Binance Square
老青蛙BNB
2.3k Publicações

老青蛙BNB

熊市撸毛,牛市卖毛
Detentor de UP
Detentor de UP
Trader de Alta Frequência
4 ano(s)
224 A seguir
9.1K+ Seguidores
5.3K+ Gostaram
Publicações
·
--
梁文锋 sabe que é preciso abrir muitas contas para participar da nova emissão😄
梁文锋 sabe que é preciso abrir muitas contas para participar da nova emissão😄
Verificado
Nem todo mundo precisa abrir dezenas de contratos todos os dias, mas a lógica dos produtos da maioria dos DEX presume que os usuários vieram para o trading de alta frequência. Quem faz rebalanceamentos de vez em quando deixa a maior parte das garantias ociosa; e quem é mais orientado a rendimento não quer ficar o dia inteiro acompanhando o book. Para quem quer exposição a ouro e ações dos EUA, ainda é preciso cortar e usar outras plataformas. Eu juntei essas rotas de capital e analisei algumas vezes, e senti que @grvt_io parece mais uma plataforma de corretagem on-chain do que apenas uma ferramenta de ordens para perps cripto. O problema é que DEXs tradicionais normalmente só lidam com o momento da execução. Depois que a liquidação termina, como o capital ocioso valoriza, como usuários de baixa frequência definem estratégias e como diferentes ativos compartilham saldos — tudo isso é devolvido para o usuário resolver. Os ganhos de trading e investimentos ficam dispersos por vários protocolos; a cada tipo de necessidade, é preciso transferir novamente as permissões de ativos, além de revalidar os riscos. $EVAA A GRVT usa o One Balance e garantias unificadas para conectar essas demandas em um mesmo ecossistema de contas. Traders ativos podem gerenciar posições perpétuas diretamente com um book central de ordens a preço limite. Para usuários de baixa frequência, os direitos da conta de trading continuam rendendo juros com Earn on Equity. Usuários mais focados em rendimento ainda podem alocar em cofres de estratégia como o GLP, e receber a participação das receitas de market making — sem precisar ficar, todos os dias, ajustando ordens e rebalanceamentos. Quem quer mexer com RWA também tem motivos bem diretos para usar isso. A GRVT oferece exposição on-chain a preços de ativos tradicionais como ouro e ações, permitindo que você gerencie tanto ativos cripto quanto contratos perpétuos de RWA no mesmo painel. As operações relacionadas ao estado de contas e liquidação de fundos ficam a cargo do ZKsync Validium e de provas de conhecimento zero, para manter o máximo possível os limites da autocustódia. $SXT O valor central dessa estrutura não está em quanta funcionalidade ela empilha, mas sim em como o mesmo capital economiza o trabalho de vai e vem entre ganhar juros via trading e configurar estratégias. Por isso, a GRVT não atende apenas jogadores de perps de alta frequência; ela também cobre usuários orientados a rendimento de baixa frequência e usuários de RWA. Claro, condições de remuneração, risco de retração das estratégias e eventos como gap de abertura de ativos tradicionais precisam ser avaliados separadamente. A proposta dela já vai além de um DEX perp comum — mas se conseguirá absorver tantas demandas de forma estável, ainda precisamos observar. #grvt
Nem todo mundo precisa abrir dezenas de contratos todos os dias, mas a lógica dos produtos da maioria dos DEX presume que os usuários vieram para o trading de alta frequência. Quem faz rebalanceamentos de vez em quando deixa a maior parte das garantias ociosa; e quem é mais orientado a rendimento não quer ficar o dia inteiro acompanhando o book. Para quem quer exposição a ouro e ações dos EUA, ainda é preciso cortar e usar outras plataformas. Eu juntei essas rotas de capital e analisei algumas vezes, e senti que @grvt_io parece mais uma plataforma de corretagem on-chain do que apenas uma ferramenta de ordens para perps cripto.

O problema é que DEXs tradicionais normalmente só lidam com o momento da execução. Depois que a liquidação termina, como o capital ocioso valoriza, como usuários de baixa frequência definem estratégias e como diferentes ativos compartilham saldos — tudo isso é devolvido para o usuário resolver. Os ganhos de trading e investimentos ficam dispersos por vários protocolos; a cada tipo de necessidade, é preciso transferir novamente as permissões de ativos, além de revalidar os riscos. $EVAA

A GRVT usa o One Balance e garantias unificadas para conectar essas demandas em um mesmo ecossistema de contas. Traders ativos podem gerenciar posições perpétuas diretamente com um book central de ordens a preço limite. Para usuários de baixa frequência, os direitos da conta de trading continuam rendendo juros com Earn on Equity. Usuários mais focados em rendimento ainda podem alocar em cofres de estratégia como o GLP, e receber a participação das receitas de market making — sem precisar ficar, todos os dias, ajustando ordens e rebalanceamentos.

Quem quer mexer com RWA também tem motivos bem diretos para usar isso. A GRVT oferece exposição on-chain a preços de ativos tradicionais como ouro e ações, permitindo que você gerencie tanto ativos cripto quanto contratos perpétuos de RWA no mesmo painel. As operações relacionadas ao estado de contas e liquidação de fundos ficam a cargo do ZKsync Validium e de provas de conhecimento zero, para manter o máximo possível os limites da autocustódia. $SXT

O valor central dessa estrutura não está em quanta funcionalidade ela empilha, mas sim em como o mesmo capital economiza o trabalho de vai e vem entre ganhar juros via trading e configurar estratégias. Por isso, a GRVT não atende apenas jogadores de perps de alta frequência; ela também cobre usuários orientados a rendimento de baixa frequência e usuários de RWA. Claro, condições de remuneração, risco de retração das estratégias e eventos como gap de abertura de ativos tradicionais precisam ser avaliados separadamente. A proposta dela já vai além de um DEX perp comum — mas se conseguirá absorver tantas demandas de forma estável, ainda precisamos observar. #grvt
低频玩家也可以来 grvt
0%
每个交易所都这么说
100%
1 Votos • Votação encerrada
Artigo
Newton Protocol e account abstraction: o que realmente precisa ser ocultado não é o custoQuando foi solicitado ao usuário iniciante testar um depósito on-chain pela primeira vez, ele não ficou preso na taxa de rendimento ou nos avisos de risco — o problema foi na linha da carteira que dizia “saldo insuficiente”. A conta tinha stablecoins, mas como não possuía o token nativo da cadeia de destino, não conseguiu nem enviar a autorização. Para colocar o fluxo em funcionamento, eu primeiro fiz um补 Gas via cross-chain, depois refiz a autorização e o depósito, e por fim conferi várias vezes a estimativa de custo do UserOperation com o débito real. O usuário só queria concluir uma única ação, mas a camada subjacente exigia que ele primeiro entendesse redes e taxas. @NewtonProtocol Com a combinação entre account abstraction e o protocolo, o que deve ser eliminado é exatamente essa barreira sem sentido.

Newton Protocol e account abstraction: o que realmente precisa ser ocultado não é o custo

Quando foi solicitado ao usuário iniciante testar um depósito on-chain pela primeira vez, ele não ficou preso na taxa de rendimento ou nos avisos de risco — o problema foi na linha da carteira que dizia “saldo insuficiente”. A conta tinha stablecoins, mas como não possuía o token nativo da cadeia de destino, não conseguiu nem enviar a autorização. Para colocar o fluxo em funcionamento, eu primeiro fiz um补 Gas via cross-chain, depois refiz a autorização e o depósito, e por fim conferi várias vezes a estimativa de custo do UserOperation com o débito real. O usuário só queria concluir uma única ação, mas a camada subjacente exigia que ele primeiro entendesse redes e taxas. @NewtonProtocol Com a combinação entre account abstraction e o protocolo, o que deve ser eliminado é exatamente essa barreira sem sentido.
Depois de implantar estratégias de automação na carteira inteligente, descobri que, embora o account abstraction (abstração de conta) resolva o problema de envio de transações, ele não define os limites de permissão do agente. O lote de transações e o pagamento de gas reduzem as assinaturas, mas quando eu propositalmente substituo o protocolo de destino e aumento o limite, a carteira ainda consegue construir um UserOperation. Ao comparar a validação do EntryPoint com os dados retornados pelo contrato da estratégia, confirmei que a restrição final vem de @NewtonProtocol e não da interface da carteira. $BILL O valor central do account abstraction está em melhorar a experiência: ele empacota várias chamadas em etapas e lida com o gas. Mas, quando um agente de automação se conecta, a carteira inteligente só ganha uma capacidade de execução mais flexível. Quais ativos e protocolos o agente pode chamar e quanto limite ele pode usar ainda exigem gestão por regras adicionais. Um “corpo” de execução mais flexível não significa que as ações sejam naturalmente seguras. $PALU O Newton Protocol complementa exatamente a camada de decisão e de restrição. As restrições da estratégia limitam previamente quais moedas o agente pode acessar, bem como o protocolo de destino e os valores/límites. simulatePolicy faz um ensaio das mudanças de ativos antes da execução e depois entrega o resultado para a verificação do contrato da conta inteligente. O account abstraction é responsável por realizar as chamadas on-chain; já o Newton Protocol determina se a chamada está de acordo com a intenção do usuário. Mesmo que o agente altere o caminho, ele não consegue sair do escopo de permissões definido pelo contrato. Isso estabelece uma divisão de responsabilidades adequada entre os dois. A carteira inteligente torna as operações on-chain mais fáceis, e o Newton Protocol mantém as permissões de automação sempre controláveis — praticidade e governabilidade não precisam sacrificar uma à outra. O que vale a pena verificar daqui em diante é se, quando a estratégia é atualizada e a recuperação da conta ocorre simultaneamente, permissões antigas podem ser efetivamente cortadas. A carteira inteligente fornece o corpo para execução; instruções de segurança precisam ter um mecanismo de frenagem independente e verificável. A confiança real na automação é construída sobre o perfeito desacoplamento entre execução e restrição.#newt $NEWT
Depois de implantar estratégias de automação na carteira inteligente, descobri que, embora o account abstraction (abstração de conta) resolva o problema de envio de transações, ele não define os limites de permissão do agente. O lote de transações e o pagamento de gas reduzem as assinaturas, mas quando eu propositalmente substituo o protocolo de destino e aumento o limite, a carteira ainda consegue construir um UserOperation. Ao comparar a validação do EntryPoint com os dados retornados pelo contrato da estratégia, confirmei que a restrição final vem de @NewtonProtocol e não da interface da carteira.
$BILL

