胖鸟

一开始看 @BabylonLabs_io 的时候，我关注点其实也放在了Staking这块，毕竟市场对于Babylon最直观的理解，就是让更多资产参与网络安全，但后面我发现真正有趣的是其实它为什么要设计Checkpoint。

很多项目在做跨链或者生态连接时，关注的通常是资产怎么转移、消息怎么传递。但我后来发现，真正难的问题其实不是怎么连接，而是如果一个网络的状态需要被另一个网络认可，靠什么证明这件事真的发生过？

这个问题其实比怎么连接更难，过去很多方案会引入额外的验证角色，让某个系统负责告诉大家这个状态是真的，但这样做之后，新的信任点也随之产生。

而#baby 中的Checkpoint让我比较关注的地方是它没有选择再增加一个新的验证层，而是尝试让状态本身变得更容易被确认。而在这个过程中，Finality Provider负责参与状态确认，EOTS则用来约束参与者行为。

其实这也是我觉得$BABY 比较特别的地方，它并不是单纯创造一种新的质押方式，也不是建立一个封闭生态，而是在尝试提供一种可以被不同网络使用的基础能力。简单来说，它关注的不只是谁来提供安全，还包括了这个安全结果如何被验证。

这其实是未来多链环境里一个很重要的问题，当越来越多网络开始互相连接，真正困难的可能不是让它们通信，而是让它们能够长期建立信任。一个网络今天运行正常并不代表未来一定可靠，过去发生的状态、历史记录，同样需要被确认。

当然，这个方向最终能不能跑出来还需要时间验证， 基础设施项目最难的地方，从来不是设计一个机制，而是让足够多的参与者愿意长期使用。

emm...我觉得它比较值得关注的一点是它没有只解决谁来提供安全这一单一问题，而是在尝试解决当越来越多网络开始连接，彼此之间的信任应该如何建立，这个问题可能才是Babylon真正想探索的方向。

前段时间看到@BabylonLabs_io 公布的生态数据变化时，我一直在思考为什么现在很多新链，真正难的不是开发，而是上线之后如何快速建立可信的安全基础？

Babylon上线以来已经有越来越多PoS网络开始关注共享安全模式，截至目前，Babylon生态已经连接了数十个区块链网络，BTC Staking参与规模也持续增长，越来越多资产开始进入这个安全市场。

这个变化让我觉得有意思。

因为过去很多项目关注的是如何吸引用户、提高TVL，但Babylon切入的是一个新网络如何降低建立安全体系的成本的问题。

刚开始研究Babylon时，我也把它理解成一个质押类协议，但深入了解它的机制后，我发现它真正想解决的，并不是简单增加一种收益方式，而是改变新网络建立安全的路径。

传统PoS网络需要自己培养验证者，需要设计自己的经济激励，然后慢慢积累安全性。

而Babylon提供的是另一种方案，通过共享安全机制，新网络可以接入Babylon提供的安全能力，不需要从零开始建立完整的安全体系。

其中让我比较关注的是Finality Provider这一层，很多人关注Babylon时，会把重点放在质押本身，但真正让安全能力传递到不同网络中的，是这些负责最终确认和验证的角色，它们连接了资产、安全资源和应用网络之间的关系。

这也是我觉得Babylon有意思的地方。

它不是单纯创造一个新的应用场景，而是在重新定义一个网络启动时需要什么。

Babylon探索的是安全本身也可以成为一种基础设施，当然，共享安全模式未来能否形成长期生态，还有很多问题需要观察，比如不同网络的激励设计、参与者规模以及长期可持续性。

未来区块链竞争可能不只是比谁拥有更多用户和流动性，也可能比谁能够更高效地建立可信基础，这或许才是Babylon真正想探索的方向。
#baby $BABY

很多人认为 BTC 最难复制的是它的稀缺性，但最近研究@BabylonLabs_io 后，我发现真正难代替的是十多年运行过程中形成的安全共识。

这也是我最近关注$BABY 的原因

坦白说刚开始看到 BTC Staking 这个方向时，我并没有特别兴奋。过去几年，市场出现过不少让 BTC 产生收益的方案，但很多本质上只是把 BTC 包装成新的金融产品，让用户承担额外风险，却没有真正释放 Bitcoin 本身的价值。

Babylon让我改变看法的地方在于它关注的不是如何消费BTC 的流动性，而是如何利用 Bitcoin 已经形成的安全能力。

#baby 的核心思路，是通过 Trustless Bitcoin Vaults和 BTC Staking 机制，让 BTC 持有者在保持资产控制权的情况下，为 PoS 网络提供安全支持。

