胖鸟

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

¿De verdad hay gente que participe? 1 punto por Alpha canjeado por 1u... ¿no habrán perdido hasta con los calzoncillos?

A veces descubro que la parte más fácil de que una empresa tenga problemas no es cuando no hay nadie responsable, sino cuando todos son responsables en cierta medida. El producto cree que el equipo de desarrollo ya lo confirmó; el desarrollo piensa que operaciones ya lo revisó y aprobó; y operaciones considera que el área legal no tendrá objeciones. Al final, cuando ocurre el problema, todos participaron, pero nadie puede explicar con claridad en qué paso exacto falló.

Más tarde vi el @NewtonProtocol , un diseño muy pequeño, y de pronto pensé en que yo nunca había prestado mucha atención a Authorization Receipt. Yo creía que era simplemente un comprobante que se genera después de que la ejecución se completa, similar a los registros y a los recibos. Más que nada, para conservar un archivo. Pero a medida que lo fui mirando con más detalle, me di cuenta de que aparecía en un lugar bastante extraño.

No está colocado al final del flujo, sino junto con Authorization, Policy y Operator, convirtiéndose en parte del proceso completo de ejecución. Después volví a revisar esa sección varias veces, y fue cuando entendí que mi interpretación inicial estaba sesgada. Antes, muchos sistemas guardaban resultados: que la transacción fue exitosa, que los activos se transfirieron, que el estado se actualizó… todo eso deja constancia. Pero cuando realmente hay un problema, la gente suele seguir preguntando: ¿quién aprobó? ¿en base a qué regla? ¿se saltó algún paso? Esa información, muchas veces, solo se puede reconstruir poco a poco con los registros.

Newton, al parecer, lleva tiempo resolviendo justamente ese problema. Authorization Receipt no registra únicamente la ejecución completada. Conecta una autorización, la Policy correspondiente, el Operator que la ejecutó y el resultado final en una cadena completa. A partir de ahora, si alguien cuestiona esa ejecución, el sistema no necesita volver a confiar en un nodo en particular ni consultar al equipo de operaciones: solo necesita seguir esa constancia y volver a verificar cada paso, encontrando las bases correspondientes de por qué cada cosa era válida.

Al ver esto, de repente descubrí que en Newton, Receipt en realidad no se parece tanto a un simple comprobante, sino más bien a una cadena de responsabilidades de una ejecución.

Así que, al volver a mirar Authorization Receipt ahora, pienso que lo que realmente deja no es un registro. Lo que deja es toda la evidencia de la ejecución, desde la autorización y el juicio hasta la finalización. Quizá lo que realmente puede confiarse a largo plazo no sea un nodo, ni una plataforma específica, sino el propio proceso, que cualquier persona puede volver a verificar.
#newt $NEWT

Increíble

En el último mes no he reclamado el Airdrop #ALPHA , ¿tan alocadamente se está poniendo esto? Esta noche a las 19:00 habrá un airdrop de cajas sorpresa con 251 puntos, la verdad es un poco exagerado

Me siento mal; en un solo ciclo solo puedes comer uno

Un poco indeciso: ¿esperar al nuevo proyecto de la próxima semana #tge o mejor reclamar primero?

估计又要有一批人赚麻了

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

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

兄弟们都准备好了吗？

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

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

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

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

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

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

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

不要再被最近吹的天花乱坠＄GRVT 欺骗了

这玩意对散户的友好度没有你想象的那么高。

这两天同步 @grvt_io 的官方开发文档，结果在结算数据结构里翻到了两个极少人讨论的venue和 broker，追踪完底层的清算路径后我心里一惊，大家都在盯着明面上的买卖怎么玩，却忽略了它在底层给大户和机构开辟的场外RFQ。散户跟大户玩同样的衍生品，天然要吃一记信息差的闷棍。

我发现在#grvt 的底盘里，普通的单向买卖走公开订单簿，但只要涉及到复杂的期权组合或者超大额的区块交易，系统会直接把这些大额流量切到专门的 RFQ 询价会话里，并通过像 CoinRoutes 这样的顶级经纪商在链下进行私密撮合。

这意味着什么？