O valor central do account abstraction está em melhorar a experiência: ele empacota várias chamadas em etapas e lida com o gas. Mas, quando um agente de automação se conecta, a carteira inteligente só ganha uma capacidade de execução mais flexível. Quais ativos e protocolos o agente pode chamar e quanto limite ele pode usar ainda exigem gestão por regras adicionais. Um “corpo” de execução mais flexível não significa que as ações sejam naturalmente seguras.
$PALU

O Newton Protocol complementa exatamente a camada de decisão e de restrição. As restrições da estratégia limitam previamente quais moedas o agente pode acessar, bem como o protocolo de destino e os valores/límites. simulatePolicy faz um ensaio das mudanças de ativos antes da execução e depois entrega o resultado para a verificação do contrato da conta inteligente. O account abstraction é responsável por realizar as chamadas on-chain; já o Newton Protocol determina se a chamada está de acordo com a intenção do usuário. Mesmo que o agente altere o caminho, ele não consegue sair do escopo de permissões definido pelo contrato.

Isso estabelece uma divisão de responsabilidades adequada entre os dois. A carteira inteligente torna as operações on-chain mais fáceis, e o Newton Protocol mantém as permissões de automação sempre controláveis — praticidade e governabilidade não precisam sacrificar uma à outra. O que vale a pena verificar daqui em diante é se, quando a estratégia é atualizada e a recuperação da conta ocorre simultaneamente, permissões antigas podem ser efetivamente cortadas. A carteira inteligente fornece o corpo para execução; instruções de segurança precisam ter um mecanismo de frenagem independente e verificável. A confiança real na automação é construída sobre o perfeito desacoplamento entre execução e restrição.#newt $NEWT
Ver tradução
策略被抄很多时候真不是自己说漏嘴,而是链上记录把底牌全亮出来了。现在多数DEX默认公开地址和资金流向,别人顺着时间线盯几次,你的建仓方向和补仓节奏就全暴露了。@grvt_io 主打交易隐私,重点不是吹嘘绝对防跟单,而是实打实减少交易意图在链上的直接暴露。 我复盘过一个活跃地址的链上数据。单笔记录看不出啥,但把转账和余额变化叠在一起看,什么时候建仓、哪里追保、何时减仓,逻辑一目了然。散户看个热闹无所谓,但对大户和做市商来说,这就是被抢跑和被复制策略的灾难,滑点也会变大。 问题其实出在一切皆上链的公共执行环境。订单和账户状态一旦明文上链,数据分析工具就能给你画出完整的行为画像。钱虽然还是你的,但策略路径成了公开数据。资金量越大操作越规律,被看穿意图的代价就越惨痛。 GRVT的解法是把验证和展示拆开。订单在链下订单簿处理,结算走基于ZKsync的Validium。交易数据存在链下,只用零知识证明来验证状态更新,不需要把保证金和成交细节全公开。这就大大增加了别人靠链上数据反推你策略的难度。 不过咱们也得客观,隐私保护不等于绝对隐形。你的链上转账、外部钱包互动甚至下单习惯,依然可能留下蛛丝马迹。GRVT解决的是公开暴露面的问题,而不是让你彻底隐身。这个方向有实际价值,但隐私边界在哪、长期效果如何,还需要时间来检验。#grvt
策略被抄很多时候真不是自己说漏嘴,而是链上记录把底牌全亮出来了。现在多数DEX默认公开地址和资金流向,别人顺着时间线盯几次,你的建仓方向和补仓节奏就全暴露了。@grvt_io 主打交易隐私,重点不是吹嘘绝对防跟单,而是实打实减少交易意图在链上的直接暴露。

我复盘过一个活跃地址的链上数据。单笔记录看不出啥,但把转账和余额变化叠在一起看,什么时候建仓、哪里追保、何时减仓,逻辑一目了然。散户看个热闹无所谓,但对大户和做市商来说,这就是被抢跑和被复制策略的灾难,滑点也会变大。

问题其实出在一切皆上链的公共执行环境。订单和账户状态一旦明文上链,数据分析工具就能给你画出完整的行为画像。钱虽然还是你的,但策略路径成了公开数据。资金量越大操作越规律,被看穿意图的代价就越惨痛。

GRVT的解法是把验证和展示拆开。订单在链下订单簿处理,结算走基于ZKsync的Validium。交易数据存在链下,只用零知识证明来验证状态更新,不需要把保证金和成交细节全公开。这就大大增加了别人靠链上数据反推你策略的难度。

不过咱们也得客观,隐私保护不等于绝对隐形。你的链上转账、外部钱包互动甚至下单习惯,依然可能留下蛛丝马迹。GRVT解决的是公开暴露面的问题,而不是让你彻底隐身。这个方向有实际价值,但隐私边界在哪、长期效果如何,还需要时间来检验。#grvt
我的操作终于只属于我一个人了
67%
我这点钱谁看得上啊
33%
6 Votos • Votação encerrada
Artigo
Ver tradução
前端可以被绕过,Newton Protocol 把安全边界写进合约钓鱼页面里的按钮和原站几乎一模一样,钱包弹窗显示的合约地址也没有明显异常。真正拆开 calldata 后,我才发现调用金额被放大,最低到账额被改低,接收参数还多套了一层路由。为了确认不是解码工具出错,我又把函数选择器和事件日志对了几遍。前端可以伪装,接口也可以被替换。如果风险规则只存在于网页里,用户一旦绕开官方入口,所有限制都会一起消失。@NewtonProtocol 的合约级执行,针对的正是这个缺口。 不少链上产品把风控放在前端。页面负责限制金额,过滤代币,计算滑点,再提醒用户哪些操作危险。正常使用时,这套流程看起来完整。但前端不是资产的最终守门人。攻击者可以复制页面,篡改脚本,劫持域名,也可以直接构造交易调用合约。只要底层合约仍接受这些参数,网页上的红色警告就没有强制力。 更麻烦的是链上代理不一定经过网页。模型生成意图后,执行器可能直接调用 RPC。聚合器返回路由后,服务节点也可能直接组装交易。页面没有参与,前端设置的额度上限和协议白名单自然无法生效。把安全寄托在某个入口没有被绕过,本质上仍是在相信调用链中的每个组件。 Newton Protocol 如果要实现硬核风控,规则就不能只是界面配置。用户设定的合约范围,函数权限,资产名单,单次额度,滑点上限和接收方约束,都需要进入智能账户或执行合约。无论请求来自官方网页,第三方应用,自动化代理还是攻击者自建脚本,最终都必须经过同一套链上验证。入口可以变化,资产出口只有一个。 这里的第一个技术锚点是函数选择器校验。只验证目标合约地址远远不够。同一个协议可能同时提供存款,提款,授权管理和紧急转移接口。代理被允许调用 deposit,不代表它能调用 withdrawTo。执行合约需要读取 calldata 前四个字节,再结合参数范围判断具体能力。攻击者即使绕过前端,也无法把许可调用替换成另一项高风险操作。 第二层是策略哈希。用户确认规则时,将协议白名单,额度和价格限制编码为链上承诺。代理每次提交交易,都要引用对应的策略版本。任何链下服务都不能悄悄扩大金额,新增目标合约或降低最低到账额。规则确实需要调整时,必须由用户重新授权并更新哈希。这样前端只负责展示和配置,不再拥有修改安全边界的最终权力。 simulatePolicy 可以提前告诉用户交易能否通过,但它不能代替合约验证。链下模拟适合发现失败原因,也能减少无意义的 Gas 消耗。真正执行时,合约仍要重新检查调用对象,金额,资产流向和策略状态。模拟通过后如果 calldata 被替换,链上检查必须拒绝。否则攻击者只需伪造一份正常模拟结果,再提交另一笔交易。 价格约束也要写进执行逻辑。只限制调用函数,仍然挡不住恶意报价。攻击者可以让代理调用许可的 swap,却把最低到账额设置得极低。合约需要参考预言机价格,检查实际输出和允许偏差。若报价超出阈值,交易直接回滚。这样即使前端隐藏滑点信息,底层也不会接受明显失真的兑换。 接收方限制同样关键。聚合交易经常经过多个路由器和流动性池,中间地址很难完全固定,但最终资产必须进入用户账户或指定仓位。Newton Protocol 需要验证最终受益人,而不是只看第一层调用地址。路由可以调整,接收方不能由网页脚本临时改写。资金经过再多中间合约,也不能落到许可范围之外。 合约级风控并不意味着把所有规则永久写死。市场状态会变化,协议也会升级。更合理的方式,是把不可突破的底线与可调整参数分开。禁止任意转账,限制接收方和保护主资产属于硬规则。额度,滑点和许可协议可以在用户授权后更新。紧急情况下还要有暂停和撤销机制,避免旧策略在新风险环境中继续运行。 这套方案也有成本。链上验证越复杂,Gas 消耗越高。组合交易需要解析多层调用,规则过细还可能误伤正常路由。Newton Protocol 必须在验证强度和执行效率之间取舍。可以把部分复杂计算放在链下,再通过 ZK 证明把结果带回链上。但最后的证明校验和权限判断不能省掉,否则安全边界又会退回服务端。 另一个难点是合约升级。风控合约自身如果保留过大的管理员权限,攻击者只需控制升级入口,就能替换全部规则。升级应设置延迟,多签确认和清晰的链上记录。用户也要知道当前账户依赖哪个验证模块,模块何时更新,新版本改变了哪些限制。把规则写进合约只是第一步,谁能修改合约同样决定安全性。 所以,Newton Protocol 的合约级执行不该被理解成更复杂的钱包功能。它是在前端之外建立一条无法绕开的资产防线。网页负责把操作讲清楚,代理负责规划路径,合约只负责判断这笔调用是否越过规则。哪一层遭到干扰,都不能单独改变最终权限。 接下来更值得检查的是,Newton Protocol 能否拦截直接 RPC 调用,能否识别合法合约里的恶意参数,也能否防止管理员通过升级绕开原有规则。正常页面里的风控提示并不能证明什么。关掉网页,修改 calldata,再从另一个入口提交,交易依旧过不了,才说明这道防线真正落在链上。先看这些对抗测试,不急着下结论。$NEWT #Newt

前端可以被绕过,Newton Protocol 把安全边界写进合约

