Binance Square
假装在抄底
2.8k Publications

假装在抄底

Compte Square Vérifié+
有钱不上北上广,落难必空以太坊,你空大饼我硬扛, 主打一个心态强!! 现货合约返佣:MY6751 钱包返佣:MY6751
Ouvert au trading
Détenteur pour BNB
Détenteur pour BNB
Trade fréquemment
1.1 an(s)
1.2K+ Suivis
33.3K+ Abonnés
19.2K+ J’aime
Publications
Portefeuille
PINNED
·
--
⚠️ Rappel les frères : l’invitation Binance est MY6751, vous économisez 30% de frais (les plus élevés sur tout le web), crédit automatique. Les anciens comptes déjà utilisés peuvent aussi le renseigner. Alpha, spot, compétition de trading, contrats, et actions tokenisées : tout est à -30%. En 3 étapes : 1️⃣ App Binance → Wallet → Inviter des amis 2️⃣ Cliquez sur « Saisir le code d’invitation », réduction de 30% des frais 3️⃣ Entrez MY6751
⚠️ Rappel les frères : l’invitation Binance est MY6751, vous économisez 30% de frais (les plus élevés sur tout le web), crédit automatique. Les anciens comptes déjà utilisés peuvent aussi le renseigner. Alpha, spot, compétition de trading, contrats, et actions tokenisées : tout est à -30%.

En 3 étapes :
1️⃣ App Binance → Wallet → Inviter des amis
2️⃣ Cliquez sur « Saisir le code d’invitation », réduction de 30% des frais
3️⃣ Entrez MY6751
Article
Voir la traduction
跨链授权最怕的不是规则写错,而是目标链还拿着旧名单今天我想聊一个不太热闹、但很容易出真实问题的细节:跨链缓存状态。 很多人看到 Newton 的多链叙事,会自然理解成“一套规则到处执行”。这个方向当然诱人,开发者不用在每条链重复搭风控,不同链上的自动化代理也能复用同一套授权逻辑。 但我越看越觉得,多链授权真正难的不是把 Policy 复制过去,而是让每条链在正确时间看到同一个安全状态。 1. 主链更新,不代表目标链立刻知道 Newton 的 operator 注册、质押、惩罚等安全状态主要发生在 Ethereum。问题是,Base、Arbitrum、Optimism 这类目标链执行时,不一定每一秒都直接读取 Ethereum 的实时状态。为了降低成本,它们可能依赖同步过来的 operator state,也就是缓存状态。 缓存本身不是坏事。跨链实时读取贵、慢、复杂,用缓存能让目标链验证更轻,用户体验也更顺。但授权系统里的缓存和普通页面缓存不一样。 普通网页晚更新几十秒,最多看到旧头像;授权网络晚更新几十秒,可能意味着目标链还在相信一个已经退出、被惩罚,或者权重已经变化的 operator 集合。 这就不是小问题了。 2. 省成本和用旧状态之间,总有一条线 假设 Ethereum 上某个 operator 被 slash,或者验证者集合刚完成更新。主链已经知道这件事,但 Base 上的轻量验证合约还没同步最新状态。此时有一个 AI 代理提交交易,目标链拿着旧 operator state 验证证明。 从目标链视角看,一切都像是正常的;从全局安全视角看,它可能已经落后了。 这就是跨链授权最尴尬的地方:你想要低成本,就难免引入状态延迟;你想要实时安全,就会牺牲速度和费用。没有免费午餐。 所以我不会简单说缓存不好。真正要看的是 Newton 怎么定义缓存的安全边界: 缓存最长能滞后多久; operator 集合发生重大变化时,目标链是否强制暂停; 证明里是否写明使用的是哪一版 operator state; 如果目标链状态过旧,交易是拒绝、等待,还是进入降级模式; 用户事后能不能从收据里看到当时使用的状态版本。 这些细节决定了多链授权是可靠工程,还是漂亮口号。 3. 跨链延迟应该写进执行收据 我觉得最实用的设计,是把跨链状态版本写进每次执行收据里。 比如一笔交易在 Base 上执行,收据不应该只写“验证通过”,而要写: 目标链:Base; 安全来源:Ethereum; operator state 版本:某个区块高度; 同步延迟:多少秒或多少个区块; 证明生成时间; 证明过期时间; 是否处于正常模式或降级模式。 普通用户不一定会逐项检查,但一旦出问题,这些信息能决定责任归属。 如果目标链用了过旧状态,用户至少能知道问题不是策略本身,也不是他提交的意图,而是跨链同步环节慢了。对机构来说,这种区分尤其重要,因为审计不会接受一句“系统当时判断通过”。 4. 缓存状态还会影响退出和惩罚 跨链缓存还有一个更微妙的点:退出和惩罚是否及时生效。 如果某个 operator 退出 Ethereum 上的验证集合,按理说它不应该继续参与新的授权判断。但目标链缓存没更新时,它可能还在旧名单里。 反过来,如果某个 operator 作恶被 slash,主链已经记录惩罚,目标链却还没同步,这段时间里它的旧签名是否仍然被接受?如果被接受,惩罚就没有及时传导;如果直接拒绝所有旧状态,又可能误伤正常交易。 这就是多链系统最难处理的灰区。不是非黑即白,而是一段状态传播的过渡期。 Newton 如果想把这件事做扎实,最好把状态变化分成几类: 普通权重调整,可以允许短暂缓存; operator 主动退出,要设置明确截止区块; 被 slash 或疑似攻击,要触发更激进的同步或暂停; 目标链长时间不同步时,应停止接受新授权,而不是继续拿旧名单凑合。 这听起来麻烦,但资金系统本来就该麻烦一点。 5. 多链不是“到处都能跑”,而是“每条链都知道自己凭什么跑” 很多项目喜欢说 chain-agnostic,好像支持越多链越厉害。可在授权网络里,我更关心另一句话:每条链能不能清楚说明自己基于哪份安全状态做判断。 如果 Ethereum 是安全来源,目标链就要承认自己不是实时上帝视角。 如果使用缓存,就要公开缓存版本。 如果缓存过期,就要拒绝或降级。 如果跨链同步失败,就要让用户看见,而不是把风险藏在后台。 这不是唱衰 Newton,反而是我觉得 $NEWT 这条路线真正值得观察的地方。它不是简单做一个 AI 交易工具,而是尝试把交易前授权做成跨链基础设施。基础设施最怕的不是概念不够大,而是边界不够清楚。 6. 我会用三个问题观察 Newton 的多链能力 第一,目标链能不能显示自己使用的 operator state 版本。 第二,状态滞后时有没有明确的拒绝、等待或降级规则。 第三,出现惩罚、退出、密钥轮换时,旧缓存能不能在合理时间内失效。 如果这三点做得扎实,Newton 的多链授权就不只是“一套规则多处部署”,而是每条链都能基于可追溯状态做判断。 我现在越来越觉得,链上自动化未来的竞争,不是看谁把 AI 包装得更聪明,而是看谁能把复杂系统里的每个判断依据摊开。@NewtonProtocol 若能把 cached operator state 这类细节做透明,$NEWT 的价值会比单纯喊“多链 AI 代理”更硬。#Newt

跨链授权最怕的不是规则写错,而是目标链还拿着旧名单

