胖鸟

Recientemente también tuve éxito al entrar en la billetera $QQQB

He estado jugando con la billetera durante 3/4 días; por ahora el desgaste promedio es de 0.8/10.000, y ya puedo decir que salí del sufrimiento. Solo que el tiempo es bastante “tenebroso”

Después de dejar de jugar las partidas de trading #ALPHA🔥 , siento que toda mi persona se elevó 😆#BsB

这段时间上了不少链上项目，在众多项目当中如何挑选到一个好的项目，不用担心资金安全成为了一个关键的点，所以当第一次看到@BabylonLabs_io 时，就被其独特的机制所吸引。

对于babylon我其实有一个比较直观的理解，既然它想让外部资产参与其他网络的安全，那么核心问题应该是有没有足够多的资产进入质押，毕竟在很多PoS网络里安全强度往往和质押规模直接相关。

后面深度参与之后我发现这个理解少了一层，有时候资产存在并不代表安全真的发生。

这个听起来有点绕，如果一个网络只是看到大量资产被锁定，就认为自己获得了安全，那其实是不够的。应该还要看这些资产有没有按照规则参与网络运行？这些安全承诺有没有被正确执行？其他链又如何确认这份安全是真的？

顺着这个想法的话我觉得Babylon最有意思的地方不是它引入了更多质押资本，而是它试图建立一套安全证明的过程。

在Babylon当中更关注价值有没有转化成可信的安全结果，这也是为什么要设计 Checkpoint机制，因为Babylon面对的不是单链内部共识，而是让外部网络认可这份共识结果。

emm...这和资产桥完全不同，桥解决的是资产移动，而 #baby 想解决的是信任移动。

这就蛮有意思了，往深了说它其实改变了安全的定义，他让安全结果本身成为一种可以被验证、被使用的东西。

但这里也存在一个问题，如果未来大量链依赖Babylon提供安全证明，那么 $BABY 自己的证明机制就会成为新的信任入口。一旦这个入口无法被参与者充分理解和监督，原本想减少信任成本的系统，可能反而制造新的依赖。

所以让我来看的话，我觉得它真正有意思的地方，并不是简单把更多资产带入区块链安全。而是它在重新研究安全到底应该如何被证明。Babylon想做的是把这种信任变成一种可以验证、可以连接的基础设施

¿Es así, siempre ha sido así? Cuando vi por primera vez @BabylonLabs_io , en realidad lo entendí de forma bastante natural como un sistema de Staking más grande. Y durante todo este tiempo, siempre que hay más staking, hay más validadores, y a mayor número de validadores, mayor es la seguridad de la red.

Después, lo probé en primera persona ejecutando el proceso de staking que diseña Babylon y descubrí que esta comprensión era un poco superficial. Si solo se trata de aumentar el capital de seguridad, entonces no haría falta diseñar roles distintos como Delegator y Finality Provider.

Siento que Babylon quizá no pretende resolver si hay suficientes activos, sino, una vez que esos activos entran al sistema, cómo convertirlos en una seguridad que otras redes puedan reconocer.

Esa diferencia es bastante clave. En una sola red PoS, normalmente los stakers, los validadores y los que ejecutan la seguridad están vinculados, pero hay una brecha: cuando la seguridad empieza a fluir entre redes, este modelo muestra problemas.

“Gente profesional para trabajos profesionales”: quien aporta el capital no necesariamente está hecho para operar infraestructura de validación. Y quien opera la infraestructura no necesariamente quiere volver a cultivar un sistema de validación. Por eso, lo que hace Babylon no es simplemente aumentar el número de validadores, sino separar el proceso de seguridad: el Delegator aporta apoyo económico, el Finality Provider se encarga de participar en las confirmaciones de seguridad y la Consumer Chain utiliza el resultado final de seguridad.

Al aterrizar todas las responsabilidades y siguiendo esa lógica, creo que el objetivo real de Babylon podría ser transformar los recursos de seguridad desde capital en una capacidad de red en la que se pueda confiar.