钓鱼页面里的按钮和原站几乎一模一样,钱包弹窗显示的合约地址也没有明显异常。真正拆开 calldata 后,我才发现调用金额被放大,最低到账额被改低,接收参数还多套了一层路由。为了确认不是解码工具出错,我又把函数选择器和事件日志对了几遍。前端可以伪装,接口也可以被替换。如果风险规则只存在于网页里,用户一旦绕开官方入口,所有限制都会一起消失。@NewtonProtocol 的合约级执行,针对的正是这个缺口。
不少链上产品把风控放在前端。页面负责限制金额,过滤代币,计算滑点,再提醒用户哪些操作危险。正常使用时,这套流程看起来完整。但前端不是资产的最终守门人。攻击者可以复制页面,篡改脚本,劫持域名,也可以直接构造交易调用合约。只要底层合约仍接受这些参数,网页上的红色警告就没有强制力。
更麻烦的是链上代理不一定经过网页。模型生成意图后,执行器可能直接调用 RPC。聚合器返回路由后,服务节点也可能直接组装交易。页面没有参与,前端设置的额度上限和协议白名单自然无法生效。把安全寄托在某个入口没有被绕过,本质上仍是在相信调用链中的每个组件。
Newton Protocol 如果要实现硬核风控,规则就不能只是界面配置。用户设定的合约范围,函数权限,资产名单,单次额度,滑点上限和接收方约束,都需要进入智能账户或执行合约。无论请求来自官方网页,第三方应用,自动化代理还是攻击者自建脚本,最终都必须经过同一套链上验证。入口可以变化,资产出口只有一个。
这里的第一个技术锚点是函数选择器校验。只验证目标合约地址远远不够。同一个协议可能同时提供存款,提款,授权管理和紧急转移接口。代理被允许调用 deposit,不代表它能调用 withdrawTo。执行合约需要读取 calldata 前四个字节,再结合参数范围判断具体能力。攻击者即使绕过前端,也无法把许可调用替换成另一项高风险操作。
第二层是策略哈希。用户确认规则时,将协议白名单,额度和价格限制编码为链上承诺。代理每次提交交易,都要引用对应的策略版本。任何链下服务都不能悄悄扩大金额,新增目标合约或降低最低到账额。规则确实需要调整时,必须由用户重新授权并更新哈希。这样前端只负责展示和配置,不再拥有修改安全边界的最终权力。
simulatePolicy 可以提前告诉用户交易能否通过,但它不能代替合约验证。链下模拟适合发现失败原因,也能减少无意义的 Gas 消耗。真正执行时,合约仍要重新检查调用对象,金额,资产流向和策略状态。模拟通过后如果 calldata 被替换,链上检查必须拒绝。否则攻击者只需伪造一份正常模拟结果,再提交另一笔交易。
价格约束也要写进执行逻辑。只限制调用函数,仍然挡不住恶意报价。攻击者可以让代理调用许可的 swap,却把最低到账额设置得极低。合约需要参考预言机价格,检查实际输出和允许偏差。若报价超出阈值,交易直接回滚。这样即使前端隐藏滑点信息,底层也不会接受明显失真的兑换。
接收方限制同样关键。聚合交易经常经过多个路由器和流动性池,中间地址很难完全固定,但最终资产必须进入用户账户或指定仓位。Newton Protocol 需要验证最终受益人,而不是只看第一层调用地址。路由可以调整,接收方不能由网页脚本临时改写。资金经过再多中间合约,也不能落到许可范围之外。
合约级风控并不意味着把所有规则永久写死。市场状态会变化,协议也会升级。更合理的方式,是把不可突破的底线与可调整参数分开。禁止任意转账,限制接收方和保护主资产属于硬规则。额度,滑点和许可协议可以在用户授权后更新。紧急情况下还要有暂停和撤销机制,避免旧策略在新风险环境中继续运行。
这套方案也有成本。链上验证越复杂,Gas 消耗越高。组合交易需要解析多层调用,规则过细还可能误伤正常路由。Newton Protocol 必须在验证强度和执行效率之间取舍。可以把部分复杂计算放在链下,再通过 ZK 证明把结果带回链上。但最后的证明校验和权限判断不能省掉,否则安全边界又会退回服务端。
另一个难点是合约升级。风控合约自身如果保留过大的管理员权限,攻击者只需控制升级入口,就能替换全部规则。升级应设置延迟,多签确认和清晰的链上记录。用户也要知道当前账户依赖哪个验证模块,模块何时更新,新版本改变了哪些限制。把规则写进合约只是第一步,谁能修改合约同样决定安全性。
所以,Newton Protocol 的合约级执行不该被理解成更复杂的钱包功能。它是在前端之外建立一条无法绕开的资产防线。网页负责把操作讲清楚,代理负责规划路径,合约只负责判断这笔调用是否越过规则。哪一层遭到干扰,都不能单独改变最终权限。
接下来更值得检查的是,Newton Protocol 能否拦截直接 RPC 调用,能否识别合法合约里的恶意参数,也能否防止管理员通过升级绕开原有规则。正常页面里的风控提示并不能证明什么。关掉网页,修改 calldata,再从另一个入口提交,交易依旧过不了,才说明这道防线真正落在链上。先看这些对抗测试,不急着下结论。$NEWT #Newt
Ver tradução
当同一套策略的资金规模从小额测试放大后,我在 @NewtonProtocol 上关注的核心不再是收益率,而是Agent凭什么承载更大的资金体量。在小额交易中,一次异常滑点尚可视为执行误差,但资金放大后,微小的路由偏移或权限越界都会演变为真实的资产损失。为了确认 Agent 是否始终恪守规则,我不得不将几笔交易的 calldata、授权额度与最终到账情况进行逐一核对,这项验证工作,远比评估策略收益更耗时。 传统 Bot 的瓶颈往往不在于策略不够智能,而在于资金规模越大,信任成本呈指数级上升。用户通常只能看到回测数据和最终的成交结果,却无法透视运行中的代码是否被暗中替换,更无法确认 Bot 是否在运行中临时扩大了授权范围。一个长期掌握资产权限的黑盒,即使历史战绩完美,也不能以此透支无条件的信任。 Newton Protocol 提供的破局思路是先验证,再放量。它通过策略约束,严格限定了可调用合约、单笔额度上限及有效时间窗口;利用 simulatePolicy 在执行前预演资产变化,并通过密码学证明、将代码状态与任务结果强绑定。在这种机制下,Agent 可以在规则框架内寻找最优执行路径,但每一次操作都必须留下可核验的证据。这意味着,大额授权的安全性建立在严密的代码规则之上,而非运营方的信用背书。 这恰恰是 Newton Protocol 对 Bot 进化方向的重新定义,能力强只代表它能完成任务,而可验证才决定它是否配得上管理更多资金。诚然,Newton Protocol 仍需证明在高频场景下,其验证机制不会拖累执行效率。但在大额资产面前,执行快上几秒,远不如清晰证明资金如何被使用来得重要。真正的资金信任,应当随着可验证证据的增加而巩固,而不是随着运行时间的推移而盲目累积。#newt $NEWT
当同一套策略的资金规模从小额测试放大后,我在 @NewtonProtocol 上关注的核心不再是收益率,而是Agent凭什么承载更大的资金体量。在小额交易中,一次异常滑点尚可视为执行误差,但资金放大后,微小的路由偏移或权限越界都会演变为真实的资产损失。为了确认 Agent 是否始终恪守规则,我不得不将几笔交易的 calldata、授权额度与最终到账情况进行逐一核对,这项验证工作,远比评估策略收益更耗时。

传统 Bot 的瓶颈往往不在于策略不够智能,而在于资金规模越大,信任成本呈指数级上升。用户通常只能看到回测数据和最终的成交结果,却无法透视运行中的代码是否被暗中替换,更无法确认 Bot 是否在运行中临时扩大了授权范围。一个长期掌握资产权限的黑盒,即使历史战绩完美,也不能以此透支无条件的信任。

Newton Protocol 提供的破局思路是先验证,再放量。它通过策略约束,严格限定了可调用合约、单笔额度上限及有效时间窗口;利用 simulatePolicy 在执行前预演资产变化,并通过密码学证明、将代码状态与任务结果强绑定。在这种机制下,Agent 可以在规则框架内寻找最优执行路径,但每一次操作都必须留下可核验的证据。这意味着,大额授权的安全性建立在严密的代码规则之上,而非运营方的信用背书。