今天我想聊一个不太热闹、但很容易出真实问题的细节:跨链缓存状态。
很多人看到 Newton 的多链叙事,会自然理解成“一套规则到处执行”。这个方向当然诱人,开发者不用在每条链重复搭风控,不同链上的自动化代理也能复用同一套授权逻辑。
但我越看越觉得,多链授权真正难的不是把 Policy 复制过去,而是让每条链在正确时间看到同一个安全状态。
1. 主链更新,不代表目标链立刻知道
Newton 的 operator 注册、质押、惩罚等安全状态主要发生在 Ethereum。问题是,Base、Arbitrum、Optimism 这类目标链执行时,不一定每一秒都直接读取 Ethereum 的实时状态。为了降低成本,它们可能依赖同步过来的 operator state,也就是缓存状态。
缓存本身不是坏事。跨链实时读取贵、慢、复杂,用缓存能让目标链验证更轻,用户体验也更顺。但授权系统里的缓存和普通页面缓存不一样。
普通网页晚更新几十秒,最多看到旧头像;授权网络晚更新几十秒,可能意味着目标链还在相信一个已经退出、被惩罚,或者权重已经变化的 operator 集合。
这就不是小问题了。
2. 省成本和用旧状态之间,总有一条线
假设 Ethereum 上某个 operator 被 slash,或者验证者集合刚完成更新。主链已经知道这件事,但 Base 上的轻量验证合约还没同步最新状态。此时有一个 AI 代理提交交易,目标链拿着旧 operator state 验证证明。
从目标链视角看,一切都像是正常的;从全局安全视角看,它可能已经落后了。
这就是跨链授权最尴尬的地方:你想要低成本,就难免引入状态延迟;你想要实时安全,就会牺牲速度和费用。没有免费午餐。
所以我不会简单说缓存不好。真正要看的是 Newton 怎么定义缓存的安全边界:
缓存最长能滞后多久;
operator 集合发生重大变化时,目标链是否强制暂停;
证明里是否写明使用的是哪一版 operator state;
如果目标链状态过旧,交易是拒绝、等待,还是进入降级模式;
用户事后能不能从收据里看到当时使用的状态版本。
这些细节决定了多链授权是可靠工程,还是漂亮口号。
3. 跨链延迟应该写进执行收据
我觉得最实用的设计,是把跨链状态版本写进每次执行收据里。
比如一笔交易在 Base 上执行,收据不应该只写“验证通过”,而要写:
目标链:Base;
安全来源:Ethereum;
operator state 版本:某个区块高度;
同步延迟:多少秒或多少个区块;
证明生成时间;
证明过期时间;
是否处于正常模式或降级模式。
普通用户不一定会逐项检查,但一旦出问题,这些信息能决定责任归属。
如果目标链用了过旧状态,用户至少能知道问题不是策略本身,也不是他提交的意图,而是跨链同步环节慢了。对机构来说,这种区分尤其重要,因为审计不会接受一句“系统当时判断通过”。
4. 缓存状态还会影响退出和惩罚
跨链缓存还有一个更微妙的点:退出和惩罚是否及时生效。
如果某个 operator 退出 Ethereum 上的验证集合,按理说它不应该继续参与新的授权判断。但目标链缓存没更新时,它可能还在旧名单里。
反过来,如果某个 operator 作恶被 slash,主链已经记录惩罚,目标链却还没同步,这段时间里它的旧签名是否仍然被接受?如果被接受,惩罚就没有及时传导;如果直接拒绝所有旧状态,又可能误伤正常交易。
这就是多链系统最难处理的灰区。不是非黑即白,而是一段状态传播的过渡期。
Newton 如果想把这件事做扎实,最好把状态变化分成几类:
普通权重调整,可以允许短暂缓存;
operator 主动退出,要设置明确截止区块;
被 slash 或疑似攻击,要触发更激进的同步或暂停;
目标链长时间不同步时,应停止接受新授权,而不是继续拿旧名单凑合。
这听起来麻烦,但资金系统本来就该麻烦一点。
5. 多链不是“到处都能跑”,而是“每条链都知道自己凭什么跑”
很多项目喜欢说 chain-agnostic,好像支持越多链越厉害。可在授权网络里,我更关心另一句话:每条链能不能清楚说明自己基于哪份安全状态做判断。
如果 Ethereum 是安全来源,目标链就要承认自己不是实时上帝视角。
如果使用缓存,就要公开缓存版本。
如果缓存过期,就要拒绝或降级。
如果跨链同步失败,就要让用户看见,而不是把风险藏在后台。
这不是唱衰 Newton,反而是我觉得 $NEWT 这条路线真正值得观察的地方。它不是简单做一个 AI 交易工具,而是尝试把交易前授权做成跨链基础设施。基础设施最怕的不是概念不够大,而是边界不够清楚。
6. 我会用三个问题观察 Newton 的多链能力
第一,目标链能不能显示自己使用的 operator state 版本。
第二,状态滞后时有没有明确的拒绝、等待或降级规则。
第三,出现惩罚、退出、密钥轮换时,旧缓存能不能在合理时间内失效。
如果这三点做得扎实,Newton 的多链授权就不只是“一套规则多处部署”,而是每条链都能基于可追溯状态做判断。
我现在越来越觉得,链上自动化未来的竞争,不是看谁把 AI 包装得更聪明,而是看谁能把复杂系统里的每个判断依据摊开。@NewtonProtocol 若能把 cached operator state 这类细节做透明,$NEWT 的价值会比单纯喊“多链 AI 代理”更硬。#Newt
·
--
Haussier
Aujourd’hui, j’ai étudié la logique d’intégration du contrat de Newton, et ce qui m’a le plus marqué n’est pas les quatre mots « la preuve est acceptée », mais le fait qu’elle ajoute de nombreuses contraintes à la preuve : l’expéditeur, le contrat cible, le montant, le calldata, l’identifiant de chaîne (chainId) et le bloc d’expiration doivent, pour l’essentiel, tous être liés. En termes simples : l’Attestation n’est pas une carte VIP valable longtemps ; c’est plutôt un billet de train aller simple. La ligne, le passager, l’itinéraire et l’heure sont verrouillés. Une fois utilisé, il est annulé, et s’il y a un dépassement de délai, il devient invalide. C’est contraignant, mais ça permet de prévenir une forme de risque très concrète : une ancienne autorisation réutilisée pour exécuter à nouveau la même opération, ou déplacée sur une autre chaîne et utilisée de façon abusive. Le défi est là aussi. Si la durée de validité est trop courte, l’agent IA peut n’avoir terminé l’évaluation de la Policy qu’au moment où la chaîne cible est saturée : le billet expire avant d’être utilisable. Si elle est trop longue, le vieux billet peut redevenir une faille, une surface de risque. Donc en regardant @NewtonProtocol , je me suis dit que ce qui doit vraiment être affiné derrière n’est pas « est-ce qu’on peut envoyer une preuve », mais plutôt la fenêtre de validité à attribuer à chaque type de tâche : pour un simple virement, un retrait de dépôt (撤仓), une protection de liquidation (清算保护), ou une exécution inter-chaînes, on ne devrait pas utiliser la même durée d’expiration. Si l’ensemble de l’autorisation $NEWT peut rendre clairement la « durée de vie du billet aller simple », alors l’utilisateur saura au moins : quand cette opération peut être utilisée, quand elle devient invalide, et pourquoi elle ne peut pas être réutilisée pour payer deux fois. Pour l’automatisation on-chain, c’est plus rassurant qu’une simple phrase du type « vérifiée ».🎫 #Newt
Aujourd’hui, j’ai étudié la logique d’intégration du contrat de Newton, et ce qui m’a le plus marqué n’est pas les quatre mots « la preuve est acceptée », mais le fait qu’elle ajoute de nombreuses contraintes à la preuve : l’expéditeur, le contrat cible, le montant, le calldata, l’identifiant de chaîne (chainId) et le bloc d’expiration doivent, pour l’essentiel, tous être liés.