Muchos de los problemas del pasado en distintas cadenas se parecen a esto: como si cada ciudad tuviera que construir su propia red eléctrica. Funciona, pero el costo es realmente alto. Y eso es precisamente lo que Babylon quiere explorar.

Emm.. aquí también hay un problema: al separar los roles, el sistema es más flexible, pero los límites de las responsabilidades se vuelven más complejos. Si surge un problema de seguridad, ¿debería atribuirse al capital en staking o a los nodos que ejecutan la seguridad? Y si los participantes se enfocan más en el rendimiento que en el mantenimiento a largo plazo de la red, ¿los incentivos económicos seguirán siendo efectivos? Esas son las cosas que Babylon necesita validar en adelante.

Babylon también está intentando ver si la seguridad puede separarse, combinarse y ofrecerse como una capacidad a otras redes. Si este modelo funciona, en el futuro la manera de construir seguridad para las blockchains podría cambiar.#baby $BABY

Ahora surgen proyectos nuevos continuamente y los estilos son cada vez más variados. Hasta antes de hoy, siempre me preguntaba por qué @BabylonLabs_io eligió proteger la finalización, en lugar de rediseñar todo un conjunto de consenso.

Porque el problema más difícil de una blockchain nunca es generar bloques: la mayoría de las redes puede producir bloques rápidamente. Lo realmente complicado es, cuando aparecen conflictos entre dos estados, cómo determina la red cuál de los resultados es finalmente irreversible. Las redes PoS tradicionales suelen depender de su propio conjunto de validadores, manteniendo la finalización mediante activos en garantía. Pero para las redes nuevas, la cantidad de validadores, el tamaño de las garantías y la seguridad económica requieren una acumulación a largo plazo.

Hmm… lo interesante es que Babylon no eligió replicar el mecanismo de consenso de Bitcoin o Ethereum. En cambio, eligió entrar desde la Finality. En el diseño de Babylon, la cadena PoS sigue ejecutando su propio consenso y los validadores siguen siendo responsables de generar bloques. Lo que hace Babylon es enviar estados clave mediante checkpoints a la red de Bitcoin, para que Bitcoin proporcione un ordenamiento adicional en el tiempo y garantías de inmutabilidad.

Lo más, lo más, lo más clave es que Babylon no reemplaza la seguridad original. En vez de eso, en la capa de confirmación final se agrega una capa adicional de seguridad económica. Y eso también me hace darme cuenta de que lo que cambia realmente Babylon no es quién produce los bloques. Entonces, creo que esos Finality Provider no son simplemente nodos: asumen la responsabilidad de la confirmación de la finalización.

Siento que el foco de Babylon podría ser cómo una red puede lograr una mayor determinación de estados. Esto realmente resuelve el problema que ha existido a largo plazo en las redes PoS. Muchas cadenas nuevas no es que no puedan funcionar, sino que, en las primeras etapas, les resulta difícil establecer garantías de finalización lo suficientemente fuertes.

Babylon ofrece una ruta nueva. Ahora mirando hacia atrás, creo que lo más valioso de Babylon no es que le dé a BTC un uso más.

Babylon está intentando demostrar que la seguridad también puede modularizarse: una red puede tener su propia lógica de ejecución y, al mismo tiempo, aprovechar una base de finalización más fuerte.

Si en el futuro cada vez más cadenas adoptan este modelo, la seguridad de blockchain podría dejar de ser algo que se construye de nuevo en cada cadena, y poco a poco convertirse en una infraestructura base que se puede combinar. #baby $BABY

第一次看 @BabylonLabs_io 的时候，我其实很自然地把它归类成了一个 Staking 协议。这套逻辑和过去很多 PoS 网络里的质押模型没有太大区别。

但后来重新看#baby 的整个架构，我发现这个理解可能太简单了。如果它只是想做一个 Staking 产品，其实没有必要设计这么复杂的角色关系。从 Delegator 到 Finality Provider，再到 Consumer Chain 和 Checkpoint，Babylon 花大量精力处理的，并不是如何让资产被锁住，而是另一个更难的问题。

一个网络如何确认另一个网络提供的安全是真实有效的？