这恰恰是 Newton Protocol 对 Bot 进化方向的重新定义,能力强只代表它能完成任务,而可验证才决定它是否配得上管理更多资金。诚然,Newton Protocol 仍需证明在高频场景下,其验证机制不会拖累执行效率。但在大额资产面前,执行快上几秒,远不如清晰证明资金如何被使用来得重要。真正的资金信任,应当随着可验证证据的增加而巩固,而不是随着运行时间的推移而盲目累积。#newt $NEWT
Na minha primeira vez usando uma nova exchange, o processo que menos gostei foi: primeiro recarregar e só depois ir testando os botões aos poucos. A área de ordens, as configurações de alavancagem, o take profit/stop loss e o modo de margem ainda não ficaram bem claros, enquanto o dinheiro real já estava parado na conta. O Demo Trading de @grvt_io inverte a ordem: não precisa fazer depósito primeiro; dá para usar capital simulado e percorrer a página inteira de negociação. Eu fiz uma rodada seguindo o hábito de quem negocia de verdade. Primeiro criei uma conta Demo independente, depois “cunhei” USDT simulado e, em seguida, transferi para a conta de negociação. Desde selecionar o mercado, preencher as quantidades, até enviar uma ordem limitada, cancelar a ordem e visualizar posições — eu cliquei vai e volta em vários pontos. O que realmente é útil não é apenas ver o P&L simulado, e sim entender com antecedência como cada parâmetro altera a posição. O erro de operação do iniciante, na superfície, é clicar no botão errado; por trás, é o sistema de trading que joga o custo de aprendizado em cima do capital real. Contratos perpétuos envolvem margem inicial, margem de manutenção e preço de liquidação estimado — qualquer desvio no entendimento de um campo pode transformar o processo de “familiarizar a interface” em perda real. O Demo Trading usa um ambiente isolado para cortar o risco do dinheiro; a conta simulada e a conta GRVT formal ficam independentes, e os ativos reais não se misturam ao fluxo de testes. $SXT Esse tipo de funcionalidade não serve apenas para iniciantes verem a página. Para quem desenvolve estratégias, dá para testar antes a diferença de execução entre ordens limitadas e ordens a mercado, observar a lógica de disparo do take profit/stop loss e depois verificar como a tela mostra o painel de posições e as taxas de funding. A GRVT permite que o usuário valide o fluxo de operações antes de decidir se vai colocar dinheiro real; isso é mais razoável do que ir aprendendo “fazendo” depois do depósito. $T Mas a execução simulada não consegue representar o mercado real. A profundidade do book, o slippage, o atraso de rede e a pressão emocional mudam os resultados no ambiente de negociação ao vivo. O Demo Trading atualmente também só é disponibilizado na versão web. Ele é adequado para se familiarizar com o fluxo e para corrigir erros de operação, mas não serve para provar que uma estratégia será sempre lucrativa. A GRVT reduz o custo de tentativa a zero em termos de capital; a função vale a pena ser testada primeiro. Se vai ou não fazer depósito, ainda precisa esperar até você entender claramente os riscos. #grvt
Na minha primeira vez usando uma nova exchange, o processo que menos gostei foi: primeiro recarregar e só depois ir testando os botões aos poucos. A área de ordens, as configurações de alavancagem, o take profit/stop loss e o modo de margem ainda não ficaram bem claros, enquanto o dinheiro real já estava parado na conta. O Demo Trading de @grvt_io inverte a ordem: não precisa fazer depósito primeiro; dá para usar capital simulado e percorrer a página inteira de negociação.
Eu fiz uma rodada seguindo o hábito de quem negocia de verdade. Primeiro criei uma conta Demo independente, depois “cunhei” USDT simulado e, em seguida, transferi para a conta de negociação. Desde selecionar o mercado, preencher as quantidades, até enviar uma ordem limitada, cancelar a ordem e visualizar posições — eu cliquei vai e volta em vários pontos.
O que realmente é útil não é apenas ver o P&L simulado, e sim entender com antecedência como cada parâmetro altera a posição.
O erro de operação do iniciante, na superfície, é clicar no botão errado; por trás, é o sistema de trading que joga o custo de aprendizado em cima do capital real. Contratos perpétuos envolvem margem inicial, margem de manutenção e preço de liquidação estimado — qualquer desvio no entendimento de um campo pode transformar o processo de “familiarizar a interface” em perda real. O Demo Trading usa um ambiente isolado para cortar o risco do dinheiro; a conta simulada e a conta GRVT formal ficam independentes, e os ativos reais não se misturam ao fluxo de testes. $SXT
Esse tipo de funcionalidade não serve apenas para iniciantes verem a página. Para quem desenvolve estratégias, dá para testar antes a diferença de execução entre ordens limitadas e ordens a mercado, observar a lógica de disparo do take profit/stop loss e depois verificar como a tela mostra o painel de posições e as taxas de funding. A GRVT permite que o usuário valide o fluxo de operações antes de decidir se vai colocar dinheiro real; isso é mais razoável do que ir aprendendo “fazendo” depois do depósito. $T
Mas a execução simulada não consegue representar o mercado real. A profundidade do book, o slippage, o atraso de rede e a pressão emocional mudam os resultados no ambiente de negociação ao vivo. O Demo Trading atualmente também só é disponibilizado na versão web. Ele é adequado para se familiarizar com o fluxo e para corrigir erros de operação, mas não serve para provar que uma estratégia será sempre lucrativa. A GRVT reduz o custo de tentativa a zero em termos de capital; a função vale a pena ser testada primeiro. Se vai ou não fazer depósito, ainda precisa esperar até você entender claramente os riscos. #grvt
先模拟练练技术再赚钱
67%
Cex 好像都有这个功能
33%
3 Votos • Votação encerrada
Artigo
Um proxy pode negociar por você, mas não pode decidir para onde os fundos vãoUma reinversão automática quase enviou os ganhos para um endereço desconhecido. O script originalmente só era responsável por coletar recompensas, converter em stablecoins e então depositar de volta no pool de fundos. Ao verificar os parâmetros de execução, porém, descobri que o contrato de roteamento permitia que uma parte externa especificasse o destinatário. Para confirmar onde o dinheiro final cairia, eu desmontei e conferi camada por camada a quantidade de approve, o seletor da função e o calldata aninhado. A lógica da estratégia não acusou erro, mas a saída de fundos podia ser substituída. Esse é exatamente o tipo de problema que as fatias de permissão de @NewtonProtocol precisam resolver. Muitos proxies na cadeia são perigosos não por causa de falhas na estratégia, mas porque as permissões concedidas são muito maiores do que a tarefa exige. O robô só quer trocar moedas, mas a conta entrega também a capacidade de efetuar transferências. O robô só quer reinvestir, mas o contrato de roteamento consegue enviar as recompensas geradas para qualquer endereço. Assim que a entrada do modelo for contaminada, o servidor de execução for controlado, ou os parâmetros da transação forem adulterados, o atacante nem sequer precisa obter a chave privada-mestra. Ele só precisa aproveitar uma autorização originalmente legítima para montar uma transação que contraria a intenção do usuário.

Um proxy pode negociar por você, mas não pode decidir para onde os fundos vão

Uma reinversão automática quase enviou os ganhos para um endereço desconhecido. O script originalmente só era responsável por coletar recompensas, converter em stablecoins e então depositar de volta no pool de fundos. Ao verificar os parâmetros de execução, porém, descobri que o contrato de roteamento permitia que uma parte externa especificasse o destinatário. Para confirmar onde o dinheiro final cairia, eu desmontei e conferi camada por camada a quantidade de approve, o seletor da função e o calldata aninhado. A lógica da estratégia não acusou erro, mas a saída de fundos podia ser substituída. Esse é exatamente o tipo de problema que as fatias de permissão de @NewtonProtocol precisam resolver.
Muitos proxies na cadeia são perigosos não por causa de falhas na estratégia, mas porque as permissões concedidas são muito maiores do que a tarefa exige. O robô só quer trocar moedas, mas a conta entrega também a capacidade de efetuar transferências. O robô só quer reinvestir, mas o contrato de roteamento consegue enviar as recompensas geradas para qualquer endereço. Assim que a entrada do modelo for contaminada, o servidor de execução for controlado, ou os parâmetros da transação forem adulterados, o atacante nem sequer precisa obter a chave privada-mestra. Ele só precisa aproveitar uma autorização originalmente legítima para montar uma transação que contraria a intenção do usuário.
Para calcular com clareza onde exatamente está o custo de uma operação cross-chain, eu desmontei, uma por uma, as rotas fornecidas pelo @NewtonProtocol . A opção com menor preço nem sempre é a mais barata. Há uma rota em que a taxa de bridge é menor, mas isso adiciona uma troca de ativos: depois que o valor é creditado, ainda é preciso fazer uma autorização complementar. Quando incluímos o slippage e o Gas dos dois lados integralmente, o custo final acaba sendo maior do que o caminho direto. Eu conferi o valor estimado com o gasto real on-chain em várias rodadas, só então confirmei que o problema estava no critério do orçamento, e não em alguma transação específica estar fora do normal. Em ambientes multi-chain, otimizar Gas nunca é apenas achar a rede com a menor taxa. O nível de congestionamento na cadeia de origem, as tarifas do bridge cross-chain e a liquidez na cadeia de destino alteram o gasto final. Mais oculto ainda é o tempo de confirmação: se uma rota “barata” precisar aguardar por mais tempo, as flutuações de preço nesse intervalo podem apagar diretamente a economia obtida. Muitas rotas só comparam os números no momento de enviar a transação, mas não fazem validação contínua para verificar se o percurso inteiro continua vantajoso. O papel do Newton Protocol é mais próximo de um sistema de decisão de rotas com restrições. Depois que o usuário define a cadeia de destino, o valor esperado de recebimento e o prazo aceitável, o simulatePolicy consegue prever o resultado líquido de diferentes rotas. As restrições de estratégia limitam quais bridges cross-chain e quais quantias de ativos o agente pode utilizar. O nó executor pode ajustar a rota conforme as mudanças em tempo real do Gas, mas não pode ampliar o escopo de autorização usando a economia de custos. Portanto, o “baixo custo” que o Newton Protocol menciona não se refere apenas a um único passo barato; trata-se de reduzir o gasto total do fluxo cross-chain. Se ele consegue, quando houver congestionamento repentino on-chain, abandonar a rota que ficou inválida a tempo — essa é uma parte que eu vou verificar com prioridade nas próximas etapas. Por enquanto, os dados ainda não são suficientes; vou manter a avaliação em aberto. #newt $NEWT
Para calcular com clareza onde exatamente está o custo de uma operação cross-chain, eu desmontei, uma por uma, as rotas fornecidas pelo @NewtonProtocol . A opção com menor preço nem sempre é a mais barata. Há uma rota em que a taxa de bridge é menor, mas isso adiciona uma troca de ativos: depois que o valor é creditado, ainda é preciso fazer uma autorização complementar. Quando incluímos o slippage e o Gas dos dois lados integralmente, o custo final acaba sendo maior do que o caminho direto. Eu conferi o valor estimado com o gasto real on-chain em várias rodadas, só então confirmei que o problema estava no critério do orçamento, e não em alguma transação específica estar fora do normal.

Em ambientes multi-chain, otimizar Gas nunca é apenas achar a rede com a menor taxa. O nível de congestionamento na cadeia de origem, as tarifas do bridge cross-chain e a liquidez na cadeia de destino alteram o gasto final. Mais oculto ainda é o tempo de confirmação: se uma rota “barata” precisar aguardar por mais tempo, as flutuações de preço nesse intervalo podem apagar diretamente a economia obtida. Muitas rotas só comparam os números no momento de enviar a transação, mas não fazem validação contínua para verificar se o percurso inteiro continua vantajoso.

O papel do Newton Protocol é mais próximo de um sistema de decisão de rotas com restrições. Depois que o usuário define a cadeia de destino, o valor esperado de recebimento e o prazo aceitável, o simulatePolicy consegue prever o resultado líquido de diferentes rotas. As restrições de estratégia limitam quais bridges cross-chain e quais quantias de ativos o agente pode utilizar. O nó executor pode ajustar a rota conforme as mudanças em tempo real do Gas, mas não pode ampliar o escopo de autorização usando a economia de custos.