En termes simples : l’Attestation n’est pas une carte VIP valable longtemps ; c’est plutôt un billet de train aller simple. La ligne, le passager, l’itinéraire et l’heure sont verrouillés. Une fois utilisé, il est annulé, et s’il y a un dépassement de délai, il devient invalide. C’est contraignant, mais ça permet de prévenir une forme de risque très concrète : une ancienne autorisation réutilisée pour exécuter à nouveau la même opération, ou déplacée sur une autre chaîne et utilisée de façon abusive.

Le défi est là aussi. Si la durée de validité est trop courte, l’agent IA peut n’avoir terminé l’évaluation de la Policy qu’au moment où la chaîne cible est saturée : le billet expire avant d’être utilisable. Si elle est trop longue, le vieux billet peut redevenir une faille, une surface de risque.
Donc en regardant @NewtonProtocol , je me suis dit que ce qui doit vraiment être affiné derrière n’est pas « est-ce qu’on peut envoyer une preuve », mais plutôt la fenêtre de validité à attribuer à chaque type de tâche : pour un simple virement, un retrait de dépôt (撤仓), une protection de liquidation (清算保护), ou une exécution inter-chaînes, on ne devrait pas utiliser la même durée d’expiration.

Si l’ensemble de l’autorisation $NEWT peut rendre clairement la « durée de vie du billet aller simple », alors l’utilisateur saura au moins : quand cette opération peut être utilisée, quand elle devient invalide, et pourquoi elle ne peut pas être réutilisée pour payer deux fois. Pour l’automatisation on-chain, c’est plus rassurant qu’une simple phrase du type « vérifiée ».🎫 #Newt
Ces deux derniers jours, en regardant des documents sur GRVT, je n’ai finalement pas été si longtemps touché par le mot « rapide ». La plateforme de trading dit qu’elle est rapide, et tout le monde le dit aussi ; ce qui m’a vraiment arrêté, c’est une autre question : une fois que tout est « terminé vite », comment prouver le résultat ? Beaucoup de problèmes des produits de transactions on-chain tiennent au fait que c’est lent : signature, confirmation, Gas, attente… Une fois la séquence passée, les opportunités ont déjà disparu. Mais si l’on fait faire le matching en dehors de la chaîne pour gagner en vitesse, de nouvelles interrogations apparaissent : puisque le processus n’est pas entièrement on-chain, pourquoi les utilisateurs devraient-ils croire que la dernière exécution, le règlement et l’état du compte ne posent aucun problème ? C’est précisément ce qui m’importe lorsque je regarde l’architecture Validium / hybride de @grvt_io . Le matching hors-chaîne peut gérer la vitesse et la profondeur, tandis que le règlement on-chain garantit les frontières des actifs ; mais au milieu, il ne peut pas rester juste une phrase : « la plateforme dit que c’est OK ». Plus on se rapproche de l’expérience d’un CEX, plus il faut compléter des résultats vérifiables, sinon on n’a fait que remplacer une boîte noire par une autre. Pour l’utilisateur lambda, ce n’est pas besoin d’en faire quelque chose de particulièrement ésotérique. Quand vous passez un ordre, l’exigence minimale est la suivante : le prix d’exécution doit être explicable, le flux des fonds doit pouvoir être vérifié, et l’état du système ne doit pas être modifié arbitrairement par l’équipe en coulisses. La rapidité, bien sûr, c’est bien, mais la vitesse ne doit pas devenir : « je n’ai pas eu le temps de vérifier et vous avez déjà exécuté ». J’ai déjà connu des plateformes dont l’expérience était très fluide et dont la relecture était difficile ; au quotidien, on ne le sent pas. C’est seulement quand on se retrouve avec des piqûres, des slippages, ou des exécutions anormales qu’on réalise qu’on n’a plus que des captures d’écran à remonter et des échanges avec le support. Le pire pour un système de trading n’est pas qu’il y ait un problème, c’est qu’après coup on ne puisse pas l’expliquer. Je pense que, pour GRVT, ce qui est vraiment difficile n’est pas de faire l’interface comme un CEX ; c’est, après avoir rendu l’expérience aussi fluide, de conserver cette forme de certitude si importante propre au trading on-chain. La vitesse donne envie d’utiliser ; la vérification donne envie d’utiliser sur le long terme. S’il manque l’un des deux, ce n’est pas complet. #grvt
Ces deux derniers jours, en regardant des documents sur GRVT, je n’ai finalement pas été si longtemps touché par le mot « rapide ». La plateforme de trading dit qu’elle est rapide, et tout le monde le dit aussi ; ce qui m’a vraiment arrêté, c’est une autre question : une fois que tout est « terminé vite », comment prouver le résultat ?

Beaucoup de problèmes des produits de transactions on-chain tiennent au fait que c’est lent : signature, confirmation, Gas, attente… Une fois la séquence passée, les opportunités ont déjà disparu. Mais si l’on fait faire le matching en dehors de la chaîne pour gagner en vitesse, de nouvelles interrogations apparaissent : puisque le processus n’est pas entièrement on-chain, pourquoi les utilisateurs devraient-ils croire que la dernière exécution, le règlement et l’état du compte ne posent aucun problème ?

C’est précisément ce qui m’importe lorsque je regarde l’architecture Validium / hybride de @grvt_io . Le matching hors-chaîne peut gérer la vitesse et la profondeur, tandis que le règlement on-chain garantit les frontières des actifs ; mais au milieu, il ne peut pas rester juste une phrase : « la plateforme dit que c’est OK ». Plus on se rapproche de l’expérience d’un CEX, plus il faut compléter des résultats vérifiables, sinon on n’a fait que remplacer une boîte noire par une autre.

Pour l’utilisateur lambda, ce n’est pas besoin d’en faire quelque chose de particulièrement ésotérique. Quand vous passez un ordre, l’exigence minimale est la suivante : le prix d’exécution doit être explicable, le flux des fonds doit pouvoir être vérifié, et l’état du système ne doit pas être modifié arbitrairement par l’équipe en coulisses. La rapidité, bien sûr, c’est bien, mais la vitesse ne doit pas devenir : « je n’ai pas eu le temps de vérifier et vous avez déjà exécuté ».

J’ai déjà connu des plateformes dont l’expérience était très fluide et dont la relecture était difficile ; au quotidien, on ne le sent pas. C’est seulement quand on se retrouve avec des piqûres, des slippages, ou des exécutions anormales qu’on réalise qu’on n’a plus que des captures d’écran à remonter et des échanges avec le support. Le pire pour un système de trading n’est pas qu’il y ait un problème, c’est qu’après coup on ne puisse pas l’expliquer.