最优质、能把对冲成本压到最低的大宗报价，在链下就已经被机构和专业经纪商提前分食干净了。散户在前端看到的公开盘口，其实只是机构吃剩的残渣。你在公开订单簿里费尽心思去配对多空，不仅买卖价差更宽，还得承担由于各条腿分开成交时的隐形Legging Risk风险。这种把最肥的大宗定价权锁在链下经纪商圈子里的设计，在无形中给普通散户筑起了一道看不见的高墙。

不过撇开这种对散户的报价隔离不谈，站在大盘系统抗风险的宏观角度，这套把大宗和零售彻底分流的架构反而是极具智慧的。传统链上交易所之所以动不动就流动性断层，就是因为散户的散单和机构的大宗头寸全混在一个池子里。一旦市场剧烈洗盘，机构千万级的多腿头寸如果直接在公开盘口强制平仓，会瞬间引发连环踩踏，把散户的止损单全部连坐引爆。而 GRVT 让大宗交易走独立的链下 RFQ 路由，用经纪商机制当隔离带，把这些毁灭性的核弹头在场外悄悄化解掉了。

它虽然让零售盘口少了一点暴利套利的机会，却换来了整个大盘在风暴中极其稳定的盘口弹性，让散户逃命时随时能撤

真是小看了@NewtonProtocol 的野心，昨天夜里我自己去翻它白皮书关于跨链架构和算力同步的那几章，我才发现它躲在暗处真正想解决的骚操作，居然是干掉多链时代最让人头疼的合规碎片化与跨链桥信任危机。

$NEWT 白皮书里提到了一个叫基于EigenLayer ELIP-008规范的多链算力table 同步协议，这名字听着挺硬核对吧？我当时看第一眼也觉得是在拽名词，但稍微一琢磨，我发现它解决的其实是链上金融一个超级恶心、而且以前根本没人能解决的死结，那就是怎么让不同链上的应用，共享同一套高强度的以太坊级别经济安全底牌。

你想啊现在的多链世界碎片化得厉害，一个稳定币或者RWA项目，如果想同时在 Ethereum、Base、Arbitrum和Optimism 上发行，传统的做法极其痛苦。你要么在每条链上都单独去找一套合规验证节点，要么就得用那种极其脆弱的第三方跨链桥，天天提心吊胆等着被黑客跨链投毒，结果就是大机构根本不敢把巨额资金往 L2 上放。

以前大家都默认这是没办法的硬伤，但 Newton这次直接在底层用密码学把这个死结给解开了，在#newt 的逻辑里，它的去中心化算力网络只需要在以太坊主网注册并进行EigenLayer再质押一次。一旦以太坊上的节点成员、质押权重或者因作恶被罚没的状态发生变化，Newton的节点们会在底层集体吐出一个用 BLS 私钥盖章的算力表默克尔根。

最扫的操作是这个包含着主网几十亿节点经济安全担保的签名根，会通过完全无许可的 Relayer疯狂同步到所有主流L2。目标链上的智能合约只需要用纯数学公式去验证这个 BLS 聚合签名 一旦对账成功本地的算力权重表瞬间同步更新。

这套ELIP-008的跨链算力同步流我算看明白了，这项目根本不是在讲宏大的合规故事，它是真拿出了别人抄不走的密码学硬功夫，把多链的合规铁轨直接统一成了一张无缝的安全大网。

很多人看@NewtonProtocol 觉得眼熟，以为它又是市面上那堆 ZK、MPC 或者同态加密的缝合怪。但如果你翻透它的白皮书，你会发现它有很多独一无二的亮点。

第一个标签叫 Newton Rego，别的项目做风控策略，只能用现成的规则库做简单的条件判断。但$NEWT 直接魔改了企业级标准的 Rego 编译器，在里面硬生生地嵌了一个专属的密码学扩展包。

这导致合规人员在写同一行声明式代码时，不仅能做传统的黑名单筛选，还能直接调用底层接口去恢复 secp256k1 和 Ed25519 的跨链身份签名，这种将链下多签判定与跨链原生存根原子化绑定的语法在 Web3 中是独一份。

第二个标签是#newt 的牛顿隐私信封，市面上大多项目做隐私玩的基本都是加密然后发送的交钥匙游戏，但 NPE 是一个高度复合的密码学构造，它利用门限加密的同时，强制要求用户+DApp进行双重签名授权，最硬核的是它在 wire format层，就把密文死死绑定到了特定的策略客户端和单次交易意图上。任何黑客或恶意节点，都绝无可能在其他上下文里去重放或挪用这份隐私数据，从根源上斩断了中间人攻击。