Portanto, o “baixo custo” que o Newton Protocol menciona não se refere apenas a um único passo barato; trata-se de reduzir o gasto total do fluxo cross-chain. Se ele consegue, quando houver congestionamento repentino on-chain, abandonar a rota que ficou inválida a tempo — essa é uma parte que eu vou verificar com prioridade nas próximas etapas. Por enquanto, os dados ainda não são suficientes; vou manter a avaliação em aberto. #newt $NEWT
Ficou tão acostumado com exchanges centralizadas que a parte mais difícil de largar é aquela sensação prática de “pedir e já executar”. O mais difícil de ignorar, porém, é a insegurança depois que você entrega o dinheiro. Quando a cotação aperta, eu ainda me preocupo com o canal de saque e com as reservas da plataforma. Para entender exatamente onde @grvt_io deixa o controle do ativo, testei o fluxo inteiro: recarga, colocação de ordens, cancelamento e saque. Depois conferi o que havia na blockchain em várias rodadas. O tempo foi basicamente gasto confirmando quem assina cada etapa e onde ocorre a liquidação. $BEE Usuários antigos ainda têm memória de quando as exchanges quebraram. O problema nunca foi apenas um erro de gestão de um “único” tipo de plataforma; é que as CEX tradicionais concentram custódia, roteamento de ordens e liquidação no mesmo conjunto de bastidores. O livro de ordens responde rápido, mas o saldo da conta é apenas um número num banco de dados. Os usuários não conseguem validar de forma contínua o estado dos ativos. Assim que a plataforma movimenta os fundos ou pausa os saques, quase não há espaço de manobra para recuperar o controle. $OWL GRVT desmonta essa estrutura em duas camadas. Primeiro, as ordens entram num livro central de ordens limitadas fora da cadeia (off-chain). A baixa latência preserva a experiência fluida de manter, cancelar e consultar posições. Já a transferência de ativos e a liquidação final voltam para uma Validium baseada em ZKsync, em que atualizações de estado são verificadas por provas de conhecimento zero. Quando a GRVT fala em “exchange híbrida”, a chave não é misturar dois rótulos, mas sim fazer com que a eficiência de matching e a custódia de fundos sejam tratadas por mecanismos diferentes. Autocustódia também não significa que o risco desapareceu. Perda de chave privada, falhas de contratos inteligentes e disponibilidade dos dados da Validium ainda precisam ser consideradas. No cenário mais extremo, vale testar se é possível sair do sistema com sucesso. Mas, em comparação com simplesmente entregar as moedas totalmente à plataforma, a GRVT ao menos oferece uma opção diferente de concessões: as negociações podem ficar quase tão “na mão” quanto numa CEX, e o controle dos fundos não precisa ser totalmente cedido. O que eu quero observar daqui em diante é o caminho de saque em estados anormais e a velocidade de geração das provas. Segurança não se cria com página de marketing; tem que ser sustentada por validação contínua ao longo do tempo. A linha da GRVT faz sentido, mas o nível de exigência de engenharia também não é baixo. Vou continuar rodando primeiro; sem pressa para tirar conclusões. Nesta versão, os principais ajustes foram no começo: puxar diretamente, com usuários antigos, a contradição entre conveniência e segurança do dinheiro, e então introduzir a GRVT de forma natural. O nome do projeto foi mantido três vezes, mas espalhado no corpo do texto para evitar repetição rígida como um slogan publicitário. #grvt
Ficou tão acostumado com exchanges centralizadas que a parte mais difícil de largar é aquela sensação prática de “pedir e já executar”. O mais difícil de ignorar, porém, é a insegurança depois que você entrega o dinheiro. Quando a cotação aperta, eu ainda me preocupo com o canal de saque e com as reservas da plataforma. Para entender exatamente onde @grvt_io deixa o controle do ativo, testei o fluxo inteiro: recarga, colocação de ordens, cancelamento e saque. Depois conferi o que havia na blockchain em várias rodadas. O tempo foi basicamente gasto confirmando quem assina cada etapa e onde ocorre a liquidação. $BEE
Usuários antigos ainda têm memória de quando as exchanges quebraram. O problema nunca foi apenas um erro de gestão de um “único” tipo de plataforma; é que as CEX tradicionais concentram custódia, roteamento de ordens e liquidação no mesmo conjunto de bastidores. O livro de ordens responde rápido, mas o saldo da conta é apenas um número num banco de dados. Os usuários não conseguem validar de forma contínua o estado dos ativos. Assim que a plataforma movimenta os fundos ou pausa os saques, quase não há espaço de manobra para recuperar o controle.
$OWL
GRVT desmonta essa estrutura em duas camadas. Primeiro, as ordens entram num livro central de ordens limitadas fora da cadeia (off-chain). A baixa latência preserva a experiência fluida de manter, cancelar e consultar posições. Já a transferência de ativos e a liquidação final voltam para uma Validium baseada em ZKsync, em que atualizações de estado são verificadas por provas de conhecimento zero. Quando a GRVT fala em “exchange híbrida”, a chave não é misturar dois rótulos, mas sim fazer com que a eficiência de matching e a custódia de fundos sejam tratadas por mecanismos diferentes.
Autocustódia também não significa que o risco desapareceu. Perda de chave privada, falhas de contratos inteligentes e disponibilidade dos dados da Validium ainda precisam ser consideradas. No cenário mais extremo, vale testar se é possível sair do sistema com sucesso. Mas, em comparação com simplesmente entregar as moedas totalmente à plataforma, a GRVT ao menos oferece uma opção diferente de concessões: as negociações podem ficar quase tão “na mão” quanto numa CEX, e o controle dos fundos não precisa ser totalmente cedido.
O que eu quero observar daqui em diante é o caminho de saque em estados anormais e a velocidade de geração das provas. Segurança não se cria com página de marketing; tem que ser sustentada por validação contínua ao longo do tempo. A linha da GRVT faz sentido, mas o nível de exigência de engenharia também não é baixo. Vou continuar rodando primeiro; sem pressa para tirar conclusões.
Nesta versão, os principais ajustes foram no começo: puxar diretamente, com usuários antigos, a contradição entre conveniência e segurança do dinheiro, e então introduzir a GRVT de forma natural. O nome do projeto foi mantido três vezes, mas espalhado no corpo do texto para evitar repetição rígida como um slogan publicitário. #grvt
DeX 和 Cex 的完美结合
0%
还是更加相信 Cex
0%
0 Votos • Votação encerrada
Artigo
Em cenários de alta volatilidade, o Newton Protocol consegue se tornar um guarda-chuva de proteção contra stop-loss on-chain?O que realmente me interessa no Newton Protocol não é o verniz de “um agente de IA te ajuda a negociar”, mas se ele consegue transformar um stop-loss on-chain, que hoje depende de um script frágil, em um fluxo de execução automático que seja verificável e sujeito a restrições. Em mercados extremamente voláteis, preço, Gas e liquidez mudam simultaneamente; a confirmação manual da transação costuma chegar tarde demais. O agente de IA só merece ser chamado de “guarda-chuva de proteção contra stop-loss” quando as fronteiras de permissão e as condições de execução também puderem ser verificadas. Eu costumava executar um conjunto de processos de proteção de posições por empréstimo. A lógica parecia não ser complicada: monitorar o fator de saúde, vender parte das garantias quando ele ficasse abaixo do limite, quitar a dívida e puxar a posição de volta para a faixa segura. Mas, na integração real, o problema é que vocês precisam concentrar tudo em alguns segundos. As cotações do oráculo já mudaram, mas a exibição no front-end ainda está atrasada. O status de pending retornado pelos nós RPC está inconsistente. A estimativa de slippage foi calculada com base na antiga liquidez; depois que a transação entra na mempool, o caminho de execução real é novamente disputado. Só colocar os três timestamps — interface de cotação, fator de saúde e recibo da transação — lado a lado já me fez conferir várias vezes. No fim, percebi que o problema não está nas condições de stop-loss, e sim em que, após a mudança das condições de execução, o script continua submetendo mecanicamente usando os parâmetros antigos.

Em cenários de alta volatilidade, o Newton Protocol consegue se tornar um guarda-chuva de proteção contra stop-loss on-chain?