Je pense que, pour GRVT, ce qui est vraiment difficile n’est pas de faire l’interface comme un CEX ; c’est, après avoir rendu l’expérience aussi fluide, de conserver cette forme de certitude si importante propre au trading on-chain. La vitesse donne envie d’utiliser ; la vérification donne envie d’utiliser sur le long terme. S’il manque l’un des deux, ce n’est pas complet. #grvt
Article
Newton ne devrait pas être compris comme un robot de trading : c’est plutôt une « machine de validation » avant la transactionCes deux derniers jours, en lisant les classements, j’ai vu beaucoup de gens discuter du stack technologique de @NewtonProtocol . TEE, ZK, AVS, Policy Engine… toute une série de termes, ça donne vite le vertige. Je voudrais prendre un angle plus concret : si l’automatisation on-chain ressemble à un départ de camion, alors Newton n’est ni le conducteur, ni le destinataire. Il ressemble plutôt à la barrière avant l’envoi. La barrière ne répond qu’à une seule question : ce chargement de ce camion a-t-il le droit de sortir maintenant ? Cette différence est cruciale. Beaucoup de gens, quand ils entendent « trading automatisé par IA », pensent d’abord : est-ce que ça peut m’aider à acheter au plus bas, vendre au plus haut, et battre le marché ? Mais la valeur centrale de Newton n’est pas là. Il traite d’une autre catégorie de problème : quand vous confiez une partie des permissions à un programme agent, comment prouver que l’agent n’a pas franchi les limites que vous lui avez autorisées.

Newton ne devrait pas être compris comme un robot de trading : c’est plutôt une « machine de validation » avant la transaction

Ces deux derniers jours, en lisant les classements, j’ai vu beaucoup de gens discuter du stack technologique de @NewtonProtocol . TEE, ZK, AVS, Policy Engine… toute une série de termes, ça donne vite le vertige.
Je voudrais prendre un angle plus concret : si l’automatisation on-chain ressemble à un départ de camion, alors Newton n’est ni le conducteur, ni le destinataire. Il ressemble plutôt à la barrière avant l’envoi. La barrière ne répond qu’à une seule question : ce chargement de ce camion a-t-il le droit de sortir maintenant ?
Cette différence est cruciale. Beaucoup de gens, quand ils entendent « trading automatisé par IA », pensent d’abord : est-ce que ça peut m’aider à acheter au plus bas, vendre au plus haut, et battre le marché ? Mais la valeur centrale de Newton n’est pas là. Il traite d’une autre catégorie de problème : quand vous confiez une partie des permissions à un programme agent, comment prouver que l’agent n’a pas franchi les limites que vous lui avez autorisées.
·
--
Haussier
L’après-midi, j’ai aidé un ami à vérifier une transaction automatisée on-chain. Il m’a envoyé une capture d’écran et m’a demandé : « Newton a déjà réussi, pourquoi la transaction n’a finalement pas abouti ? » La question est très typique. Beaucoup de gens confondent « l’autorisation approuvée » et « la transaction conclue ». En réalité, il y a plusieurs étapes entre les deux. Newton ressemble davantage à une machine de preuve des risques avant la transaction : il évalue d’abord si l’opération correspond à vos règles, par exemple l’état d’identité, la provenance des fonds, les montants, le protocole visé, la fenêtre de temps. Une fois validé, il fournit une preuve que « cette intention peut être autorisée à passer ». Mais le fait que la transaction aboutisse dépend aussi de l’encombrement de la chaîne cible, du Gas, de la profondeur de la liquidité, du slippage et de l’état du contrat. C’est comme un contrôle d’accès par reconnaissance faciale : le fait que vous soyez autorisé à entrer dans l’immeuble ne veut pas dire que l’ascenseur arrivera tout de suite. 😅 Je pense que c’est précisément là que le $NEWT mérite d’être démêlé : ce n’est pas un système qui garantit que vous gagnerez de l’argent, ni une garantie que chaque transaction réussira, mais plutôt une façon de clarifier à l’avance si un agent a dépassé ses autorisations. À l’avenir, quand vous regardez Newton, ne vous contentez pas de surveiller le résultat “succès/échec” : il faut aussi comprendre à quelle étape l’échec se produit — Policy non validée, preuve expirée, exécution sur la chaîne cible qui échoue, ou bien manque de liquidité. En séparant l’autorisation, l’exécution et le règlement, l’IA on-chain ne deviendra pas un grand mystère. @NewtonProtocol #Newt
L’après-midi, j’ai aidé un ami à vérifier une transaction automatisée on-chain. Il m’a envoyé une capture d’écran et m’a demandé : « Newton a déjà réussi, pourquoi la transaction n’a finalement pas abouti ? »

La question est très typique. Beaucoup de gens confondent « l’autorisation approuvée » et « la transaction conclue ». En réalité, il y a plusieurs étapes entre les deux. Newton ressemble davantage à une machine de preuve des risques avant la transaction : il évalue d’abord si l’opération correspond à vos règles, par exemple l’état d’identité, la provenance des fonds, les montants, le protocole visé, la fenêtre de temps. Une fois validé, il fournit une preuve que « cette intention peut être autorisée à passer ».
Mais le fait que la transaction aboutisse dépend aussi de l’encombrement de la chaîne cible, du Gas, de la profondeur de la liquidité, du slippage et de l’état du contrat. C’est comme un contrôle d’accès par reconnaissance faciale : le fait que vous soyez autorisé à entrer dans l’immeuble ne veut pas dire que l’ascenseur arrivera tout de suite. 😅

Je pense que c’est précisément là que le $NEWT mérite d’être démêlé : ce n’est pas un système qui garantit que vous gagnerez de l’argent, ni une garantie que chaque transaction réussira, mais plutôt une façon de clarifier à l’avance si un agent a dépassé ses autorisations. À l’avenir, quand vous regardez Newton, ne vous contentez pas de surveiller le résultat “succès/échec” : il faut aussi comprendre à quelle étape l’échec se produit — Policy non validée, preuve expirée, exécution sur la chaîne cible qui échoue, ou bien manque de liquidité.

En séparant l’autorisation, l’exécution et le règlement, l’IA on-chain ne deviendra pas un grand mystère. @NewtonProtocol #Newt
·
--
Haussier
J’ai déjà fourni une clé API à un outil de quantification. Ce qui me fait le plus peur, ce n’est pas qu’il ne puisse pas fonctionner, mais plutôt qu’il “fonctionne trop bien”. Si une clé peut tout consulter, tout télécharger et que les limites des autorisations ne sont pas claires, alors l’automatisation ne devient pas un assistant : elle revient à exposer le compte sans protection. C’est pourquoi, quand je regarde la conception de la clé API de @grvt_io , je ne commence pas par la vitesse : je commence par la façon dont les autorisations sont découpées. La clé est liée à un Trading Account précis. Pour passer des ordres, il faut aussi cocher séparément l’autorisation Trade. Détail important. Car beaucoup d’incidents ne commencent pas avec un hacker qui vole d’un coup tout l’argent : ils commencent par l’obtention d’une permission d’interface qui paraît banale, puis l’on élargit progressivement le périmètre des dégâts. Ce point est aussi très compréhensible pour un trader “ordinaire” : tu peux demander à un ami de surveiller les marchés, mais cela ne veut pas dire qu’il faut lui donner le mot de passe de ta carte bancaire ; tu peux laisser un script automatiser la mise en attente et l’annulation d’ordres, mais cela ne veut pas dire qu’il devrait pouvoir toucher à tous tes comptes. Le cœur d’une API n’est pas “peut-elle s’automatiser”, mais : l’automatisation est-elle enfermée dans une cage de quelle taille. Si GRVT veut servir des traders professionnels et des utilisateurs de stratégies, ces limites d’autorisations sont plus cruciales que la beauté de l’interface. Car les personnes qui exécutent réellement des stratégies craignent surtout : un script qui part hors contrôle, une fuite de clé, ou des autorisations trop étendues. Une mauvaise saisie peut ne faire perdre “qu’un peu”, mais si la conception des autorisations est trop grossière, la perte peut être démultipliée. Je pense qu’une bonne infrastructure de trading ne devrait pas se contenter de dire à l’utilisateur : “vous pouvez connecter l’API”. Elle devrait aussi lui expliquer : à quoi cette API sert, ce qu’elle ne doit pas faire, et si, en cas de problème, le risque peut être verrouillé sur un compte donné. Ce n’est pas spectaculaire, mais c’est très concret.#grvt #比特币ETF终结八周资金流出 #ARB跌约6%至$0.090
J’ai déjà fourni une clé API à un outil de quantification. Ce qui me fait le plus peur, ce n’est pas qu’il ne puisse pas fonctionner, mais plutôt qu’il “fonctionne trop bien”. Si une clé peut tout consulter, tout télécharger et que les limites des autorisations ne sont pas claires, alors l’automatisation ne devient pas un assistant : elle revient à exposer le compte sans protection.