最让人头皮发麻、最不可能被其他项目套用的是它的 ZK 罚没挑战机制，别人搞 ZK 证明是老老实实为每个特定的合规业务去手写定制的电路，不仅痛苦而且无法通用，但 Newton 利用了 Rego 语言纯函数、绝对确定的数学特性，干脆把整个 Rego 语言解释器直接塞进了 SP1 或 Risc0 零知识虚拟机里！

这种情况产生的结果就是任何风控人员随手写出的一行代码，底层自动具备了 ZK 可证明属性。外部挑战者发现节点作恶时，可以直接用这个通用 ZK 证明去干翻 EigenLayer 上的作恶节点瞬间触发链上资产罚没，甚至为了配合这套算力，节点仅在以太坊主网质押一次，就能通过 BLS 默克尔树将算力权重安全同步到所有主流 L2。

Recientemente corté un script de alta frecuencia y se cayó: 2000U en fichas intenté capturar oportunidades de arbitraje en @grvt_io . Entraron varias órdenes, pero al hacer la conciliación me quedé en blanco: algunas órdenes que en teoría debían “comer” quedaron con el precio de ejecución varios puntos básicos por debajo/encima del precio justo del libro de órdenes. Esta sesión en real me despertó por completo. El proyecto presume que las órdenes privadas fuera de la cadena con privacidad impiden a los “clappers” (interceptadores), pero en condiciones de mercado extremas, en realidad estamos pagando un “impuesto” invisible en forma de privacidad que se intercambia de manera fantasma.

#grvt es uno de los puntos clave introduce un libro de órdenes de privacidad cifrado impulsado por tecnología de cero conocimiento. Su lógica base es: barajar y cifrar en la capa fuera de la cadena todas las órdenes limitadas, pujas y profundidades de usuarios de toda la red, de modo que los robots “clampers” de tres partes y los equipos de cuantificación que cazan en el mainnet no pueden obtener datos del mempool. ¿Qué significa esto? Que si abres una orden dentro de ese sistema, en teoría tienes una privacidad muy alta frente a la caza.

Pero pongamos un balde de agua fría: en escenarios extremos, este sistema trae otro golpe invisible, que es el deslizamiento dentro de una “caja sorpresa” provocado por la liquidez no transparente. Como la profundidad total del libro es un completo “caja negra” para el mercado, los traders comunes y los market makers de terceros no pueden observar en tiempo real, como en un exchange tradicional, el grosor real de las órdenes en distintos niveles de precio.

Anoche, cuando el mercado entró en pánico y fue arrastrado por la liquidación, la profundidad real en la red cifrada fuera de la cadena ya estaba muy segmentada, pero en el frente, debido al aislamiento de datos, aún se mostraba normal. Mi orden de compra chocó directamente en una zona de vacío sin profundidad pública suficiente, lo que hizo que la “diferencia de precio” invisible se llevara una operación que debía haber tomado ganancias. Esta pasividad que no se ve en el libro de órdenes es especialmente letal en un mercado donde todo se decide por segundos.

No obstante, si lo vemos al revés: después de quejarme del velo del deslizamiento, también hay que admitir que, en su línea on-chain de protección anti-mal, se clava muy fuerte en la base de los fondos.

Lo que más repugna de las plataformas tradicionales es desconectar la red (“talar la línea”) y ejecutar explosiones dirigidas en puntos específicos. Su liquidación forzada corre como código de caja negra dentro de servidores centralizados. Pero #grvt fija las líneas rojas más esenciales de liquidación y la verificación del estado de la cuenta en contratos inteligentes en la cadena. Si necesitas o no que te reduzcan forzosamente la posición, eso lo determina automáticamente el código inteligente público; la parte del proyecto no puede interferir ni modificar tu línea de liquidación.

En resumen, aunque #grvt sacrifica la transparencia del libro de órdenes, también ayuda a que los retail eliminen la bala más tóxica con la que los “señores/ballenas” hacen mal.