O que realmente me interessa no Newton Protocol não é o verniz de “um agente de IA te ajuda a negociar”, mas se ele consegue transformar um stop-loss on-chain, que hoje depende de um script frágil, em um fluxo de execução automático que seja verificável e sujeito a restrições. Em mercados extremamente voláteis, preço, Gas e liquidez mudam simultaneamente; a confirmação manual da transação costuma chegar tarde demais. O agente de IA só merece ser chamado de “guarda-chuva de proteção contra stop-loss” quando as fronteiras de permissão e as condições de execução também puderem ser verificadas.
Eu costumava executar um conjunto de processos de proteção de posições por empréstimo. A lógica parecia não ser complicada: monitorar o fator de saúde, vender parte das garantias quando ele ficasse abaixo do limite, quitar a dívida e puxar a posição de volta para a faixa segura. Mas, na integração real, o problema é que vocês precisam concentrar tudo em alguns segundos. As cotações do oráculo já mudaram, mas a exibição no front-end ainda está atrasada. O status de pending retornado pelos nós RPC está inconsistente. A estimativa de slippage foi calculada com base na antiga liquidez; depois que a transação entra na mempool, o caminho de execução real é novamente disputado. Só colocar os três timestamps — interface de cotação, fator de saúde e recibo da transação — lado a lado já me fez conferir várias vezes. No fim, percebi que o problema não está nas condições de stop-loss, e sim em que, após a mudança das condições de execução, o script continua submetendo mecanicamente usando os parâmetros antigos.
Na semana passada, ao testar o fluxo de negociação automatizada do @NewtonProtocol , criei para mim uma regra bem específica: se a moeda A subir mais do que um limite configurado, vendo a moeda B e, em seguida, troco o capital obtido por C. Parece apenas três passos, mas na prática é travado na transição de estados. Depois do primeiro trade, a atualização do saldo, a variação do slippage e a próxima autorização precisam estar alinhadas ao mesmo tempo. Só entender como passar os parâmetros das condições levou bastante tempo, e ainda conferi várias vezes os dados retornados pelos dois endpoints. $BEAT Isso não é por botões ruins no front-end; é que, na maioria das automações on-chain, ainda se fica “montando” operações manuais. A carteira assina, o script monitora e o robô executa: cada camada detém parte das permissões, mas não existe um limite único e unificado de validação. Quando a moeda A dispara, quanto da moeda B realmente deve ser vendida, se a moeda C consegue ser comprada dentro da faixa de slippage — qualquer etapa com estado expirado deforma toda a estratégia. Em muitos casos, “automação” é apenas trocar a observação manual do mercado por um script de chave privada em execução contínua. O que o Newton Protocol realmente merece estudo não é substituir o usuário no clique do botão de negociação, mas decompor os combos de condições em regras de execução verificáveis. A estratégia primeiro passa por uma prévia via simulatePolicy, verificando o escopo de ativos, limites e condições de gatilho; então, restrições da estratégia determinam o que a conta de proxy pode fazer. Os nós de execução só podem chamar caminhos de transação dentro dos limites de autorização, e a validação on-chain confirma se o resultado corresponde à intenção original. $XPIN Isso faz o Newton Protocol parecer mais uma infraestrutura de permissões e validação para automação. Ele não resolve apenas “se dá para vender automaticamente moedas”, mas sim como, quando condições complexas disparam em sequência contínua, o executor é restringido e como o processo é verificado. A barreira do Newton Protocol ainda é relativamente alta, e a disputa de estados em cenários de anomalia também precisa continuar sendo testada. Vou seguir mais um tempo, sem pressa de tirar conclusões. #newt $NEWT
Na semana passada, ao testar o fluxo de negociação automatizada do @NewtonProtocol , criei para mim uma regra bem específica: se a moeda A subir mais do que um limite configurado, vendo a moeda B e, em seguida, troco o capital obtido por C. Parece apenas três passos, mas na prática é travado na transição de estados. Depois do primeiro trade, a atualização do saldo, a variação do slippage e a próxima autorização precisam estar alinhadas ao mesmo tempo. Só entender como passar os parâmetros das condições levou bastante tempo, e ainda conferi várias vezes os dados retornados pelos dois endpoints. $BEAT
Isso não é por botões ruins no front-end; é que, na maioria das automações on-chain, ainda se fica “montando” operações manuais. A carteira assina, o script monitora e o robô executa: cada camada detém parte das permissões, mas não existe um limite único e unificado de validação. Quando a moeda A dispara, quanto da moeda B realmente deve ser vendida, se a moeda C consegue ser comprada dentro da faixa de slippage — qualquer etapa com estado expirado deforma toda a estratégia. Em muitos casos, “automação” é apenas trocar a observação manual do mercado por um script de chave privada em execução contínua.
O que o Newton Protocol realmente merece estudo não é substituir o usuário no clique do botão de negociação, mas decompor os combos de condições em regras de execução verificáveis. A estratégia primeiro passa por uma prévia via simulatePolicy, verificando o escopo de ativos, limites e condições de gatilho; então, restrições da estratégia determinam o que a conta de proxy pode fazer. Os nós de execução só podem chamar caminhos de transação dentro dos limites de autorização, e a validação on-chain confirma se o resultado corresponde à intenção original. $XPIN
Isso faz o Newton Protocol parecer mais uma infraestrutura de permissões e validação para automação. Ele não resolve apenas “se dá para vender automaticamente moedas”, mas sim como, quando condições complexas disparam em sequência contínua, o executor é restringido e como o processo é verificado. A barreira do Newton Protocol ainda é relativamente alta, e a disputa de estados em cenários de anomalia também precisa continuar sendo testada. Vou seguir mais um tempo, sem pressa de tirar conclusões. #newt $NEWT
Quando o meu telemóvel está no auge da agitação, os apps da exchange, das finanças e dos corretores no exterior ficam todos enfileirados. Ontem à noite quis ajustar a carteira: primeiro vender moedas, depois esperar o dinheiro cair, transferir para stablecoins e, por fim, confirmar a rede. Foram vinte minutos de confusão — e a cotação já tinha corrido. @grvt_io A primeira sensação que me deu foi: finalmente não preciso instalar cinco apps no telemóvel. Os veteranos de mercado sabem: “múltiplos apps” não é só chatice de interface; é o capital sendo fatiado em ilhas. A cada vez que você troca de plataforma, cria mais uma camada de risco: recarga, levantamento, ponte cross-chain e risco de conta. A Grvt quer trazer a entrada para trading cripto e ativos tradicionais para um mesmo sistema financeiro em cadeia, com arquitetura Validium, tecnologia ZK e, ao mesmo tempo, uma book de ordens off-chain para equilibrar privacidade, velocidade e liquidação verificável. Esse rumo está certo: uma conta unificada de verdade não deveria ser apenas empilhar botões numa página. $EVAA Mas ainda vou jogar um balde de água fria. É fácil agregar o “ponto de entrada”; é difícil agregar liquidez real. Os horários de negociação de diferentes ativos, os limites de custódia, a profundidade de cotação e as regras de liquidação não desaparecem só porque um app “some” automaticamente. A interface até parece unificada, mas será que a eficiência do capital no fundo consegue ser unificada também? Eu me preocupo mais com isso em condições de mercado extremas: a execução de ordens, a liquidação entre mercados e a saída de ativos continuam fluindo sem atrito? Poupar quatro apps, mas ter de esperar quatro camadas de confirmação — isso é totalmente contraintuitivo! $TAC Quanto ao token da Grvt, eu não vou olhar apenas a curva de preço após o listamento. Se conseguir formar um ciclo entre compensação por taxas, segurança da custódia/pledge, permissões de governança e incentivos do ecossistema, então o volume de negociação da plataforma pode realmente se consolidar como uma necessidade real. Se o uso depender principalmente de subsídios, a chamada “captura de valor” continua sendo uma prosperidade alugada por pouco tempo. Por isso, vou continuar usando uma pequena carteira para testar a profundidade de trading da Grvt, a velocidade de liquidação e a experiência de entrada e saída. Eu reconheço a direção, mas não vou apostar pesado apenas porque é “uma plataforma unificada” e tem três palavras na manchete. Construir uma entrada unificada de finanças é um osso duro; eu respeito a Grvt por insistir em brigar pelo infrastructure. A questão é: quando todos os ativos são colocados dentro de um único ponto de entrada, ganhamos eficiência maior ou um risco mais concentrado em um único ponto? #grvt
Quando o meu telemóvel está no auge da agitação, os apps da exchange, das finanças e dos corretores no exterior ficam todos enfileirados. Ontem à noite quis ajustar a carteira: primeiro vender moedas, depois esperar o dinheiro cair, transferir para stablecoins e, por fim, confirmar a rede. Foram vinte minutos de confusão — e a cotação já tinha corrido. @grvt_io A primeira sensação que me deu foi: finalmente não preciso instalar cinco apps no telemóvel.
Os veteranos de mercado sabem: “múltiplos apps” não é só chatice de interface; é o capital sendo fatiado em ilhas. A cada vez que você troca de plataforma, cria mais uma camada de risco: recarga, levantamento, ponte cross-chain e risco de conta. A Grvt quer trazer a entrada para trading cripto e ativos tradicionais para um mesmo sistema financeiro em cadeia, com arquitetura Validium, tecnologia ZK e, ao mesmo tempo, uma book de ordens off-chain para equilibrar privacidade, velocidade e liquidação verificável. Esse rumo está certo: uma conta unificada de verdade não deveria ser apenas empilhar botões numa página. $EVAA
Mas ainda vou jogar um balde de água fria. É fácil agregar o “ponto de entrada”; é difícil agregar liquidez real. Os horários de negociação de diferentes ativos, os limites de custódia, a profundidade de cotação e as regras de liquidação não desaparecem só porque um app “some” automaticamente. A interface até parece unificada, mas será que a eficiência do capital no fundo consegue ser unificada também? Eu me preocupo mais com isso em condições de mercado extremas: a execução de ordens, a liquidação entre mercados e a saída de ativos continuam fluindo sem atrito? Poupar quatro apps, mas ter de esperar quatro camadas de confirmação — isso é totalmente contraintuitivo! $TAC
Quanto ao token da Grvt, eu não vou olhar apenas a curva de preço após o listamento. Se conseguir formar um ciclo entre compensação por taxas, segurança da custódia/pledge, permissões de governança e incentivos do ecossistema, então o volume de negociação da plataforma pode realmente se consolidar como uma necessidade real. Se o uso depender principalmente de subsídios, a chamada “captura de valor” continua sendo uma prosperidade alugada por pouco tempo.
Por isso, vou continuar usando uma pequena carteira para testar a profundidade de trading da Grvt, a velocidade de liquidação e a experiência de entrada e saída. Eu reconheço a direção, mas não vou apostar pesado apenas porque é “uma plataforma unificada” e tem três palavras na manchete. Construir uma entrada unificada de finanças é um osso duro; eu respeito a Grvt por insistir em brigar pelo infrastructure. A questão é: quando todos os ativos são colocados dentro de um único ponto de entrada, ganhamos eficiência maior ou um risco mais concentrado em um único ponto? #grvt
一个 app 解决大问题
0%
分散的 app 更专业
100%
1 Votos • Votação encerrada
Artigo
Estável não falta velocidade: o Newton Protocol adiciona a camada de execução de regrasÀ meia-noite, sentado diante do computador, olhando para os dados on-chain que pulam na tela, de repente me veio à cabeça a experiência que tive anos atrás, quando trabalhava como ajudante em uma empresa de logística fazendo separação. Naquela época, o armazém tinha acabado de colocar uma esteira de separação automatizada. Assim que uma encomenda era carregada na esteira, o sistema primeiro fazia a leitura do destino, do peso e verificava se havia ou não materiais perigosos. Se tudo estivesse dentro dos critérios, a encomenda seguia diretamente para o canal correspondente. Mas, quando a leitura identificava alguma anomalia, a esteira automaticamente desviava o fluxo para uma área de conferência feita por pessoas — nunca deixava encomendas com problemas entrarem no processo normal de envio. Mais tarde entendi que, de fato, um sistema logístico eficiente não depende apenas de a esteira correr mais rápido, e sim de as regras de cada nó estarem bem ajustadas e executarem com precisão. Essa experiência de trabalho me fez lembrar das dificuldades que as stablecoins enfrentam hoje para realmente entrar em cenários de pagamentos e liquidação. E @NewtonProtocol está tentando, por uma abordagem extremamente “hardcore”, levar essa lógica de triagem para cada transferência na rede. $TAC

Estável não falta velocidade: o Newton Protocol adiciona a camada de execução de regras