C’est pourquoi, quand je regarde la conception de la clé API de @grvt_io , je ne commence pas par la vitesse : je commence par la façon dont les autorisations sont découpées. La clé est liée à un Trading Account précis. Pour passer des ordres, il faut aussi cocher séparément l’autorisation Trade. Détail important. Car beaucoup d’incidents ne commencent pas avec un hacker qui vole d’un coup tout l’argent : ils commencent par l’obtention d’une permission d’interface qui paraît banale, puis l’on élargit progressivement le périmètre des dégâts.

Ce point est aussi très compréhensible pour un trader “ordinaire” : tu peux demander à un ami de surveiller les marchés, mais cela ne veut pas dire qu’il faut lui donner le mot de passe de ta carte bancaire ; tu peux laisser un script automatiser la mise en attente et l’annulation d’ordres, mais cela ne veut pas dire qu’il devrait pouvoir toucher à tous tes comptes. Le cœur d’une API n’est pas “peut-elle s’automatiser”, mais : l’automatisation est-elle enfermée dans une cage de quelle taille.

Si GRVT veut servir des traders professionnels et des utilisateurs de stratégies, ces limites d’autorisations sont plus cruciales que la beauté de l’interface. Car les personnes qui exécutent réellement des stratégies craignent surtout : un script qui part hors contrôle, une fuite de clé, ou des autorisations trop étendues. Une mauvaise saisie peut ne faire perdre “qu’un peu”, mais si la conception des autorisations est trop grossière, la perte peut être démultipliée.

Je pense qu’une bonne infrastructure de trading ne devrait pas se contenter de dire à l’utilisateur : “vous pouvez connecter l’API”. Elle devrait aussi lui expliquer : à quoi cette API sert, ce qu’elle ne doit pas faire, et si, en cas de problème, le risque peut être verrouillé sur un compte donné. Ce n’est pas spectaculaire, mais c’est très concret.#grvt
#比特币ETF终结八周资金流出 #ARB跌约6%至$0.090
🎙️ Plus d’acheteurs ou de vendeurs sur ETH ?
avatar
Fin
04 h 01 min 40 sec
25.2k
23
19
🎙️ Après avoir atteint un sommet, le BTC et l’ETH retombent rapidement : la tendance commence à se diviser sur le marché ! Vous voulez savoir où se situeront les résistances lors du prochain rebond et les niveaux de support en dessous ? Restez dans la salle de diffusion en direct
avatar
Fin
04 h 12 min 30 sec
5.3k
6
14
🎙️ Maintenir l’équilibre écologique, construire la grande place Binance Jianguang
avatar
Fin
04 h 09 min 45 sec
13.8k
24
113
🎙️ Faire un vrai trading avec de l’argent réel
avatar
Fin
02 h 31 min 14 sec
23.5k
27
32
🎙️ Ensemble, construisons la place Binance|Une nouvelle semaine commence : y aura-t-il de nouvelles tendances aujourd’hui ? Discutons-en
avatar
Fin
04 h 16 min 41 sec
9.5k
31
27
Article
Mieux vaut ne pas exécuter que faire n’importe quoi ? Décomposer le dilemme Fail-Closed de NewtonLa première fois que j’ai remarqué le terme « Fail-Closed », c’était en regardant le traitement des exceptions d’un Vault automatisé. Ce n’est pas compliqué : si le système ne peut pas confirmer qu’une opération est sûre, il refuse par défaut de l’exécuter. Cela semble tout à fait raisonnable. La passerelle est temporairement indisponible, les nœuds d’exploitation n’atteignent pas le nombre légal requis, la preuve a expiré, la vérification on-chain a échoué : si un seul maillon connaît un problème, la transaction ne devrait pas continuer à avancer avec des doutes. Pour un mandataire chargé de gérer des fonds, « s’arrêter quand on n’est pas sûr » est manifestement plus prudent que « exécuter d’abord, on verra ». Mais en suivant la scène réelle, je me rends compte que ce principe n’est pas sûr en toutes circonstances.

Mieux vaut ne pas exécuter que faire n’importe quoi ? Décomposer le dilemme Fail-Closed de Newton

La première fois que j’ai remarqué le terme « Fail-Closed », c’était en regardant le traitement des exceptions d’un Vault automatisé. Ce n’est pas compliqué : si le système ne peut pas confirmer qu’une opération est sûre, il refuse par défaut de l’exécuter.
Cela semble tout à fait raisonnable. La passerelle est temporairement indisponible, les nœuds d’exploitation n’atteignent pas le nombre légal requis, la preuve a expiré, la vérification on-chain a échoué : si un seul maillon connaît un problème, la transaction ne devrait pas continuer à avancer avec des doutes. Pour un mandataire chargé de gérer des fonds, « s’arrêter quand on n’est pas sûr » est manifestement plus prudent que « exécuter d’abord, on verra ».
Mais en suivant la scène réelle, je me rends compte que ce principe n’est pas sûr en toutes circonstances.
·
--
Haussier
En triant mon portefeuille aujourd’hui, je me suis posé une question très concrète : si une oracle d’identité classe par erreur une adresse normale comme présentant un risque élevé, à qui l’utilisateur peut-il faire appel ? Si une oracle de prix tombe en erreur, on peut la comparer à des transactions publiques ; pour l’identification, c’est bien plus complexe. Un certain montant ayant transité via un mixeur ne signifie pas pour autant que le propriétaire de l’adresse a participé à un blanchiment ; et les restrictions varient aussi selon les régions. Se limiter à “accepté/refusé” de la part du système, c’est trop facile et cela peut transformer la prudence en atteinte injustifiée. @NewtonProtocol place la vérification de l’identité et du risque avant l’exécution de la transaction : cela permet d’éviter que des fonds problématiques n’entrent d’abord dans le protocole avant qu’on ne tente de les retracer. Mais plus ce blocage préalable est puissant, plus le canal de correction doit être clair et sans ambiguïté. Sinon, si une adresse est mal étiquetée, des transferts automatiques, des ajustements de Vault, voire même un remboursement normal, peuvent être interrompus en même temps. Je souhaite que la policy d’identité fournisse au moins quatre éléments : quelles catégories de règles ont été déclenchées, sur quelles bases elles sont mises à jour (et quand), vers quel fournisseur de données déposer un recours, et quelles opérations à faible risque restent autorisées pendant la période de réexamen. Les détails touchant à la vie privée peuvent être masqués, mais il ne peut pas rester une simple phrase du type « échec de la vérification ». Surtout, le résultat de la correction doit pouvoir être diffusé. Une fois que la source de données retire le marqueur, les anciennes preuves, le cache et l’état de la chaîne cible doivent expirer dans un délai clairement défini : pas seulement parce que la blockchain principale a été corrigée, tandis qu’une autre chaîne continue de bloquer.$NEWT Newton veut devenir une couche de garde automatisée on-chain : l’exactitude du filtrage est bien sûr importante ; mais reconnaître l’erreur, la corriger, et empêcher qu’elle ne se propage encore, sont aussi des capacités d’infrastructure indispensables.🪪 @NewtonProtocol $NEWT #Newt
En triant mon portefeuille aujourd’hui, je me suis posé une question très concrète : si une oracle d’identité classe par erreur une adresse normale comme présentant un risque élevé, à qui l’utilisateur peut-il faire appel ?