这个问题让我沉默一会，因为很多系统默认了安全只能来自自己。一个链维护自己的验证者，运行自己的共识，然后相信自己的状态。但如果未来越来越多网络需要共享安全，真正困难的地方就不是有没有资本，而是这些资本如何被转化成其他网络可以接受的安全证明。

也就是说质押只是开始，真正重要的是谁证明安全发生了。再看$BABY 我觉得它最有意思的地方，是它没有简单复制传统 PoS 的结构，而是把不同角色承担的责任拆开。Delegator 提供经济支持，Finality Provider负责参与状态确认，Consumer Chain使用这些确认结果获得额外安全。资本、安全执行和状态验证，不再被绑定在同一个角色上。

这让我想到很多基础设施的问题，很多时候，系统缺少的并不是资源，而是资源之间无法被信任，如果没有一种方式证明这部分安全确实有效，这些资源就无法真正流动起来。

Babylon做的事情本质上是在建立这种连接。

Checkpoint并不是简单记录某个状态，而是在不同网络之间提供一种可以被验证的共识结果。它解决的不是数据传输问题，而是安全状态如何被另一个系统认可的问题。
所以现在回头看我觉得 Babylon 最有价值的地方，可能并不是它创造了一个新的 Staking 市场。

Hace un tiempo, cuando charlaba con un amigo sobre internet, de repente descubrí que @BabylonLabs_io en realidad tiene muchas similitudes con esto. Primero, una pregunta para todos: si nos remontamos a los primeros tiempos de internet, y un equipo de startups quiere crear un sitio web, ¿cuál es el problema principal que primero debe resolver?

El problema más realista sería resolver el tema del servidor. En aquella época, muchas empresas necesitaban comprar sus propios servidores y mantener salas de servidores, porque la infraestructura todavía no se había abstraído. Hasta que apareció la computación en la nube, los desarrolladores ya no tenían que montar la infraestructura de base desde cero.

Este punto se parece un poco a lo que ocurre con la blockchain ahora. Cuando se lanzan muchas redes PoS nuevas, además de desarrollar la aplicación en sí, también hay que resolver la pregunta: ¿de dónde viene la seguridad?

En la mayoría de las cadenas del pasado, la forma era crear un sistema de validadores a través de su propia economía de tokens, de modo que los participantes hicieran staking de activos para mantener la red. Pero para los proyectos tempranos, esto no es fácil. Si la red no tiene suficiente valor, cuesta atraer validadores; y si no tiene suficiente seguridad, es difícil atraer usuarios y ecosistema. En realidad, este problema se parece un poco al de internet en sus inicios.

baby, mediante un modelo de seguridad compartida, permite que las nuevas redes PoS no tengan que empezar de cero construyendo su propio sistema de seguridad, sino que puedan conectarse con las capacidades de seguridad que proporciona #baby .

Y en ese proceso, $BABY conecta la nueva red que necesita seguridad con los participantes que están dispuestos a proporcionar seguridad. A través de mecanismos como Finality Provider, permite que estos proveedores de seguridad participen en el proceso de confirmación de distintas redes, mientras que la red conectada no tiene que depender por completo de construir su propia seguridad a través de su sistema de validadores.

Esto me hace pensar que Babylon no solo está agregando “más recursos de seguridad”, sino que está cambiando la forma en que se usan esos recursos. Antes, cada cadena era como una aplicación de internet temprana: tenía que resolver sus propios problemas de capa base. Pero si en el futuro surgen cada vez más cadenas, quizá la seguridad no tenga que seguir construyéndose desde cero en cada una con el mismo esquema.

Por supuesto, si esta dirección puede funcionar o no, el tiempo lo dirá. Porque la seguridad, a diferencia de los recursos de cómputo, involucra consenso, incentivos económicos y el comportamiento a largo plazo de los participantes; y esos problemas son mucho más complejos que los de la computación en la nube.

Quizá en el futuro, en el desarrollo de la infraestructura de blockchain, la competencia no sea únicamente por el rendimiento y el tamaño del ecosistema, sino también por quién puede hacer que la seguridad sea tan fácil de conseguir y usar como los recursos de cómputo.