À meia-noite, sentado diante do computador, olhando para os dados on-chain que pulam na tela, de repente me veio à cabeça a experiência que tive anos atrás, quando trabalhava como ajudante em uma empresa de logística fazendo separação. Naquela época, o armazém tinha acabado de colocar uma esteira de separação automatizada. Assim que uma encomenda era carregada na esteira, o sistema primeiro fazia a leitura do destino, do peso e verificava se havia ou não materiais perigosos. Se tudo estivesse dentro dos critérios, a encomenda seguia diretamente para o canal correspondente. Mas, quando a leitura identificava alguma anomalia, a esteira automaticamente desviava o fluxo para uma área de conferência feita por pessoas — nunca deixava encomendas com problemas entrarem no processo normal de envio. Mais tarde entendi que, de fato, um sistema logístico eficiente não depende apenas de a esteira correr mais rápido, e sim de as regras de cada nó estarem bem ajustadas e executarem com precisão. Essa experiência de trabalho me fez lembrar das dificuldades que as stablecoins enfrentam hoje para realmente entrar em cenários de pagamentos e liquidação. E @NewtonProtocol está tentando, por uma abordagem extremamente “hardcore”, levar essa lógica de triagem para cada transferência na rede. $TAC
Antes eu tinha muito medo de que o módulo de gerenciamento de posição desse algum problema ao fazer backtest de estratégias quantitativas: os limites de controle de risco viravam algo praticamente inútil, e uma única “black swan” podia engolir meses de lucro. Esse receio de que o controle de risco falhasse foi o que me deixou ainda mais atento quando fui estudar casos de uso de DeFi Vault da @NewtonProtocol . Os veteranos que trabalham com cofres e agregadores de rendimento sabem: muitos pools não explodem por causa de uma estratégia ruim, e sim porque as regras de controle de risco ficam só na documentação, sem serem realmente embutidas na camada de execução.$VELVET Hoje, a dor da indústria é bem tocante: muitos cofres ainda mantêm o controle de qualificação do investidor e limites de posição na etapa de revisão manual; quando algo dá errado, só dá para rastrear depois, e aí já é tarde demais. A abordagem do Newton Protocol transforma essas regras em lógica executável verificável on-chain. Com o Newton Keystore e um módulo de permissões programável, a verificação de qualificação do investidor, as limitações de posição e a triagem de contrapartes são “soldadas” em cada fluxo de entrada e saída de capital do cofre. Seja para rebalancear a estratégia ou para subscrições de fundos externas, tudo tem de passar primeiro pelo portão de controle de risco on-chain. Essa forma de antecipar as fronteiras de segurança realmente dá mais tranquilidade! Mas a realidade costuma ser um pouco cruel, apesar do ideal. Mesmo com um controle de risco on-chain tão detalhado como o do Newton Protocol, ainda há desafios na entrega: aquelas regras complexas de limitação de posição, quando acionadas de verdade em cenários de alta volatilidade e alta frequência, conseguem suportar congestionamento instantâneo e atrasos? Ou as regras acabam sendo aplicadas com defasagem, quando o preço já entrou em colapso?$TAC Falando em aumentar a posição, no fundo eu não estou tão ansioso.$NEWT , nesta estrutura de controle de risco, assume o papel de fazer staking do nó verificador e de cobrir taxas de execução; a lógica de captura de valor é clara. Porém, o teto depende de quantos cofres estão dispostos a terceirizar o controle de risco para esse arcabouço on-chain. No estágio atual, eu prefiro tratá-lo como um “plano reserva” de segurança para observar, esperando que mais cofres reais gerem dados, sem pressa de fazer um aporte pesado. Por fim, vai minha homenagem a este grupo de desenvolvedores que se dedicam a esmiuçar o controle de risco “na base” dos cofres e tentam transformar as regras de segurança em código. Se, no futuro, todos os DeFi Vault rodarem em um framework verificável como o do Newton Protocol, estaremos mais próximos do ideal de nunca mais ter que se preocupar com explosões de risco — mas ainda falta quanto para chegar lá?#newt
Antes eu tinha muito medo de que o módulo de gerenciamento de posição desse algum problema ao fazer backtest de estratégias quantitativas: os limites de controle de risco viravam algo praticamente inútil, e uma única “black swan” podia engolir meses de lucro. Esse receio de que o controle de risco falhasse foi o que me deixou ainda mais atento quando fui estudar casos de uso de DeFi Vault da @NewtonProtocol . Os veteranos que trabalham com cofres e agregadores de rendimento sabem: muitos pools não explodem por causa de uma estratégia ruim, e sim porque as regras de controle de risco ficam só na documentação, sem serem realmente embutidas na camada de execução.$VELVET
Hoje, a dor da indústria é bem tocante: muitos cofres ainda mantêm o controle de qualificação do investidor e limites de posição na etapa de revisão manual; quando algo dá errado, só dá para rastrear depois, e aí já é tarde demais. A abordagem do Newton Protocol transforma essas regras em lógica executável verificável on-chain. Com o Newton Keystore e um módulo de permissões programável, a verificação de qualificação do investidor, as limitações de posição e a triagem de contrapartes são “soldadas” em cada fluxo de entrada e saída de capital do cofre. Seja para rebalancear a estratégia ou para subscrições de fundos externas, tudo tem de passar primeiro pelo portão de controle de risco on-chain. Essa forma de antecipar as fronteiras de segurança realmente dá mais tranquilidade!
Mas a realidade costuma ser um pouco cruel, apesar do ideal. Mesmo com um controle de risco on-chain tão detalhado como o do Newton Protocol, ainda há desafios na entrega: aquelas regras complexas de limitação de posição, quando acionadas de verdade em cenários de alta volatilidade e alta frequência, conseguem suportar congestionamento instantâneo e atrasos? Ou as regras acabam sendo aplicadas com defasagem, quando o preço já entrou em colapso?$TAC
Falando em aumentar a posição, no fundo eu não estou tão ansioso.$NEWT , nesta estrutura de controle de risco, assume o papel de fazer staking do nó verificador e de cobrir taxas de execução; a lógica de captura de valor é clara. Porém, o teto depende de quantos cofres estão dispostos a terceirizar o controle de risco para esse arcabouço on-chain. No estágio atual, eu prefiro tratá-lo como um “plano reserva” de segurança para observar, esperando que mais cofres reais gerem dados, sem pressa de fazer um aporte pesado.
Por fim, vai minha homenagem a este grupo de desenvolvedores que se dedicam a esmiuçar o controle de risco “na base” dos cofres e tentam transformar as regras de segurança em código. Se, no futuro, todos os DeFi Vault rodarem em um framework verificável como o do Newton Protocol, estaremos mais próximos do ideal de nunca mais ter que se preocupar com explosões de risco — mas ainda falta quanto para chegar lá?#newt
Artigo
Diga adeus à autorização de caixa-preta; Newton está reescrevendo a lógica subjacente da operação segura na cadeiaÀ meia-noite, sentado diante do computador, observando os dados na corrente (on-chain) saltarem na tela, de repente lembrei das minhas experiências de quando eu jogava, anos atrás, o jogo do “loop verde”. Naquela época, o erro mais comum que os iniciantes cometiam era endividar-se até o limite e construir uma torre de defesa de nível máximo; mas, por causa de estouro de dano ou de a corrente de controle se romper, acabavam sendo derrotados por um bando de pequenos monstros, extremamente velozes, que derrubavam a posição. Só depois eu entendi que o que realmente sustenta desafios de alta dificuldade não é apenas empilhar valores numéricos de um único ponto, e sim a coordenação precisa e o encaixe lógico entre vários tipos de torres básicas. No ecossistema on-chain complexo, nós também enfrentamos exatamente a mesma disputa; e @NewtonProtocol está tentando, de uma forma extremamente “hardcore”, reestruturar a lógica subjacente dessa confiança para a coordenação.$ARTX

Diga adeus à autorização de caixa-preta; Newton está reescrevendo a lógica subjacente da operação segura na cadeia