Si une oracle de prix tombe en erreur, on peut la comparer à des transactions publiques ; pour l’identification, c’est bien plus complexe. Un certain montant ayant transité via un mixeur ne signifie pas pour autant que le propriétaire de l’adresse a participé à un blanchiment ; et les restrictions varient aussi selon les régions. Se limiter à “accepté/refusé” de la part du système, c’est trop facile et cela peut transformer la prudence en atteinte injustifiée.

@NewtonProtocol place la vérification de l’identité et du risque avant l’exécution de la transaction : cela permet d’éviter que des fonds problématiques n’entrent d’abord dans le protocole avant qu’on ne tente de les retracer. Mais plus ce blocage préalable est puissant, plus le canal de correction doit être clair et sans ambiguïté. Sinon, si une adresse est mal étiquetée, des transferts automatiques, des ajustements de Vault, voire même un remboursement normal, peuvent être interrompus en même temps.

Je souhaite que la policy d’identité fournisse au moins quatre éléments : quelles catégories de règles ont été déclenchées, sur quelles bases elles sont mises à jour (et quand), vers quel fournisseur de données déposer un recours, et quelles opérations à faible risque restent autorisées pendant la période de réexamen. Les détails touchant à la vie privée peuvent être masqués, mais il ne peut pas rester une simple phrase du type « échec de la vérification ».

Surtout, le résultat de la correction doit pouvoir être diffusé. Une fois que la source de données retire le marqueur, les anciennes preuves, le cache et l’état de la chaîne cible doivent expirer dans un délai clairement défini : pas seulement parce que la blockchain principale a été corrigée, tandis qu’une autre chaîne continue de bloquer.$NEWT

Newton veut devenir une couche de garde automatisée on-chain : l’exactitude du filtrage est bien sûr importante ; mais reconnaître l’erreur, la corriger, et empêcher qu’elle ne se propage encore, sont aussi des capacités d’infrastructure indispensables.🪪
@NewtonProtocol $NEWT #Newt
·
--
Haussier
Quand je regardais le carnet d’ordres hier soir, j’ai soudain pensé à un problème très concret : d’habitude, on surveille le carnet, on ne voit que le meilleur achat et la meilleure vente, comme si le prix était là, tout simplement. Mais quand on passe réellement un ordre, la partie la plus pénible n’est pas la fluctuation du prix : c’est plutôt de cliquer sur l’exécution, puis de se rendre compte que l’on n’a pas obtenu la position la plus confortable. C’est pourquoi, en lisant le dossier de @grvt_io , le point RPI m’a fait faire une pause. Ce n’est pas un concept mystérieux : en termes simples, RPI signifie Retail Price Improvement, soit un mécanisme qui offre aux ordres de détail la possibilité d’obtenir un prix meilleur. Vous voyez sur le carnet public des prix d’achat et de vente, mais dans le marché, il peut aussi exister de meilleures propositions ou une liquidité cachée, que les utilisateurs ordinaires ne rencontrent pas d’habitude. Pour les gros investisseurs, ce phénomène peut ne représenter que quelques points de base. Pour les petits particuliers, en revanche, c’est quelque chose de très réel. Bien des fois, ce qu’on perd n’est pas la direction, mais le fait que, à chaque exécution, on passe à côté : un peu plus de slippage, un ordre limité placé un peu plus lentement, une exécution un peu plus chère. Avec le temps et le nombre d’occurrences, ces “petites décimales” se transforment en argent visible sur le compte. J’aime regarder GRVT sous cet angle, parce que l’entreprise ne se contente pas de dire “rapide et performant”. Elle touche quelque chose de très fin dans l’expérience de trading : est-ce que l’utilisateur ordinaire peut perdre un peu moins ? Une bourse qui laisse simplement l’utilisateur voir le carnet, sans l’aider à obtenir une exécution meilleure, même si tout est fluide, manque un peu de saveur. Bien sûr, le RPI ne garantit pas que chaque exécution sera meilleure, ni que l’on va obtenir de bonnes affaires gratuitement. C’est plutôt comme une question supplémentaire avant de passer un ordre : en plus du prix public, existe-t-il une offre plus appropriée ? C’est une question petite, mais elle est très proche de la réalité du trading. #grvt
Quand je regardais le carnet d’ordres hier soir, j’ai soudain pensé à un problème très concret : d’habitude, on surveille le carnet, on ne voit que le meilleur achat et la meilleure vente, comme si le prix était là, tout simplement. Mais quand on passe réellement un ordre, la partie la plus pénible n’est pas la fluctuation du prix : c’est plutôt de cliquer sur l’exécution, puis de se rendre compte que l’on n’a pas obtenu la position la plus confortable.

C’est pourquoi, en lisant le dossier de @grvt_io , le point RPI m’a fait faire une pause. Ce n’est pas un concept mystérieux : en termes simples, RPI signifie Retail Price Improvement, soit un mécanisme qui offre aux ordres de détail la possibilité d’obtenir un prix meilleur. Vous voyez sur le carnet public des prix d’achat et de vente, mais dans le marché, il peut aussi exister de meilleures propositions ou une liquidité cachée, que les utilisateurs ordinaires ne rencontrent pas d’habitude.

Pour les gros investisseurs, ce phénomène peut ne représenter que quelques points de base. Pour les petits particuliers, en revanche, c’est quelque chose de très réel. Bien des fois, ce qu’on perd n’est pas la direction, mais le fait que, à chaque exécution, on passe à côté : un peu plus de slippage, un ordre limité placé un peu plus lentement, une exécution un peu plus chère. Avec le temps et le nombre d’occurrences, ces “petites décimales” se transforment en argent visible sur le compte.

J’aime regarder GRVT sous cet angle, parce que l’entreprise ne se contente pas de dire “rapide et performant”. Elle touche quelque chose de très fin dans l’expérience de trading : est-ce que l’utilisateur ordinaire peut perdre un peu moins ? Une bourse qui laisse simplement l’utilisateur voir le carnet, sans l’aider à obtenir une exécution meilleure, même si tout est fluide, manque un peu de saveur.