Recientemente descubrí que @NewtonProtocol dedicó bastante espacio a hablar sobre Attestation, Verification y Replay. Al principio, la verdad, no lo entendí muy bien, porque en mi forma de pensar, mientras el resultado final sea correcto, el cómo se completa en medio no parece ser tan importante. Quién es el ejecutor, qué ocurre durante la ejecución… eso me suena más a detalles de implementación que a cosas que el protocolo realmente le importe.

Hasta que más tarde volví a ordenar todo el flujo de ejecución, desde Transaction Intent entrando al Gateway, pasando por la Policy Evaluation y la ejecución del Operator, y luego por la Attestation. Ahí fue cuando descubrí dónde estaban mis dudas.

$NEWT en realidad no parece preocuparse nunca por si el resultado es correcto, sino por por qué el resultado merece ser confiado. Transaction Intent no se ejecuta directamente solo por entrar en el sistema; antes debe pasar por Policy Evaluation. Y cuando el Operator termina su tarea, tampoco se convierte inmediatamente en el resultado final; después aún hace falta una Attestation, y si es necesario incluso puede haber Replay.

A medida que sigo leyendo, más claro me queda que todas ellas, en el fondo, responden a esta pregunta: ¿la ejecución se realizó realmente siguiendo las reglas que toda la red reconoce y acepta de manera conjunta?

Fue también en ese punto cuando me di cuenta de que #Newt no registra el resultado de una ejecución, sino el proceso de una ejecución. Luego lo pensé con más cuidado y de pronto recordé una pregunta que antes nunca había considerado seriamente.

¿Por qué muchos sistemas se enfocan más en demostrar el resultado, mientras que Newton invierte tanto esfuerzo en demostrar el proceso?

Cada vez siento más que, detrás de estos dos enfoques de diseño, en realidad hay dos maneras completamente distintas de construir la confianza: si solo demuestras el resultado, al final todavía tienes que confiar en la persona que te dice el resultado. Pero si todo el proceso de ejecución puede verificarse, entonces lo que realmente hay que confiar ya no es un Operator en particular, sino una ruta de ejecución que cualquiera puede volver a verificar.

Así que creo que Newton no pretende realmente reestructurar el flujo de ejecución; lo que en verdad está desafiando es una suposición predeterminada que existe desde hace muchos años: ¿con que el resultado sea correcto es suficiente?

Al menos para Newton, parece que no
quizá esa sea la verdadera razón de la existencia de Attestation, Verification y Replay. No protegen solo el resultado, sino todo el proceso que hace que ese resultado sea válido.

He estado leyendo sin parar el blog de @grvt_io estos días. Hay una palabra que aparece especialmente con frecuencia: Capital Productivity. Al principio, en realidad no le presté mucha atención; pensé que era simplemente un concepto de marketing. Al final, ¿no es el intercambio lo que se impone con la liquidez, las comisiones y la velocidad de negociación? Si un platform de trading habla continuamente de la productividad del capital, suena un poco a que no es algo que deba decir un exchange.

Así que cuando vi por primera vez One Balance y Unified Margin, yo lo interpreté todo en la dirección de la optimización de la experiencia. Luego, volví a poner varias entradas del blog juntas y las releí; lo que al principio era solo para entender qué problema resolvía exactamente Unified Margin, terminó pareciéndome cada vez más extraño.

La oferta oficial casi no hablaba de la velocidad de negociación, ni insistía constantemente en Hybrid Exchange. En cambio, hablaba una y otra vez de Capital Productivity, Capital Drag, e incluso en la sección posterior sobre Yield Layer. Todo el tiempo se discutía la misma cuestión.

Fue entonces cuando me di cuenta de que quizá desde el principio estaba entendiendo mal. GRVT parece estar preguntando algo distinto: por qué una sola porción de capital solo puede asumir un único propósito. Y solo hasta aquí entendí por qué la entidad oficial insiste tanto en Capital Drag. Lo verdaderamente desperdiciado quizá no es la velocidad de negociación, sino el proceso en el que el capital espera, migra y se vuelve a configurar continuamente.

Después volví a revisar One Balance, Unified Margin y Yield Layer, y de repente descubrí que, aunque se ven como tres funciones diferentes, en realidad siempre están respondiendo a la misma pregunta: si se puede hacer que la misma porción de capital no se detenga cada vez que cambia el uso.