Recientemente, mientras leía debates en la comunidad @BabylonLabs_io , vi que alguien mencionaba temas relacionados con los Finality Provider. Entonces pensé de repente: si en el futuro cada vez más redes dependen de Babylon para obtener seguridad, ¿en qué se basan realmente quienes participan en asegurar que no van a hacer el mal?

Esta pregunta es bastante interesante. Cuando la gente habla de seguridad compartida, la primera reacción suele ser mirar cuántos activos entran o cuántas redes se conectan, pero casi nadie indaga qué pasa si un participante en verdad hace el mal: ¿cómo sabe el sistema?, ¿cómo lo castiga?

Antes, en las redes PoS este problema era relativamente directo. Los validadores bloqueaban sus propios activos y, si ocurría una doble firma, la cadena podía aplicar directamente Slash. Pero el escenario al que se enfrenta Babylon no es exactamente igual: los participantes aportan capacidades adicionales de seguridad; el sistema necesita considerar cómo asegurar que esa participación externa siga teniendo restricciones suficientemente fuertes.

Pero aquí hay una diferencia: en el PoS tradicional, los validadores y la red en sí pertenecen al mismo sistema; si alguien se equivoca, la cadena puede gestionarlo directamente. Sin embargo, el $BABY se enfrenta a otra situación: las personas que proporcionan seguridad no pertenecen a esas redes.

Y justamente a partir de este problema empecé a fijarme en EOTS. Para participar en la confirmación, Finality Provider necesita generar una firma única mediante EOTS. Si un participante intenta crear un estado conflictivo en la misma altura, esta conducta deja evidencia identificable, que a su vez activa el castigo.

Creo que donde EOTS realmente hace efecto no es para que los participantes se vuelvan más fuertes, sino para que sepan que hacer el mal dejará huellas.

Hasta aquí también entendí que el problema que #baby intenta resolver quizá no es tan simple. Muchos proyectos, al hablar de seguridad, suelen enfatizar cuánta financiación participa. Pero lo que realmente determina si un sistema de seguridad puede funcionar a largo plazo es si, cuando los participantes cometen errores, el sistema tiene alguna forma de encontrar a ese responsable.

Volviendo a EOTS, me parece interesante no porque cree un método de firma nuevo, sino porque completa un eslabón que es muy fácil de pasar por alto en el sistema de seguridad compartida. A medida que entren más participantes externos en el marco de la seguridad de la red, cómo demostrar quién cumple las reglas y quién intenta romperlas podría convertirse en un problema clave en la competencia por la infraestructura.

Por supuesto, si este mecanismo puede verificarse y validarse con el tiempo, todavía requiere que pase un tiempo.

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

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

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

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

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

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

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

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

Hace un tiempo, cuando vi los datos del cambio ecológico publicados por @BabylonLabs_io , estuve reflexionando sobre por qué, hoy en día, en muchas cadenas nuevas, lo realmente difícil no es el desarrollo, sino cómo establecer rápidamente una base de seguridad confiable después del lanzamiento.

Desde que Babylon entró en funcionamiento, cada vez más redes PoS han empezado a prestar atención al modelo de seguridad compartida. A la fecha, el ecosistema de Babylon ya ha conectado decenas de redes blockchain, y la participación en BTC Staking ha seguido creciendo. Cada vez más activos están entrando en este mercado de seguridad.

Este cambio me pareció interesante.

Porque en el pasado muchos proyectos se enfocaban en cómo atraer usuarios y aumentar el TVL, pero Babylon aborda el problema de cómo unirse a una red nueva puede reducir el costo de construir un sistema de seguridad.

Cuando empecé a investigar Babylon, también lo interpreté como un protocolo de staking. Sin embargo, después de profundizar en su mecanismo, descubrí que lo que realmente quiere resolver no es simplemente agregar otra forma de generar rendimiento, sino cambiar la ruta para que una red nueva establezca seguridad.

Las redes PoS tradicionales necesitan formar sus propios validadores, diseñar sus propios incentivos económicos y, poco a poco, acumular seguridad.