Bien sûr, le RPI ne garantit pas que chaque exécution sera meilleure, ni que l’on va obtenir de bonnes affaires gratuitement. C’est plutôt comme une question supplémentaire avant de passer un ordre : en plus du prix public, existe-t-il une offre plus appropriée ? C’est une question petite, mais elle est très proche de la réalité du trading. #grvt
Article
Qui doit vérifier le « vérificateur » ? Newton a aussi besoin d’un ensemble de challengers économiquesIl y a quelques jours, en classant un historique d’exécution de transactions automatisées, je me suis soudain posé une question assez inconfortable : si le système fournit un reçu indiquant « vérification réussie », un utilisateur ordinaire doit-il encore douter de sa validité ? À première vue, cela ne semble pas nécessaire. L’idée de <c-92/> consiste à confier d’abord l’intention de transaction à l’évaluation de Policy, puis à faire exécuter la vérification par des nœuds d’exploitation, en s’appuyant sur un environnement d’exécution de confiance, des preuves cryptographiques et des enregistrements on-chain, afin que l’agent ne puisse pas franchir arbitrairement les limites définies par l’utilisateur. Puisque le processus est vérifiable, le résultat devrait donc paraître fiable. Cependant, la partie la plus pénible du système en chaîne n’est souvent pas de savoir s’il y a des preuves, mais plutôt qui est prêt à prendre le temps de vérifier les preuves.

Qui doit vérifier le « vérificateur » ? Newton a aussi besoin d’un ensemble de challengers économiques

Il y a quelques jours, en classant un historique d’exécution de transactions automatisées, je me suis soudain posé une question assez inconfortable : si le système fournit un reçu indiquant « vérification réussie », un utilisateur ordinaire doit-il encore douter de sa validité ?
À première vue, cela ne semble pas nécessaire. L’idée de <c-92/> consiste à confier d’abord l’intention de transaction à l’évaluation de Policy, puis à faire exécuter la vérification par des nœuds d’exploitation, en s’appuyant sur un environnement d’exécution de confiance, des preuves cryptographiques et des enregistrements on-chain, afin que l’agent ne puisse pas franchir arbitrairement les limites définies par l’utilisateur. Puisque le processus est vérifiable, le résultat devrait donc paraître fiable.
Cependant, la partie la plus pénible du système en chaîne n’est souvent pas de savoir s’il y a des preuves, mais plutôt qui est prêt à prendre le temps de vérifier les preuves.
🎙️ Parlons d’état d’esprit d’investissement et d’un DCA sur le BNB au comptant !
avatar
Fin
03 h 54 min 41 sec
35.4k
32
37
·
--
Haussier
Hier soir, un ami m’a demandé : « @NewtonProtocol Si on peut limiter le montant, la devise et le protocole de l’agent, pourquoi ne pas créer quelques modèles et laisser les gens ordinaires choisir en un clic ? » L’idée est très pratique, mais plus j’y pense, plus je me dis que le modèle est l’entrée de risque la plus facile à ignorer. Supposons qu’il y ait, sur la page, un modèle « Investissement régulier prudent » : par défaut, l’agent peut acheter chaque semaine, mobiliser au maximum 500 USDC et n’utiliser que des DEX spécifiés. Quand les utilisateurs voient les mots « prudent », ils ne vont généralement pas vérifier point par point. Mais si le modèle définit une durée de validité trop longue, ou s’il oublie de fixer une limite au slippage, l’agent exécutera quand même strictement les règles… seulement, ces règles ne correspondent peut-être pas à ce que l’utilisateur imagine comme « prudent ». Les zkPermissions de @NewtonProtocol peuvent prouver que l’agent ne dépasse pas les limites, et la Policy peut aussi bloquer les opérations non conformes avant l’exécution. Mais elles répondent à la question : « Est-ce que l’on suit les règles ? », et non : « Est-ce que ces règles sont bien écrites ? » Donc, je pense que les modèles de permission ne peuvent pas se contenter d’afficher un simple nom. Il faut au minimum rendre publics la version, le créateur, les rapports d’audit, les cas d’usage concernés et la perte maximale possible ; et quand les paramètres changent, que les anciennes autorisations expirent automatiquement, avec une nouvelle confirmation. $NEWT C’est comme un contrat de location : même si la signature électronique est fiable, il faut d’abord lire la caution, la durée et les clauses de rupture. Le point clé, pour Newton, qui réduit vraiment la barrière à l’entrée, n’est pas de cacher la configuration complexe, mais de traduire les risques en choix que les gens ordinaires peuvent comprendre.🔐 $NEWT #Newt
Hier soir, un ami m’a demandé : « @NewtonProtocol Si on peut limiter le montant, la devise et le protocole de l’agent, pourquoi ne pas créer quelques modèles et laisser les gens ordinaires choisir en un clic ? »

L’idée est très pratique, mais plus j’y pense, plus je me dis que le modèle est l’entrée de risque la plus facile à ignorer.

Supposons qu’il y ait, sur la page, un modèle « Investissement régulier prudent » : par défaut, l’agent peut acheter chaque semaine, mobiliser au maximum 500 USDC et n’utiliser que des DEX spécifiés. Quand les utilisateurs voient les mots « prudent », ils ne vont généralement pas vérifier point par point. Mais si le modèle définit une durée de validité trop longue, ou s’il oublie de fixer une limite au slippage, l’agent exécutera quand même strictement les règles… seulement, ces règles ne correspondent peut-être pas à ce que l’utilisateur imagine comme « prudent ».

Les zkPermissions de @NewtonProtocol peuvent prouver que l’agent ne dépasse pas les limites, et la Policy peut aussi bloquer les opérations non conformes avant l’exécution. Mais elles répondent à la question : « Est-ce que l’on suit les règles ? », et non : « Est-ce que ces règles sont bien écrites ? »