简单来说，Babylon 并不是要求用户把 BTC 转移到其他生态，或者依赖中心化机构托管，而是希望利用 Bitcoin 原生的安全属性，让 BTC 成为连接其他区块链网络的一种安全基础。

这个方向让我觉得有意思，它解决的是 PoS 生态长期存在的问题。很多新兴区块链并不是没有技术，也不是没有开发者，而是在早期阶段很难快速建立足够强的安全体系。验证者数量、质押规模以及经济成本，都会影响一个网络抵御攻击的能力。

而 Bitcoin 已经用十多年的时间证明了自己的安全性，如果这种安全能力未来能够被更多 PoS 网络利用，那么 BTC 的角色可能会发生变化。

当然我不会简单认为 $BABY 一定会成功，Crypto 历史上从来不缺少宏大的叙事，最终决定一个基础设施项目价值的，还是技术是否可靠、安全模型是否经过验证，以及生态是否真正采用。

过去我们理解 BTC，更多关注它的稀缺性和价格。但如果未来 Bitcoin 的安全能力可以服务更多网络，那么 BTC 的价值边界可能会被重新定义。

也许未来，我们不只是因为 Bitcoin 足够稀缺而关注它，

Est-ce que quelqu’un participe vraiment ? 1 point pour échanger 1u alpha, c’est tellement une perte, même les caleçons sont rincés, non ?

Parfois, je me rends compte qu’un jour où une entreprise est le plus susceptible de rencontrer des problèmes, ce n’est pas parce qu’il n’y a personne pour s’en occuper, mais plutôt parce que tout le monde en est un peu responsable. L’équipe produit pense que le développement a déjà confirmé. Le développement estime que l’exploitation a déjà approuvé. L’exploitation pense alors que le service juridique n’aura pas d’objection. Et quand finalement les choses tournent mal, chacun a participé, mais personne n’arrive à dire clairement à quel moment exact ça a dérapé.

Plus tard, en voyant @NewtonProtocol un très petit élément de conception, j’ai soudain pensé que je n’avais pas vraiment prêté attention à l’Authorization Receipt. Je croyais que c’était simplement un document généré après l’exécution, un peu comme des logs ou un reçu. À mes yeux, il servait surtout à archiver. Mais en continuant à regarder, je me suis rendu compte que sa position était assez étrange.

Il n’est pas placé à la fin du processus. Il se trouve aux côtés d’Authorization, de Policy et d’Operator, et fait partie du déroulement complet de l’exécution. Puis j’ai relu ce passage plusieurs fois, et j’ai enfin compris que ma compréhension initiale était décalée. Avant, beaucoup de systèmes sauvegardaient uniquement des résultats : la transaction a réussi, l’actif a été transféré, l’état a été mis à jour… tout cela laisse des traces. Mais quand il y a vraiment un problème, les gens continuent souvent à demander : qui a approuvé ? Sur quelle règle s’est-on appuyé ? Y a-t-il eu une étape sautée au milieu ? Dans beaucoup de cas, ces informations ne peuvent être reconstituées que petit à petit à partir des logs.

Newton semble justement résoudre ce problème. L’Authorization Receipt ne consigne pas seulement une exécution terminée. Il relie une autorisation donnée, la Policy correspondante, l’Operator qui l’a exécutée, puis le résultat final, en une chaîne complète. À l’avenir, si quelqu’un remet en question cette exécution, le système n’a pas besoin de refaire confiance à un nœud en particulier, ni de demander à la partie “exploitation”. Il suffit de remonter cette trace et de revalider à nouveau chaque étape : pourquoi elle est valable, et quelles preuves y correspondent.

En voyant cela, je me suis soudain rendu compte que, dans Newton, le Receipt n’est en fait pas un simple reçu. C’est plutôt une chaîne de responsabilité de l’exécution.

Donc, quand je regarde à nouveau l’Authorization Receipt, je pense que ce qu’il laisse derrière lui n’est pas une simple trace.
Ce qu’il laisse, c’est l’ensemble des preuves d’une exécution, depuis l’autorisation et le jugement jusqu’à l’achèvement. Et ce qui peut être cru durablement, peut-être, ce n’est jamais un nœud unique, ni une plateforme unique : c’est plutôt le processus lui-même, celui que n’importe qui peut vérifier à nouveau.
#newt $NEWT

Incroyable

Ces derniers temps, le mois dernier, je n’ai pas récupéré l’airdrop #ALPHA . Tout le monde est devenu aussi acharné comme ça ? Ce soir à 19h : airdrop en boîte surprise avec 251 points, c’est un peu délirant.

Ça me met mal à l’aise : un cycle ne permet de ne manger qu’une seule fois.