Por eso, ahora que miro hacia atrás, cada vez tengo más claro que lo que GRVT realmente quiere reestructurar no es “un exchange”. Lo que está poniendo en duda es un hábito predeterminado del sistema financiero que casi nadie cuestiona: ¿por qué, cuando el capital completa una tarea, tiene que terminar esa etapa y empezar otra?

Al menos ahora me inclino cada vez más por esta interpretación: lo que GRVT realmente quiere preservar no es una cuenta en particular, ni un producto en particular, sino la continuidad de la misma porción de capital.

Trading, beneficios, inversión y pagos no son cuatro porciones distintas de capital. En realidad, deberían ser la misma porción de capital cumpliendo distintas responsabilidades en diferentes etapas.

Así que cuando ahora vuelvo a mirar Capital Productivity, al contrario, siento que lo que realmente quiere optimizar no es la eficiencia del trading, sino la forma en que el capital opera en todo el sistema financiero.
#grvt

久しぶりに新しいTGEに来た、最近新しくリリースされた@grvt_io もまた大きな利益をもたらすもの。

@grvt_io ではお得なBoosterキャンペーンも登場しており、2ポイントで価値8uのトークンに交換できるので、絶対に見逃さないでください。

最初に@grvt_io のHEX Architectureを見たとき、ずっと疑問がありました。もし取引のマッチングがオフチェーンで行われるなら、オンチェーンはいったい何を根拠に信じられるのか？

私の理解では、ブロックチェーンの最大の価値は「確実性」です。最もコアなマッチングプロセスがチェーンを離れるなら、これは従来の取引所と何が違うのでしょうか？そのため最初は、GRVTはパフォーマンスと非中央集権の間で妥協しただけだと思っていました。しかし実行フローを見直してみると、最初の理解が間違っていたと気づきました。

#grvt が本当に解決しているのは、「取引をどこに置くか」ではなく、オフチェーンで生み出された取引状態が最終的にオンチェーンに認められるようにする方法です。その設計では、注文はまず Off-chain Matching Engine に入り、そこでマッチングが完了します。こうすることで、高頻度取引がオンチェーンの承認を待つ必要がなくなり、従来の取引所に近い執行効率を得られます。

面白いのは、約定が成立を意味しないことです。取引結果は On-chain Settlement を通じて最終的に確定する必要があります。オンチェーンのルールとスマートコントラクトによって最終確認が行われる、つまりオフチェーンが高頻度計算を担当し、オンチェーンが最終状態を担当するのです。

ここでようやく、#grvt が分解しようとしているのは「状態を生成する」ことと「状態を定義する」ことの境界だと理解しました。Matching Engine は取引結果を生成し、Settlement Layer は資産状態を確認し、Smart Contract Vault はユーザーの資産が完全に中央集権的な台帳に依存しないよう保証します。

だから私は、Hybrid Exchangeは単にCEXとDEXを組み合わせただけではないと感じています。実際に変えているのは、取引システムにおける「信頼の境界」です。取引のすべてのステップが必ずしもオンチェーンで行われる必要はありませんが、最終的にユーザーの資産状態に影響する部分は、オンチェーンのルールによって必ず確認されなければならないのです。

その後、Unified Balanceを見て、この論理が取引の決済だけに留まらず、資産状態管理全体に貫通していることに気づきました。取引、証拠金、収益はもはや分断された口座状態ではなく、統一された体系の中で流動し、資産が特定の場面に固定されるのではなく、継続的に変化しうるようになります。

今度はGRVTを見てみると、これは「オフチェーンで生まれた状態が、どのようにオンチェーンの現実に入っていくか」という仕組みを解決し、それがオンチェーンの世界に認められる現実になることに、より近いと思います

Siempre he pensado que lo más importante de un sistema de autorización son las reglas.

Mientras la Policy esté escrita de forma lo bastante rigurosa, el sistema puede decidir qué transacciones deben ejecutarse y cuáles deben rechazarse. Así que, cuando al principio leí el Whitepaper de @NewtonProtocol , mi atención se centró en la Rego Policy y en el Authorization Flow.

Hasta que más tarde volví a mirar la sección de Data Provider, me di cuenta de que había pasado por alto un problema más subyacente: incluso si las reglas son precisas, si los datos de entrada no son confiables, la decisión final no tiene sentido.