À meia-noite, sentado diante do computador, observando os dados na corrente (on-chain) saltarem na tela, de repente lembrei das minhas experiências de quando eu jogava, anos atrás, o jogo do “loop verde”. Naquela época, o erro mais comum que os iniciantes cometiam era endividar-se até o limite e construir uma torre de defesa de nível máximo; mas, por causa de estouro de dano ou de a corrente de controle se romper, acabavam sendo derrotados por um bando de pequenos monstros, extremamente velozes, que derrubavam a posição. Só depois eu entendi que o que realmente sustenta desafios de alta dificuldade não é apenas empilhar valores numéricos de um único ponto, e sim a coordenação precisa e o encaixe lógico entre vários tipos de torres básicas. No ecossistema on-chain complexo, nós também enfrentamos exatamente a mesma disputa; e @NewtonProtocol está tentando, de uma forma extremamente “hardcore”, reestruturar a lógica subjacente dessa confiança para a coordenação.$ARTX
Antes, no laboratório eu ajustava sensores e o que mais temia era um deadlock na conexão: eu enviava comandos ao hardware, mas eles ficavam travados pelo caminho, indo e voltando sem parar. Essa experiência péssima só terminou de vez depois que eu usei @NewtonProtocol . Antes, para fazer funcionar o staking de cross-chain, eu precisava primeiro autorizar na cadeia A, esperar na ponte e então alternar para a cadeia B para confirmar. No meio disso, se o slippage ficasse grande demais ou se algum nó travasse, os fundos ficavam “presos”, como um braço mecânico travado e incapaz de se mover. Essa interação manual “no câmbio” realmente deveria ser substituída diante da condução automatizada on-chain trazida pelo Newton Protocol.$ARTX Agora, as dores do setor são muito óbvias: todo mundo corre atrás de desempenho, mas ninguém resolve a ruptura entre intenção e execução. O Newton Protocol, com sua arquitetura centrada em intenções e o módulo de resolução atômica, empacota transações cross-chain multi-etapas complexas em um comando do tipo “faça sozinho”. Eu testei algumas estratégias predefinidas, como monitorar o preço do token, disparar compras cross-chain e então depositar automaticamente em empréstimos; essa sensação de fluidez realmente traz grande conveniência ao público! Mas a teoria é bela, e a realidade costuma ser um pouco dura. No Newton Protocol, a execução totalmente automática pode gerar um paradoxo de mecanismos: quando as estratégias de todo mundo apontam para a mesma oportunidade de arbitragem ou para a mesma linha de liquidação, a alta concorrência pode instantaneamente “entupir” a largura de banda da execução e até causar desvios do oracle? Esse espaço de tolerância sacrificado em nome da eficiência, em cenários extremos, pode virar outra espécie de cisne negro?$SKYAI Quanto ao ambiente de produção, eu sou sempre comedida.$NEWT assume o papel de fazer a admissão no staking dos nós e de pagar as taxas: a lógica flui bem, mas o teto depende do tamanho total da escala de transações do pipeline automatizado. No momento, eu prefiro tratá-lo como uma ferramenta para aumentar eficiência, e não como algo para apostar tudo. Por fim, é preciso prestar homenagem a esse grupo de devs que se dedica de verdade à automação. Se, no futuro, toda a ação on-chain for impulsionada pelo Newton Protocol, onde deve ser traçada a última linha de controle soberano da humanidade?#newt
Antes, no laboratório eu ajustava sensores e o que mais temia era um deadlock na conexão: eu enviava comandos ao hardware, mas eles ficavam travados pelo caminho, indo e voltando sem parar. Essa experiência péssima só terminou de vez depois que eu usei @NewtonProtocol . Antes, para fazer funcionar o staking de cross-chain, eu precisava primeiro autorizar na cadeia A, esperar na ponte e então alternar para a cadeia B para confirmar. No meio disso, se o slippage ficasse grande demais ou se algum nó travasse, os fundos ficavam “presos”, como um braço mecânico travado e incapaz de se mover. Essa interação manual “no câmbio” realmente deveria ser substituída diante da condução automatizada on-chain trazida pelo Newton Protocol.$ARTX
Agora, as dores do setor são muito óbvias: todo mundo corre atrás de desempenho, mas ninguém resolve a ruptura entre intenção e execução. O Newton Protocol, com sua arquitetura centrada em intenções e o módulo de resolução atômica, empacota transações cross-chain multi-etapas complexas em um comando do tipo “faça sozinho”. Eu testei algumas estratégias predefinidas, como monitorar o preço do token, disparar compras cross-chain e então depositar automaticamente em empréstimos; essa sensação de fluidez realmente traz grande conveniência ao público!
Mas a teoria é bela, e a realidade costuma ser um pouco dura. No Newton Protocol, a execução totalmente automática pode gerar um paradoxo de mecanismos: quando as estratégias de todo mundo apontam para a mesma oportunidade de arbitragem ou para a mesma linha de liquidação, a alta concorrência pode instantaneamente “entupir” a largura de banda da execução e até causar desvios do oracle? Esse espaço de tolerância sacrificado em nome da eficiência, em cenários extremos, pode virar outra espécie de cisne negro?$SKYAI
Quanto ao ambiente de produção, eu sou sempre comedida.$NEWT assume o papel de fazer a admissão no staking dos nós e de pagar as taxas: a lógica flui bem, mas o teto depende do tamanho total da escala de transações do pipeline automatizado. No momento, eu prefiro tratá-lo como uma ferramenta para aumentar eficiência, e não como algo para apostar tudo.
Por fim, é preciso prestar homenagem a esse grupo de devs que se dedica de verdade à automação. Se, no futuro, toda a ação on-chain for impulsionada pelo Newton Protocol, onde deve ser traçada a última linha de controle soberano da humanidade?#newt
Artigo
Quando o mempool ganha semáforo, o Newton Protocol está reescrevendo as regras do tráfego na redeTenho estado a reanalisar, durante este período, aquela experiência de *front-running* quase me deixou à beira da falência há seis meses. Foi precisamente esse momento de susto que me fez começar a decompor em profundidade a lógica subjacente de @NewtonProtocol na camada de intercepção de transações. Naquela altura, eu participava numa oferta de tokens de um novo blockchain público, extremamente em alta. Para conseguir alocar, no exato momento em que submeti a transação, fui alvo de uma matilha de robôs. Eles captaram de forma precisa o conteúdo da minha transação ainda não confirmada e se anteciparam, saltando a fila e empacotando primeiro, fazendo com que eu comprasse ativos por um preço várias vezes acima do normal, que deveria ser o preço corrente. Mais tarde, ao reanalisar, percebi que a raiz do problema não está na transação em si, mas nesta etapa: o mempool. Todas as transações — sejam elas conformes ou não, sejam intencionalmente *front-run* ou não — são lançadas de forma indistinta nesse pool público à espera de serem empacotadas. É como um cruzamento sem quaisquer regras de trânsito: todos os carros entram de uma vez, e quem *front-ran* mais rápido, ou quem oferece mais gorjeta, consegue passar primeiro. Essa desordem na organização faz com que comportamentos maliciosos e transações normais tenham exatamente o mesmo direito de passagem.

Quando o mempool ganha semáforo, o Newton Protocol está reescrevendo as regras do tráfego na rede

Tenho estado a reanalisar, durante este período, aquela experiência de *front-running* quase me deixou à beira da falência há seis meses. Foi precisamente esse momento de susto que me fez começar a decompor em profundidade a lógica subjacente de @NewtonProtocol na camada de intercepção de transações. Naquela altura, eu participava numa oferta de tokens de um novo blockchain público, extremamente em alta. Para conseguir alocar, no exato momento em que submeti a transação, fui alvo de uma matilha de robôs. Eles captaram de forma precisa o conteúdo da minha transação ainda não confirmada e se anteciparam, saltando a fila e empacotando primeiro, fazendo com que eu comprasse ativos por um preço várias vezes acima do normal, que deveria ser o preço corrente.
Mais tarde, ao reanalisar, percebi que a raiz do problema não está na transação em si, mas nesta etapa: o mempool. Todas as transações — sejam elas conformes ou não, sejam intencionalmente *front-run* ou não — são lançadas de forma indistinta nesse pool público à espera de serem empacotadas. É como um cruzamento sem quaisquer regras de trânsito: todos os carros entram de uma vez, e quem *front-ran* mais rápido, ou quem oferece mais gorjeta, consegue passar primeiro. Essa desordem na organização faz com que comportamentos maliciosos e transações normais tenham exatamente o mesmo direito de passagem.
Na semana passada eu executei um script de agente de IA para fazer uma comparação e negociação de preços entre plataformas. O agente concluiu a comparação e a negociação em nível de milissegundos, mas a etapa de liquidação travou na aprovação manual de conformidade, então eu esperei exatamente quarenta minutos a mais — e a janela de oportunidade já tinha se fechado. Essa quebra de desempenho me fez perceber que o que o @NewtonProtocol precisa resolver é exatamente essa dor real. $EVAA Os problemas do pagamento tradicional on-chain são bem claros: mesmo que a decisão inteligente no front-end rode rápido, a verificação de conformidade no back-end sempre será o gargalo que fica para trás. O agente de IA negocia o preço, mas o dinheiro fica travado pelo caminho esperando aprovação manual ou confirmação on-chain. Esse custo de atrito é amplificado em cenários de alta frequência a ponto de irritar qualquer pessoa. Quem aguenta ganhar a negociação, mas perder na etapa de liquidação por causa de atraso? A proposta do Newton Protocol é transformar a validação de conformidade em um serviço atômico no backend. Depois que o agente conclui a negociação de comparação de preços, ele dispara o pagamento diretamente. A correspondência de regras e a pontuação de risco fora da cadeia rodam em paralelo e terminam em milissegundos. No framework de execução do Newton Protocol, a camada de negociação e a camada de liquidação são completamente desacopladas. A lógica de liquidação sem atrito depende do design que separa o motor de estratégia dos canais de pagamento — não há mais necessidade de intervenção humana para criar gargalos. $CLO Na camada de tokens, o $NEWT nesta jornada assume o papel de “combustível” para chamadas de rede. A cada validação automática de conformidade e confirmação de liquidação que o agente dispara, isso consome o limite de recursos do NEWT. Esse consumo está diretamente ligado à atividade real do agente, e não a narrativas de “atividade sem fazer nada” para sustentar a avaliação. Se o agente de IA realmente conseguir fazer negociação, conformidade e pagamento ao mesmo tempo, você ficaria confortável em entregar para ele a execução de compras do dia a dia e a gestão da distribuição de recursos? #newt
Na semana passada eu executei um script de agente de IA para fazer uma comparação e negociação de preços entre plataformas. O agente concluiu a comparação e a negociação em nível de milissegundos, mas a etapa de liquidação travou na aprovação manual de conformidade, então eu esperei exatamente quarenta minutos a mais — e a janela de oportunidade já tinha se fechado. Essa quebra de desempenho me fez perceber que o que o @NewtonProtocol precisa resolver é exatamente essa dor real. $EVAA
Os problemas do pagamento tradicional on-chain são bem claros: mesmo que a decisão inteligente no front-end rode rápido, a verificação de conformidade no back-end sempre será o gargalo que fica para trás. O agente de IA negocia o preço, mas o dinheiro fica travado pelo caminho esperando aprovação manual ou confirmação on-chain. Esse custo de atrito é amplificado em cenários de alta frequência a ponto de irritar qualquer pessoa. Quem aguenta ganhar a negociação, mas perder na etapa de liquidação por causa de atraso?
A proposta do Newton Protocol é transformar a validação de conformidade em um serviço atômico no backend. Depois que o agente conclui a negociação de comparação de preços, ele dispara o pagamento diretamente. A correspondência de regras e a pontuação de risco fora da cadeia rodam em paralelo e terminam em milissegundos. No framework de execução do Newton Protocol, a camada de negociação e a camada de liquidação são completamente desacopladas. A lógica de liquidação sem atrito depende do design que separa o motor de estratégia dos canais de pagamento — não há mais necessidade de intervenção humana para criar gargalos. $CLO
Na camada de tokens, o $NEWT nesta jornada assume o papel de “combustível” para chamadas de rede. A cada validação automática de conformidade e confirmação de liquidação que o agente dispara, isso consome o limite de recursos do NEWT. Esse consumo está diretamente ligado à atividade real do agente, e não a narrativas de “atividade sem fazer nada” para sustentar a avaliação.
Se o agente de IA realmente conseguir fazer negociação, conformidade e pagamento ao mesmo tempo, você ficaria confortável em entregar para ele a execução de compras do dia a dia e a gestão da distribuição de recursos? #newt
Inicia sessão para explorar mais conteúdos
Junta-te a utilizadores de criptomoedas de todo o mundo na Binance Square
⚡️ Obtém informações úteis e recentes sobre criptomoedas.
💬 Com a confiança da maior exchange de criptomoedas do mundo.
👍 Descobre perspetivas reais de criadores verificados.
E-mail/Número de telefone
Mapa do sítio
Preferências de cookies
Termos e Condições da Plataforma