Donc, je pense que les modèles de permission ne peuvent pas se contenter d’afficher un simple nom. Il faut au minimum rendre publics la version, le créateur, les rapports d’audit, les cas d’usage concernés et la perte maximale possible ; et quand les paramètres changent, que les anciennes autorisations expirent automatiquement, avec une nouvelle confirmation.
$NEWT
C’est comme un contrat de location : même si la signature électronique est fiable, il faut d’abord lire la caution, la durée et les clauses de rupture.
Le point clé, pour Newton, qui réduit vraiment la barrière à l’entrée, n’est pas de cacher la configuration complexe, mais de traduire les risques en choix que les gens ordinaires peuvent comprendre.🔐 $NEWT #Newt
·
--
Haussier
J’utilisais auparavant des exchanges décentralisées sur la chaîne, et ce que je redoutais le plus n’était pas de ne pas savoir faire, mais d’être freiné à chaque étape par le “ressenti de la blockchain” : signer, attendre les confirmations, surveiller le Gas, et craindre que l’exécution soit trop lente. Mais quand on revient sur un exchange centralisé, un autre souci apparaît : tout se passe bien côté exécution, mais jusqu’où s’étend exactement la frontière des fonds ? Donc, quand je vois @grvt_io , ce qui me parle le plus n’est pas une simple “plateforme hybride”, c’est le fait qu’elle traite une transaction en deux couches. Les étapes rapides — appariement des ordres, exécution des trades — tournent hors chaîne, ce qui donne une expérience utilisateur proche de celle d’un exchange classique ; tandis que les étapes plus lourdes, liées à la sécurité et à l’attribution (custodie des actifs, marges, règlement), sont confiées à la chaîne et aux smart contracts. Ça ressemble à une architecture technique, mais dit en mots simples : là où c’est rapide, ne forcez pas à tout faire sur la chaîne ; là où c’est lourd, ne gardez pas tout en boîte noire. 🙂 Ce qui compte vraiment pour un trader, c’est finalement très simple : que la mise en vente ne bloque pas, que le成交 (l’exécution) ne traîne pas, et que les fonds ne restent pas dans le flou. Avant, beaucoup de DEX insistaient sur la décentralisation, mais l’expérience, c’était comme réparer un ordinateur. Beaucoup de CEX sont fluides, mais tu dois alors faire confiance à l’后台 (backend) de la plateforme. La voie que GRVT veut emprunter, c’est de redistribuer les parties qui influencent le plus l’expérience utilisateur, des deux côtés. Personnellement, je crains surtout ce genre de produit “concept avancé, mais quand tu cliques, tu n’as que de l’attente”. Les opportunités de trading ne vont pas attendre les gens, surtout quand le marché bouge vite : quelques secondes de plus peuvent déjà changer l’état d’esprit. Mais la vitesse ne peut pas non plus se faire au prix d’une perte de transparence sur les fonds ; sinon, le côté “fluide” n’est qu’une surface. Je pense que cette direction mérite d’être suivie, parce qu’au final, ce n’est pas tant le niveau de sophistication des concepts qui fait gagner un produit de trading, c’est si, une seconde après avoir passé l’ordre, tu hésites ou non. Est-ce qu’on peut avoir la même fluidité qu’un CEX, tout en conservant les frontières des fonds on-chain et la transparence du règlement ? C’est précisément ce qui rend @grvt_io assez intéressant.#grvt
J’utilisais auparavant des exchanges décentralisées sur la chaîne, et ce que je redoutais le plus n’était pas de ne pas savoir faire, mais d’être freiné à chaque étape par le “ressenti de la blockchain” : signer, attendre les confirmations, surveiller le Gas, et craindre que l’exécution soit trop lente. Mais quand on revient sur un exchange centralisé, un autre souci apparaît : tout se passe bien côté exécution, mais jusqu’où s’étend exactement la frontière des fonds ?

Donc, quand je vois @grvt_io , ce qui me parle le plus n’est pas une simple “plateforme hybride”, c’est le fait qu’elle traite une transaction en deux couches. Les étapes rapides — appariement des ordres, exécution des trades — tournent hors chaîne, ce qui donne une expérience utilisateur proche de celle d’un exchange classique ; tandis que les étapes plus lourdes, liées à la sécurité et à l’attribution (custodie des actifs, marges, règlement), sont confiées à la chaîne et aux smart contracts.

Ça ressemble à une architecture technique, mais dit en mots simples : là où c’est rapide, ne forcez pas à tout faire sur la chaîne ; là où c’est lourd, ne gardez pas tout en boîte noire. 🙂

Ce qui compte vraiment pour un trader, c’est finalement très simple : que la mise en vente ne bloque pas, que le成交 (l’exécution) ne traîne pas, et que les fonds ne restent pas dans le flou. Avant, beaucoup de DEX insistaient sur la décentralisation, mais l’expérience, c’était comme réparer un ordinateur. Beaucoup de CEX sont fluides, mais tu dois alors faire confiance à l’后台 (backend) de la plateforme. La voie que GRVT veut emprunter, c’est de redistribuer les parties qui influencent le plus l’expérience utilisateur, des deux côtés.

Personnellement, je crains surtout ce genre de produit “concept avancé, mais quand tu cliques, tu n’as que de l’attente”. Les opportunités de trading ne vont pas attendre les gens, surtout quand le marché bouge vite : quelques secondes de plus peuvent déjà changer l’état d’esprit. Mais la vitesse ne peut pas non plus se faire au prix d’une perte de transparence sur les fonds ; sinon, le côté “fluide” n’est qu’une surface.

Je pense que cette direction mérite d’être suivie, parce qu’au final, ce n’est pas tant le niveau de sophistication des concepts qui fait gagner un produit de trading, c’est si, une seconde après avoir passé l’ordre, tu hésites ou non. Est-ce qu’on peut avoir la même fluidité qu’un CEX, tout en conservant les frontières des fonds on-chain et la transparence du règlement ? C’est précisément ce qui rend @grvt_io assez intéressant.#grvt
Article
Le vrai défi du Model Registry n’est pas de publier un agent, mais d’établir sa réputationAujourd’hui, j’ai envie d’aborder Newton sous un autre angle. Ces derniers jours, ce dont tout le monde a le plus discuté, ce sont Policy Engine, TEE, ZK, Keystore Rollup : tout cela est important. Mais plus je regarde, plus je me dis que la prochaine étape, plus difficile encore, @NewtonProtocol , pourrait être le Model Registry. La raison est très simple : la couche de permissions résout « est-ce que le proxy peut faire n’importe quoi », mais elle ne résout pas « est-ce que le proxy est fiable ». Ces deux problèmes sont très différents. Imaginons qu’à l’avenir, sur Newton, il y ait un agent de rebalancement automatique. Vous lui configurez des permissions : au maximum, il peut déplacer 1000 U, il ne peut interagir qu’avec des protocoles spécifiés, il ne peut pas transférer vers des adresses inconnues, et s’il dépasse le seuil de slippage, il refuse d’exécuter. zkPermissions peut vérifier qu’il n’a pas outrepassé ses droits, et Policy Engine peut vérifier qu’il respecte bien les règles. Ces garde-fous de sécurité ont une vraie valeur.

Le vrai défi du Model Registry n’est pas de publier un agent, mais d’établir sa réputation

Aujourd’hui, j’ai envie d’aborder Newton sous un autre angle. Ces derniers jours, ce dont tout le monde a le plus discuté, ce sont Policy Engine, TEE, ZK, Keystore Rollup : tout cela est important. Mais plus je regarde, plus je me dis que la prochaine étape, plus difficile encore, @NewtonProtocol , pourrait être le Model Registry.
La raison est très simple : la couche de permissions résout « est-ce que le proxy peut faire n’importe quoi », mais elle ne résout pas « est-ce que le proxy est fiable ».
Ces deux problèmes sont très différents.
Imaginons qu’à l’avenir, sur Newton, il y ait un agent de rebalancement automatique. Vous lui configurez des permissions : au maximum, il peut déplacer 1000 U, il ne peut interagir qu’avec des protocoles spécifiés, il ne peut pas transférer vers des adresses inconnues, et s’il dépasse le seuil de slippage, il refuse d’exécuter. zkPermissions peut vérifier qu’il n’a pas outrepassé ses droits, et Policy Engine peut vérifier qu’il respecte bien les règles. Ces garde-fous de sécurité ont une vraie valeur.
Connectez-vous pour découvrir plus de contenu
Rejoignez la communauté mondiale des adeptes de cryptomonnaies sur Binance Square
⚡️ Suviez les dernières informations importantes sur les cryptomonnaies.
💬 Jugé digne de confiance par la plus grande plateforme d’échange de cryptomonnaies au monde.
👍 Découvrez les connaissances que partagent les créateurs vérifiés.
Adresse e-mail/Nº de téléphone
Plan du site
Préférences de cookies
CGU de la plateforme