La Policy Evaluation de $NEWT no ejecuta las reglas directamente. El Operator necesita llamar a datos externos como Oracle Price, Sanctions Feed y Risk Score, y luego introducir esas entradas en la Rego Policy para tomar una decisión. Sin embargo, esos datos en sí no existen de forma nativa en la cadena. Entonces me di cuenta: esto parece ser un problema que todos los sistemas de automatización en cadena suelen enfrentar. Todos debaten si los contratos inteligentes son confiables, pero casi nunca se pregunta: ¿los datos que el sistema ve al tomar decisiones realmente son confiables?

Si el estado de una dirección se evalúa mal, si hay desviaciones en la puntuación de riesgo o si distintos nodos obtienen datos inconsistentes, entonces incluso si el cálculo de la Policy, la Attestation y el Consensus es correcto, el resultado solo podría ser “correcto” en base a entradas incorrectas.

La propuesta de #newt para este problema es muy interesante. No elige convertirse en el único proveedor de datos, sino que convierte el Data Provider en un módulo enchufable. El Operator puede ejecutar WASM Data Provider de forma independiente, obtener datos en un entorno aislado y, con la información que observa, generar una ECDSA Attestation para que la propia entrada también quede dentro del alcance de la verificación.

Al llegar aquí, entendí que antes lo había interpretado mal. Yo creía que el núcleo de Newton era hacer que las reglas fueran verificables, pero en realidad primero tiene que resolver que, durante la ejecución, las reglas se enfrenten a la misma realidad confiable. La Policy determina cómo el sistema juzga; el Data Provider determina qué ve el sistema.

Lo realmente difícil no es hacer que la máquina ejecute las reglas, sino asegurarse de que, antes de que la máquina tome una decisión, el mundo que ve no haya sido alterado por entradas erróneas. Tal vez esa sea la razón de ser del diseño del Data Provider Ecosystem de $NEWT .

En el futuro, la competencia entre sistemas en cadena no será solo por las reglas y la ejecución, sino por quién puede lograr que toda la red, antes de tomar decisiones, se base en una misma realidad.

Siempre he pensado que, mientras todos los nodos obtengan la misma versión de los datos, el consenso no debería tener problemas. Así que, cuando al principio vi el "Streaming Two-Phase Consensus" en el whitepaper @NewtonProtocol , mi primera reacción fue optimizar el rendimiento: Gateway, NATS y Streaming parecían estar solo para reducir la latencia.

Luego volví a leer esa sección y me di cuenta de que la había entendido mal.

El whitepaper menciona que el Operator invoca, por su cuenta, el WASM Data Provider para obtener datos externos como el Oracle Price, Sanctions Feed, Risk Score, etc. Incluso al consultar la misma fuente de datos, si los caminos de red y los tiempos de respuesta difieren, cada Operator podría ver datos distintos. Y como la BLS Aggregate Signature exige que todos los nodos firmen mensajes completamente idénticos, si hay discrepancias en los datos, no se puede generar la firma agregada.

Por eso Newton lo dividió en dos etapas. En la fase Prepare, cada Operator obtiene los datos de manera independiente y genera una ECDSA Attestation; el Gateway luego los consolida para formar un Canonical Dataset unificado. En la fase Evaluate, todos los Operator ejecutan Rego Policy basándose en la misma versión de los datos y, finalmente, generan una BLS Signature que puede agregarse.

Al llegar a este punto, me di cuenta de que yo había estado entendiendo mal todo el tiempo.

Siempre pensé que el consenso resolvía quién tenía razón.

Pero Newton en realidad resuelve primero otra cosa: si todos están hablando de la misma realidad.

Si cada Operator se enfrenta a datos correspondientes a diferentes momentos del tiempo, entonces, aunque la Policy Evaluation posterior, las Attestation y la BLS Aggregation estén completamente correctas, solo estarán demostrando realidades distintas.

Ahora que lo veo en retrospectiva, cada vez tengo más claro que lo más importante del Streaming Two-Phase Consensus no es mejorar el rendimiento, sino unificar primero la realidad y luego unificar la respuesta. Quizá lo verdaderamente difícil nunca haya sido llegar a un consenso, sino asegurarse de que todos estén enfrentando el mismo mundo.
#newt $NEWT