J’hésite un peu : faut-il attendre le nouveau projet de la semaine prochaine (#tge ) ou vaut-il mieux d’abord le récupérer ?

估计又要有一批人赚麻了

不出意外下周二会上新久违的TGE项目

这次的#tge 采用新的规则，热度不是一般的高

兄弟们都准备好了吗？

按照$GRVT Whales Market 盘前折算价，目前 FDV 大约落在 3.5 亿刀。接下来老规矩，咱用大白话简单拆解一下这个项目到底能不能打。

​从基本面看@grvt_io 确实解决了行业痛点，其首创的One Balance余额系统，让保证金不再是死钱，在交易开仓的同时还能无缝吃满底层最高11% 的自动生息收益。结合CEX 的速度 + DEX 的资产自托管的混血叙事，加之高盛和 Meta 的团队背景，长期的基本盘非常扎实。

但是最致命的黑天鹅也摆在明处，这次官方把社区空投的比例直接从 20% 一路死磕加码到了 28%！更要命的是TGE筹码当天不强制锁仓，这28％的天量筹码一旦瞬间砸向市场，对二级的承接力将是一场极度严苛的极限压力测试。

不过我个人觉得不至于是开盘即巅峰，毕竟它背后是zkSync生态航母级资源包，作为zkSync Hyperchain上的核心旗舰生态预期，GRVT不仅仅是一个交易所，它更加在底层充当着整个生态流动性中继和数据交割的重要节点。

如果开盘第一波泥石流抛压能被做市商消化，后面真实交易数据跑起来，那么它那套One Balance的飞轮效应就会开始展现威力。大资金和长线 LP 为了吃那 11% 的生息红利，会源源不断地从以太坊$ETH 主网倒灌资金进来，形成一个天然的吸金黑洞。

总的来说#grvt 机制不错，但 3.5 亿的盘前估值，短线大概率顶不住 28% 的天量空投踩踏，最好是等订单簿稳定、链上筹码洗得差不多了再进场，我的心里价位是在$0.2以下。

兄弟们觉得 $0.35 的盘前价能守住吗，你们的心理防线入场价是多少呢，不妨来聊聊

Ne te laisse plus avoir par les promesses extravagantes récentes de <c-1/>GRVT.

Cette chose n’est pas aussi favorable aux particuliers que tu pourrais le croire.

Ces derniers jours, j’ai synchronisé la documentation officielle associée à @grvt_io et j’ai fini par tomber, dans les structures de données de règlement, sur deux « venue » et « broker » dont presque personne ne parle. Après avoir retracé le chemin de compensation en profondeur, j’ai eu un frisson : tout le monde regarde comment les échanges acheteur/vendeur sont joués en surface, mais ignore totalement le fait qu’au niveau le plus bas, elle ouvre un RFQ de gré à gré aux gros acteurs et aux institutions. Les particuliers jouent avec les mêmes produits dérivés que les gros, mais ils doivent naturellement encaisser un coup de massue lié à un avantage informationnel.

J’ai remarqué qu’au sein du socle de #grvt , les opérations classiques d’achat/vente unidirectionnelles passent par un carnet d’ordres public. Mais dès qu’il est question de combinaisons d’options complexes ou de transactions par blocs d’une taille énorme, le système coupe directement ces gros flux vers des sessions d’interrogation RFQ dédiées, puis effectue un rapprochement privé hors chaîne via des courtiers de premier plan comme CoinRoutes.

Que signifie tout cela ?

Les meilleures cotations pour des blocs — celles qui permettent de réduire au minimum les coûts de couverture — ont déjà été « mangées » hors chaîne, en amont, par les institutions et les courtiers professionnels. Ce que les particuliers voient sur le carnet d’ordres public n’est en réalité que des résidus laissés. Si tu passes tout ton temps à essayer d’assortir acheteurs et vendeurs sur le carnet public, non seulement le spread acheteur-vendeur est plus large, mais tu dois aussi assumer le risque de « Legging » invisible, lié au fait que chaque jambe s’exécute séparément. Concevoir un verrouillage du pouvoir de tarification des blocs les plus juteux dans le cercle des courtiers revient, sans qu’on s’en rende compte, à ériger un mur invisible très haut pour le petit particulier.

Mais en mettant de côté cette isolation des cotations pour les particuliers, d’un point de vue macro de la résilience du système du marché, cette architecture qui sépare totalement les blocs des flux de détail est au contraire extrêmement intelligente. Les plateformes traditionnelles en chaîne connaissent, de temps en temps, des ruptures de liquidité, justement parce que les ordres dispersés des particuliers et les positions en blocs des institutions se retrouvent mélangés dans le même bassin. Dès qu’un marché se fait violemment « laver » (shake-out), si les positions multi-jambes à plusieurs millions des institutions sont contraintes de se dénouer directement sur le carnet public, cela déclenche instantanément une cascade de piétinements, explosant toutes les ordres stop-loss des particuliers. GRVT permet que les transactions de blocs empruntent un routage RFQ indépendant hors chaîne : en utilisant le mécanisme des courtiers comme zone tampon, elle neutralise discrètement, en dehors du terrain, ces têtes nucléaires destructrices.

Même si cela réduit un peu les opportunités de marges/arbitrages très lucratifs pour le détail, cela offre en échange une élasticité du carnet extrêmement stable à l’échelle de tout le marché, en pleine tempête : quand les particuliers doivent fuir, ils peuvent à tout moment retirer leurs ordres.

Vraiment, j’ai sous-estimé l’ambition de @NewtonProtocol . La nuit dernière, je suis allé(e) lire par moi-même quelques chapitres de sa “white paper” sur l’architecture cross-chain et la synchronisation de la puissance de calcul, et j’ai découvert le genre de manœuvre sulfureuse qu’il cache dans l’ombre : en réalité, son objectif est de supprimer la fragmentation des exigences de conformité qui rend le monde multi-chaînes si pénible, ainsi que la crise de confiance dans les ponts cross-chain.

La white paper de $NEWT mentionne un protocole de synchronisation “multi-chaîne” de table de puissance de calcul appelé “basé sur la spécification ELIP-008 de EigenLayer”. Le nom fait très “tech” et assez hardcore, n’est-ce pas ? À première vue, je pensais aussi qu’il s’agissait surtout de jargon. Mais en y réfléchissant un peu, je me rends compte que ça résout en fait un nœud extrêmement vicieux — et surtout, un nœud qui n’avait jamais été vraiment résolu auparavant — dans la finance on-chain : comment permettre aux applications de différentes chaînes de partager la même “carte maîtresse” de sécurité économique de niveau Ethereum, très robuste.

Tu vois, aujourd’hui le monde multi-chaînes est fortement fragmenté. Par exemple, si un stablecoin ou un projet RWA veut être émis à la fois sur Ethereum, Base, Arbitrum et Optimism, l’approche classique est extrêmement douloureuse. Soit tu dois trouver, pour chaque chaîne, un ensemble séparé de nœuds de vérification de conformité, soit tu dois utiliser ces ponts cross-chain tiers, extrêmement fragiles, qui te font passer tes journées à attendre anxieusement qu’un hacker fasse de l’empoisonnement cross-chain. Résultat : les grandes institutions n’osent tout simplement pas investir des montants colossaux sur les L2.

Avant, tout le monde considérait que c’était une tare “impossible à corriger”. Mais Newton a cette fois directement débloqué le problème à la base, via la cryptographie. Dans la logique de #newt , son réseau décentralisé de puissance de calcul n’a besoin de s’enregistrer sur le réseau principal Ethereum et d’être reproposé une seule fois dans EigenLayer. Dès que l’état — par exemple les membres des nœuds Ethereum, leurs pondérations de mise, ou les conditions de sanctions en cas de mauvaise conduite — évolue, les nœuds de Newton crachent collectivement, au niveau bas, une table de puissance de calcul “marquée” par une signature BLS, sous forme d’une racine Merkle.

La manœuvre la plus impressionnante, c’est que cette signature qui porte la garantie de sécurité économique de dizaines de milliards de nœuds du mainnet est ensuite synchronisée frénétiquement vers tous les principaux L2 via un Relayer totalement non autorisé (sans permission). Sur la chaîne cible, les smart contracts n’ont alors qu’à vérifier, avec de simples formules mathématiques, cette signature BLS agrégée : dès que la vérification de bilan passe, la table de pondération locale de la puissance de calcul se met à jour instantanément.

En gros, j’ai compris le flux de synchronisation cross-chain de la puissance de calcul basé sur ELIP-008. Ce projet ne raconte pas une histoire de conformité grandiose : il a réellement fourni une “performance cryptographique” impossible à copier par d’autres. Il transforme directement les rails de conformité multi-chaînes en un seul réseau de sécurité continu, sans couture.

Beaucoup de gens voient @NewtonProtocol et trouvent ça familier, pensant que c’est encore un de ces « frankensteins » du marché autour de ZK, MPC ou du chiffrement homomorphe. Mais si vous lisez attentivement sa whitepaper, vous verrez qu’il possède de nombreux points vraiment uniques.

Le premier élément s’appelle Newton Rego. D’autres projets ne font que des stratégies de contrôle des risques, en se limitant à des évaluations conditionnelles simples à partir d’une bibliothèque de règles toute prête. Mais $NEWT a carrément modifié de fond en comble le compilateur Rego au standard « entreprise », en y intégrant de force un paquet d’extensions cryptographiques dédié.

Cela fait que, lorsque les équipes de conformité écrivent une même déclaration en code déclaratif, elles ne peuvent pas seulement faire du filtrage par liste noire classique : elles peuvent aussi appeler directement des interfaces de bas niveau pour restaurer des signatures d’identité inter-chaînes secp256k1 et Ed25519. Cette syntaxe qui atomise la liaison entre la validation multi-signature hors-chaîne et l’origine de preuve inter-chaînes native au niveau de la chaîne est tout simplement unique dans le Web3.

Le deuxième élément est l’« enveloppe de confidentialité » de #newt . La plupart des projets qui font de la confidentialité jouent essentiellement au jeu de la « boîte noire » : ils chiffrent puis envoient. Mais NPE est une construction cryptographique hautement composite : tout en utilisant le chiffrement à seuil, elle exige en plus une double autorisation par signature de l’utilisateur + du DApp. Le plus hardcore est qu’au niveau du wire format, elle attache fermement le chiffré à un client de stratégie précis et à une intention de transaction unique. Aucun pirate ou nœud malveillant ne pourra jamais rejouer ou détourner ces données de confidentialité dans un autre contexte. À la racine, cela coupe court aux attaques de l’homme du milieu.

Ce qui fait vraiment frissonner, et ce qui est le moins réutilisable tel quel par d’autres projets, c’est son mécanisme de défi ZK de pénalisation. Les autres fabriquent des preuves ZK en écrivant patiemment des circuits sur mesure pour chaque activité de conformité spécifique : c’est douloureux et pas réutilisable. Newton, lui, s’appuie sur les propriétés d’une fonction pure du langage Rego et sur la caractéristique mathématique d’une déterminité absolue, et finit par intégrer carrément l’interpréteur de Rego dans une machine virtuelle ZK de SP1 ou Risc0 !

Le résultat est que, quelle que soit la façon dont un responsable du contrôle des risques écrit une simple ligne de code, le niveau inférieur possède automatiquement des propriétés prouvables en ZK. Lorsqu’un adversaire externe découvre qu’un nœud se comporte mal, il peut directement utiliser cette preuve ZK universelle pour renverser instantanément les nœuds malveillants sur EigenLayer et déclencher la confiscation/pénalisation d’actifs en chaîne. Et même pour s’aligner avec cette puissance de calcul, les nœuds n’ont qu’à miser une fois sur le réseau principal Ethereum : grâce à l’arbre Merkle BLS, les pondérations de puissance sont synchronisées en toute sécurité sur tous les L2 majeurs.

Récemment, j’ai découpé un script haute fréquence et ça a planté 2000 U de jetons sur le @grvt_io , en essayant de saisir une opportunité d’arbitrage. Il y a eu pas mal d’ordres qui sont bien passés, mais lors du rapprochement, j’ai directement été estomaqué : quelques ordres qui auraient dû “manger” (faire du profit) ont, en réalité, un prix d’exécution qui a dévié de quelques points de base par rapport au “juste prix” affiché au carnet. Cette exécution en conditions réelles m’a complètement réveillé. Le projet met en avant un carnet d’ordres de confidentialité hors chaîne, mais même s’il empêche les “placeurs” (siphonneurs) et les tricheurs, en situation de marché extrême, nous payons en fait une sorte d’impôt invisible lié à cette confidentialité.

Un des arguments clés du #grvt , c’est l’introduction d’un carnet d’ordres chiffré de confidentialité, piloté par des technologies de preuve à divulgation nulle (zero-knowledge). Son principe est le suivant : il brouille et chiffre, en hors-chaîne, tous les ordres, les enchères et la profondeur de tous les utilisateurs du réseau. Ainsi, les robots “clamp/夹子” de l’AMM sur la chaîne, ainsi que les équipes de quantification chasseuses, n’obtiennent même pas les données du mempool. Qu’est-ce que cela implique ? En théorie, lorsque vous passez des ordres dedans, vous bénéficiez d’un niveau très élevé de confidentialité contre la chasse (anti-réduction/anti-détection).

Mais voici l’eau froide : dans les marchés extrêmes, ce système entraîne aussi un autre défaut invisible, à savoir le “slippage” lié à une liquidité non transparente, comme une boîte mystère. Comme la profondeur totale du carnet est une boîte noire complète pour le marché, les traders ordinaires et les market makers tiers ne peuvent pas observer en temps réel, comme sur une bourse traditionnelle, l’épaisseur réelle des ordres à différents niveaux de prix.

Hier soir, lors de la panique, la vraie profondeur dans le réseau de chiffrement hors chaîne était déjà fortement stratifiée. Pourtant, l’interface affichait encore des données normales, à cause de l’isolation des données. Mon ordre d’achat s’est violemment écrasé dans une zone de vide, dépourvue de profondeur publique, ce qui m’a fait encaisser un écart de prix “invisible” que l’on n’aurait pas dû avoir sur la partie “take profit”. Ce passif lié à l’absence de carnet visible est extrêmement dangereux dans des marchés où tout se joue seconde par seconde.

Cela dit, à l’envers : après avoir critiqué le brouillard de slippage, on ne peut pas non plus nier que, côté chaîne, la compensation et l’exécution anti-malveillants sont très “dures” (rigides) sur le plan du règlement.

Ce qu’il y a de plus dégoûtant sur les plateformes traditionnelles, c’est de couper le réseau (tirer le câble) et de lancer des attaques ciblées à des endroits précis : leurs codes de liquidation sur-marge (strong liquidation) s’exécutent complètement dans des “boîtes noires” sur des serveurs centralisés. Mais le #grvt verrouille les lignes rouges les plus critiques de liquidation et la validation de l’état des comptes dans des smart contracts sur la chaîne. Que vous deviez être contraint à réduire votre position, cela est calculé automatiquement par du code de smart contract public : la plateforme ne peut pas intervenir ni modifier votre ligne de liquidation.

En résumé, le #grvt , même s’il sacrifie la transparence du carnet, aide aussi les petits investisseurs à éliminer la tentative de manipulation du “pool” (le faiseur de marché malveillant), c’est-à-dire la munition la plus toxique.

Récemment, j’ai découvert que le @NewtonProtocol a consacré beaucoup de place à parler de l’Attestation, de la Verification et du Replay. Au début, je n’ai pas vraiment compris, parce que, dans ma façon de voir les choses, tant que le résultat final est correct, la manière dont on y arrive n’a pas l’air aussi importante. Qui exécute, ce qui se passe pendant l’exécution : tout cela ressemble davantage à des détails d’implémentation qu’à des éléments qui intéressent réellement le protocole.

Ce n’est que plus tard, en refaisant toute la chaîne d’exécution dans l’ordre, depuis Transaction Intent jusqu’au Gateway, puis l’évaluation de la Policy, l’exécution par l’Operator, et enfin l’Attestation, que j’ai réalisé où se trouvait exactement mon doute.

$NEWT Ce qui compte vraiment, semble-t-il, ce n’est pas seulement de savoir si le résultat est correct, mais pourquoi ce résultat mérite d’être considéré comme fiable. Transaction Intent n’est pas exécuté directement du seul fait d’entrer dans le système : il doit d’abord passer par Policy Evaluation. Et même une fois la tâche accomplie par l’Operator, l’exécution terminée ne devient pas automatiquement le résultat final ; ensuite il faut encore une Attestation, et si nécessaire, on peut même faire un Replay.

En regardant la suite, je me rends de plus en plus compte qu’elles répondent toutes à une question : cette exécution a-t-elle été réalisée conformément aux règles que tout le réseau reconnaît collectivement ?

C’est aussi à ce moment-là que j’ai compris que #Newt ne consigne pas le résultat d’une exécution unique, mais le déroulement de cette exécution. Plus tard, j’y ai repensé attentivement et j’ai soudain pensé à une question que je n’avais jamais vraiment prise au sérieux auparavant.

Pourquoi tant de systèmes accordent-ils autant d’importance au résultat de la preuve, alors que Newton a consacré autant d’efforts à prouver le processus ?

Je me dis de plus en plus que, derrière ces deux approches, il y a en réalité deux façons totalement différentes de construire la confiance. Si l’on ne fait que prouver le résultat, à la fin, il faut encore faire confiance à la personne (ou au système) qui vous donne ce résultat. Mais si tout le processus d’exécution peut être vérifié, alors la confiance ne repose plus sur un seul Operator : ce n’est plus une personne à croire, mais bien un chemin d’exécution que n’importe qui peut reproduire et vérifier.

C’est pourquoi je pense que Newton ne cherche pas vraiment à « refondre » le flux d’exécution en soi : ce qu’il remet surtout en question, c’est une hypothèse par défaut qui existe depuis de nombreuses années, à savoir « le résultat est correct, donc c’est suffisant » ?

Au moins, aux yeux de Newton, ce n’est probablement pas assez.
Peut-être est-ce là la véritable signification de l’Attestation, de la Verification et du Replay. Elles ne protègent pas seulement le résultat, mais tout le processus qui fait que ce résultat tient debout.

Ces derniers jours, je me suis toujours replongé dans le blog de <b>@grvt_io </b> et un terme revient particulièrement souvent : « Capital Productivity ». Au début, je n’y prêtais pas vraiment attention. Je me disais que c’était forcément un concept marketing. Après tout, n’est-ce pas la liquidité, les frais et la vitesse de négociation qui font la différence entre les exchanges ? Un exchange qui ne cesse de parler de productivité du capital, ça ne ressemble pas vraiment à ce qu’un exchange devrait dire.

Donc, quand je suis tombé pour la première fois sur One Balance et Unified Margin, je l’ai interprété à fond dans l’idée d’optimiser l’expérience. Puis j’ai regroupé plusieurs articles et je les ai relus. À l’origine, je voulais simplement comprendre quel problème Unified Margin résout. Mais au fil de la lecture, ça devenait de plus en plus étrange.

L’officiel discute presque jamais de la vitesse de négociation, et n’insiste pas sur Hybrid Exchange. En revanche, on revient sans cesse sur Capital Productivity et Capital Drag, et même sur la suite, le Yield Layer : tout le temps, on parle de la même chose.

C’est là que j’ai réalisé que je me trompais peut-être dès le départ. GRVT semble poser une autre question : pourquoi un même capital ne peut-il servir qu’un seul objectif ? C’est aussi à ce moment-là que j’ai compris pourquoi l’officiel insiste autant sur Capital Drag. Ce qui serait véritablement « gaspillé », ce n’est peut-être pas la vitesse de négociation, mais plutôt le temps où le capital attend, migre et se reconfigure sans cesse.

Ensuite, je suis retourné lire One Balance, Unified Margin et Yield Layer, et j’ai soudain eu l’impression qu’ils ressemblent à trois fonctionnalités différentes. En réalité, ils répondent en continu à la question : est-ce qu’on peut faire en sorte qu’une même portion de capital ne s’arrête pas lorsqu’on change d’usage ?

Du coup, maintenant que je reviens en arrière, je trouve de plus en plus que ce que GRVT veut vraiment refondre, ce n’est pas un exchange. C’est plutôt un défi lancé à une habitude par défaut du système financier que presque personne ne remet en question : pourquoi, lorsqu’un capital a accompli une tâche, doit-il forcément mettre fin à cette étape puis en recommencer une autre ?

Au moins pour l’instant, je me rapproche de plus en plus d’une compréhension : ce que GRVT cherche à préserver, ce n’est pas un compte particulier, ni un type de produit précis, mais la continuité d’une même portion de capital.
La négociation, les revenus, l’investissement et les paiements ne sont pas, à la base, quatre capitaux différents ; ce devrait être la même portion de capital, qui assume des rôles différents à des étapes différentes.

Donc, maintenant, en relisant Capital Productivity, je me dis au contraire que ce qu’il cherche à optimiser n’est pas l’efficacité de trading, mais la manière dont le capital circule dans l’ensemble du système financier.
#grvt

Ça faisait longtemps que je n’étais pas venu à une nouvelle TGE. Et récemment, le tout nouveau @grvt_io est encore une sacrée opportunité.

Le @grvt_io lance aussi une activité Booster très avantageuse : avec 2 points, vous pouvez échanger contre des tokens d’une valeur de 8u. Ne le manquez surtout pas.

Au début, en regardant l’architecture HEX du @grvt_io , je me posais une question : si le matching des transactions se fait hors chaîne, alors comment la chaîne peut-elle croire ce qui se passe ?

D’après ma compréhension, la plus grande valeur de la blockchain, c’est la déterminisme. Si le processus de matching le plus central quitte la chaîne, alors en quoi est-ce différent des bourses d’échange traditionnelles ? Donc au début, je pensais que GRVT n’était qu’un compromis entre performances et décentralisation. Mais en revoyant son flux d’exécution, j’ai réalisé que je m’étais trompé dès le départ.

#grvt ne résout pas d’abord le problème de savoir où placer les transactions, mais plutôt comment faire en sorte que l’état des transactions généré hors chaîne soit finalement reconnu par la chaîne. Dans sa conception, les commandes entrent d’abord dans le Off-chain Matching Engine pour réaliser le matching : ainsi, les transactions à haute fréquence n’ont pas besoin d’attendre la confirmation on-chain, et peuvent obtenir une efficacité d’exécution proche de celle des bourses traditionnelles.

Fait intéressant : le fait qu’une transaction soit conclue ne signifie pas que l’état final est définitivement établi. Le résultat doit passer par un On-chain Settlement : la confirmation finale est effectuée par des règles on-chain et des smart contracts. En d’autres termes, le hors chaîne gère le calcul haute fréquence, tandis que la chaîne gère l’état final.

C’est là que j’ai compris que #grvt cherchait à délimiter la frontière entre la génération de l’état et sa définition. Le Matching Engine produit le résultat des transactions, la Settlement Layer confirme l’état des actifs, et le Smart Contract Vault garantit que les avoirs des utilisateurs ne dépendent pas entièrement d’un registre centralisé.

Du coup, je pense que le Hybrid Exchange n’est pas simplement un assemblage de CEX et DEX. Ce qu’il change réellement, c’est la frontière de confiance dans le système de trading. Toutes les étapes ne doivent pas forcément avoir lieu on-chain, mais l’impact final sur l’état des actifs doit être confirmé par des règles on-chain.

Ensuite, en regardant Unified Balance, je me suis rendu compte que cette logique ne s’applique pas seulement au règlement des transactions : elle traverse toute la gestion de l’état des actifs. Les transactions, les marges et les profits ne sont plus des états de compte séparés : ils circulent dans un système unifié, ce qui empêche les actifs d’être figés dans un seul contexte, et leur permet d’évoluer en continu.

Maintenant, je dirais que GRVT vise surtout à mettre en place un mécanisme : comment faire émerger des états hors chaîne qui puissent entrer dans la réalité on-chain, puis devenir une réalité reconnue par le monde on-chain.

Je pensais toujours qu’un système d’autorisation, ce qui compte le plus, ce sont les règles.

Tant que la Policy est suffisamment rigoureuse, le système peut déterminer quels échanges doivent être exécutés et lesquels doivent être refusés. C’est donc au début, en lisant le Whitepaper @NewtonProtocol , que je me concentrais sur la Rego Policy et le Authorization Flow.

Ce n’est que plus tard, en revenant à la section Data Provider, que j’ai réalisé que j’avais ignoré un problème plus fondamental : même si les règles sont parfaitement exactes, si les données en entrée ne sont pas dignes de confiance, le verdict final perd encore tout son sens.

La Policy Evaluation de $NEWT ne fait pas que « exécuter directement » des règles. L’Operator doit appeler des données externes telles que l’Oracle Price, le Sanctions Feed, le Risk Score, etc., puis intégrer ces entrées dans la Rego Policy pour trancher. Mais ces données n’existent pas elles-mêmes nativement on-chain. D’un coup, je me suis rendu compte que c’est probablement un problème auquel sont confrontés tous les systèmes d’automatisation on-chain.

On discute beaucoup de savoir si les smart contracts sont dignes de confiance, mais on se demande rarement si, au moment où le système prend une décision, les données qu’il voit sont fiables. Sont-elles réellement fiables ?

Si le jugement sur l’état d’une adresse est erroné, si le scoring du risque est biaisé ou si différents nœuds obtiennent des données incohérentes, alors même si les calculs de Policy, d’Attestation et de Consensus sont corrects, il se peut que le résultat « correct » ne soit que le bon résultat basé sur de mauvaises entrées.

Le design de #newt pour ce problème est vraiment intéressant : il ne choisit pas de devenir le seul fournisseur de données, mais transforme le Data Provider en module « plug-in ». L’Operator peut exécuter indépendamment un WASM Data Provider, obtenir des données externes dans un environnement isolé, puis produire une ECDSA Attestation à partir des données qu’il observe, de sorte que l’entrée elle-même entre aussi dans le périmètre de la vérification.

En arrivant à ce point, j’ai compris que j’avais mal interprété les choses : je pensais que le cœur de Newton consistait à rendre les règles vérifiables, mais en réalité, il s’agit d’abord de faire en sorte que, lors de l’exécution des règles, le système fasse face à la même réalité digne de confiance. La Policy détermine comment le système juge, et le Data Provider détermine ce que le système voit.

La vraie difficulté n’a jamais été de faire exécuter aux machines des décisions selon des règles ; le plus dur, c’est de s’assurer qu’avant que la machine ne prenne une décision, le monde qu’elle perçoit n’a pas été altéré par des entrées incorrectes. C’est peut-être exactement la signification de la conception de l’écosystème Data Provider de $NEWT .

À l’avenir, la compétition des systèmes on-chain ne portera pas seulement sur les règles et l’exécution, mais sur qui parviendra à faire en sorte que tout le réseau, avant de prendre des décisions, s’appuie d’abord sur la même réalité.