En cambio, lo que ofrece Babylon es otra solución: mediante el mecanismo de seguridad compartida, las redes nuevas pueden acceder a la capacidad de seguridad provista por Babylon, sin tener que construir desde cero un sistema de seguridad completo.

Lo que más me llama la atención es la capa de Finality Provider. Cuando mucha gente habla de Babylon, suele poner el foco en el staking en sí. Pero lo que realmente permite que la capacidad de seguridad se transfiera a redes distintas son esos roles encargados de la confirmación y verificación final. Ellos conectan la relación entre los activos, los recursos de seguridad y las redes de aplicaciones.

Esa es también, para mí, la parte interesante de Babylon.

No crea únicamente un nuevo escenario de aplicación, sino que redefinen qué se necesita cuando una red arranca.

Babylon explora la idea de que la seguridad en sí misma también puede convertirse en una infraestructura. Por supuesto, si el modelo de seguridad compartida logrará formar un ecosistema a largo plazo o no, aún quedan muchas preguntas por observar: por ejemplo, el diseño de incentivos de las diferentes redes, el tamaño de los participantes y la sostenibilidad a largo plazo.

En el futuro, la competencia entre blockchains quizá no solo sea por quién tiene más usuarios y liquidez, sino también por quién puede establecer una base confiable de manera más eficiente. Ese podría ser, precisamente, el rumbo que Babylon quiere explorar.
#baby $BABY

Mucha gente piensa que lo más difícil de replicar del BTC es su escasez, pero después de investigar @BabylonLabs_io , descubrí que lo realmente difícil de reemplazar es el consenso de seguridad que se forma durante más de una década de funcionamiento.

Esa es también la razón por la que recientemente me enfoqué en $BABY .

Para ser sincero, al principio, cuando vi la dirección de BTC Staking, no me emocioné especialmente. En los últimos años, el mercado ha presentado muchos planes para que el BTC genere rendimientos, pero en esencia muchos solo envuelven el BTC como un nuevo producto financiero, haciendo que los usuarios asuman riesgos adicionales, sin liberar realmente el valor del Bitcoin en sí.

Lo que me hizo cambiar de perspectiva Babylon es que no se centra en cómo consumir la liquidez del BTC, sino en cómo aprovechar las capacidades de seguridad que Bitcoin ya ha construido.

La idea central de #baby es, mediante Trustless Bitcoin Vaults y el mecanismo de BTC Staking, permitir que los tenedores de BTC mantengan el control de sus activos y, al mismo tiempo, aporten soporte de seguridad a redes PoS.

En términos simples, Babylon no le pide a los usuarios que transfieran su BTC a otras cadenas ecológicas, ni que dependan de instituciones centralizadas para la custodia; en cambio, quiere utilizar los atributos nativos de seguridad de Bitcoin para convertirlo en una base segura que conecte otras redes de blockchain.

Este enfoque me parece interesante porque resuelve un problema que ha persistido durante mucho tiempo en el ecosistema PoS. Muchas blockchains emergentes no es que no tengan tecnología ni que no tengan desarrolladores, sino que en la etapa temprana es difícil establecer rápidamente un sistema de seguridad lo suficientemente sólido. El número de validadores, el tamaño del staking y el costo económico influyen en la capacidad de una red para resistir ataques.

Y Bitcoin ya ha demostrado su seguridad durante más de una década. Si en el futuro esa capacidad de seguridad se puede aprovechar para más redes PoS, el papel del BTC podría cambiar.

Por supuesto, no voy a asumir simplemente que $BABY vaya a tener éxito. En la historia de Crypto, nunca faltan narrativas grandiosas; al final, lo que determina el valor de un proyecto de infraestructura es si la tecnología es confiable, si el modelo de seguridad está validado y si el ecosistema realmente lo adopta.

Antes, cuando entendíamos el BTC, nos enfocábamos más en su escasez y en su precio. Pero si en el futuro la capacidad de seguridad de Bitcoin puede servir a más redes, los límites del valor del BTC podrían redefinirse.

Quizás en el futuro, no nos interesará el BTC solo porque sea lo bastante escaso…

¿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。