冷毅

社区里最容易把 @Dusk 说过头的一句话，不是“它重视隐私”，而是把“可以构建”直接说成“已经上线”。我重新看官方 Overview 和 Market Infrastructure 页面时，注意到用例段落前特意写的是“Some example use cases Dusk was designed for”，后面又补充：不同应用可以用不同方式实现，Dusk提供的是协议积木和执行路径。这个限定其实是在给社区传播划边界。
当有人把“代币化证券、机构 DeFi、隐私支付”当成现成产品来转发，普通用户会把架构能力、应用部署和真实采用混成一件事。发行人可能还在设计资格规则，开发者可能只完成了合约，用户却已经按“可用市场”去理解 $DUSK 。信息差一旦进入交易讨论，错误预期就不再只是文案问题。
最麻烦的场景是：项目介绍被截成一句“Dusk支持某某金融场景”，随后有人追问具体入口、可交易资产和责任方，社区只能继续用宣传去补洞。久而久之，真正的产品进度和未验证的想象会被混在一起。
所以我判断 @Dusk 的社区教育质量，不看谁把用例写得最宏大，而看谁能区分“协议能提供什么”“哪个应用已经实现”“哪些采用仍待证据”。下一次看到 #dusk 的大词，我会先找部署名称、公开流程和可核验记录；说清楚边界，比把未来提前写成现在更能保护项目。

如果一个机构的每笔持仓都公开，市场会更透明还是先把真正的买家吓走？我在想这个问题时真正关心的是做市商和发行人要守住的那条线，哪些信号足够形成价格而哪些细节一旦暴露就会泄露仓位。我查到@Dusk 的Market Infrastructure说明时注意到它把受监管市场拆成两个需求，公共协调和受保护数据，文档还把institutional DeFi的目标写得很直白，公开市场信号并保护私人持仓。对应到协议层时Moonlight提供公开账户和公开链上数据，Phoenix与零知识证明处理机密转账，这个安排让我改变了判断，隐私不只是用户偏好而是市场结构设计，报价、结算状态以及资产规则需要被看见，而机构的仓位、对手方以及资金路径则不应自动广播。

压力在流动性变薄时出现，假设一家机构刚完成大额配置且地址和金额都可追踪，套利者可能提前改价导致后来的买方选择观望，但如果应用连价格、可成交性以及结算状态都藏起来，做市商又无法判断风险时市场看似安静却可能失去交易能力。所以我评价@Dusk 时不会只问它能不能隐藏一笔转账，这不等于流动性已经解决，我会看$DUSK 金融应用能否公开足够市场信号，让价格发现继续发生，同时不把机构仓位变成实时广播。Dusk的考题不是隐私做得多深，而是隐私存在时市场还能不能保持可交易。#dusk

跨链最容易被写成“多一个出口就多一份流动性”，但我重新看@Dusk 与NPEX、Chainlink的合作说明时反而停在了CCIP的控制边界，双方把它作为受监管资产的跨链互操作层，同时保留代币合约的所有权、限速以及升级控制。这个细节改变了我的判断，机构想要的并不是把证券复制到更多网络，而是在扩大可达范围时仍然知道谁能改规则、谁能暂停流动以及谁对资产状态负责。对普通代币来说跨链失败可能只是一次转账延迟，但对受监管证券来说控制权和合规边界一旦说不清，接入的链越多解释成本反而越高。

真正麻烦的场景是资产已经在DuskEVM上发行，投资者想在另一条网络使用，跨链流程却遇到异常或触发限速，发行方要决定暂停新的转移、等待状态确认还是启动修正流程，每个选择都会影响投资者的资金安排和市场连续性。如果控制权分散在多个桥接参与者手里，投资者不知道该相信哪条记录，如果发行方拥有全部开关，市场又要面对新的中心化依赖。CCIP的价值因此不只是连接网络，还在于把控制责任摆到台面上。

官方说明能证明@Dusk 和NPEX正在采用这套标准，却不能证明每一种证券都已经实现了无摩擦跨链。对$DUSK
来说后面值得看的是限速、暂停以及升级权限是否会被公开写进每个资产的规则。@Dusk想把金融市场带到更多网络，先要让市场知道跨出去以后谁仍然负责。#dusk

#dusk $DUSK @Dusk Antes creía que, una vez que un contrato se despliega en la cadena, lo único que quedaba era conectar la aplicación para llamar funciones. Pero cuando seguí la guía de inicio rápido de <DuskVM> de @Dusk, descubrí un detalle que es muy fácil pasar por alto: a partir del mismo código fuente en Rust hay que generar dos WASM. Una es el contrato que realmente se ejecuta en la cadena; la otra es un “controlador” de datos para que el lado de la aplicación codifique y decodifique. Esto no es simplemente compilar el archivo una segunda vez. La versión en la cadena es la que determina cómo cambia el estado; la versión en la parte fuera de la cadena es la que determina cómo el frontend traduce “cambiar el número a 42” a parámetros que el protocolo pueda leer, y también determina si el resultado devuelto puede reconstruirse en datos comprensibles para humanos. @Dusk Además, coloca estos dos productos en rutas diferentes y proporciona una verificación (verify) para comprobar que ambos coinciden y que el hash del contrato es el mismo. En realidad, lo que el desarrollador debe mantener es un par de interfaces que necesariamente deben estar sincronizadas.
El caso más problemático es cuando el contrato ya está desplegado y las transacciones se ejecutan, pero la aplicación envía la solicitud usando un controlador de datos antiguo. Entonces el usuario puede ver errores de codificación de parámetros, o bien que la llamada tenga éxito pero la página interprete mal el resultado. Cuando en la cadena no aparece un error evidente, el desarrollador termina teniendo que volver a rastrear el código fuente, la versión del build y los registros de despliegue. Ese tiempo que se ahorra al principio acaba convirtiéndose en un costo de localización que asumen por igual el integrador y el usuario. Por eso, al evaluar la experiencia de desarrollo de DUSK, no solo me pregunto “¿pueden ejecutar el contrato Rust?”. El diseño de doble producto de DuskVM hace más claras las fronteras entre la ejecución en cadena y la comprensión por parte de la aplicación, y también recuerda al equipo que “despliegue exitoso” no significa necesariamente “integración completada”. Más adelante revisaré si el proyecto deja juntos para poder verificarlos: la versión del controlador de datos, el hash del contrato y el flujo de publicación. Ese es el paso clave para que Dusk pase de “funciona” a “es mantenible”.

#dusk $DUSK @Dusk Anteriormete cuando hacía pagos on-chain, solía meter el número de pedido en el memo por costumbre, pero después de leer la documentación de Transaction Lifecycle de @Dusk descubrí que no se puede trasladar directamente ese hábito. Esto se debe a que los datos de transacción de Dusk tienen una relación de opción única entre memo, llamada al contrato, despliegue del contrato y blob; el memo no puede asumirse que venga junto con otros payload. Esta diferencia cambia directamente la forma de conectar el sistema de pagos. Si el comercio necesita tanto recibir el pago como ejecutar una acción mediante contrato, no puede dar por hecho que el número de pedido siga guardándose en el memo de la misma transacción. El cliente debe decidir primero cuál es la tarea principal de esa transacción y luego diseñar otro registro fiable para asociar el pedido. El escenario de presión es bastante concreto: el usuario envía un pago que incluye acciones de contrato, la interfaz muestra “enviado”, pero el backend busca la orden haciendo match según el memo; el resultado es que el importe sí entra, pero el número de pedido no aparece como se esperaba, y el personal de atención al cliente solo puede consultar la transacción manualmente. Esto tal vez no signifique que Dusk pierda datos; es más probable que el integrador haya forzado los hábitos de transacciones de otras cadenas. Por eso, al revisar la integración de pagos de DUSK, no solo pregunto si la transferencia puede tener éxito; primero confirmo si la transacción porta realmente memo o una llamada al contrato, y luego verifico si la asociación del pedido puede revisarse de forma independiente. @Dusk ya dejó claros los límites del payload, pero si el ejemplo puede permitir que los desarrolladores eviten este uso indebido con antelación es, en realidad, el aspecto que vale más la pena validar cuando Dusk entra en escenarios de pagos reales.

#termmax @TermMax 一个Vault里明明有钱订单却还不继续放量，我原来会把这个现象归咎于借款需求不足，但看到TermMax Curator文档里的“maximum supply limits for orders”后才发现订单本身还有一层人为天花板。这个上限是设在订单上的，并不是Vault的总余额，Curator可以限制某个lending order的最大供给量，所以资金即使闲置在Vault里也未必能继续进入同一个市场。看到余额还在并不能直接推断策略只是在等借款人，也可能是订单已经封顶了。这项设计有合理性，市场突然变热时Curator确实不必把全部资金压到一条报价上，但限额太低会导致资金闲置并使存款人错过成交，而限额太高又会让单一市场的集中暴露被放大。Curator在调整风险，存款人却未必知道这个旋钮被拧到了哪里。压力场景是借款需求突然涌入时订单先触顶，Vault里还有余额，用户却可能误以为市场没有需求，等上限被提高后资金又可能在最拥挤的时点集中进入，前后承担的风险并不一样。所以我看@TermMax 的Vault时不会只看总资产和收益曲线，会先查每个订单的maximum supply limit、闲置资金以及上限变更记录。TMX相关Vault的资金效率关键并不在于钱有没有进入Vault，而在于它为什么停在了那里。#TermMax

#dusk $DUSK @Dusk 我以前习惯把账户生成看成发送前的最后一步，但读到@Dusk 文档中“Signing transactions directly”部分时才发现这个判断需要修正。W3sper 提供了交易构建器，却并不是一个完整的钱包，因此刚生成的 Profile 并没有同步的 Bookkeeper，交易所需的余额和 nonce 状态都还未准备好。我在看 W3sper 的直接签名示例时第一反应是，Profile 都生成了，为什么还不能把 $DUSK 交易发出去，后来才注意到文档中这个容易被忽略的边界。

对开发者而言，这意味着“能创建账户”和“已经可以发送交易”之间还有一段需要自己完成的工作，包括可恢复的密钥存储、Treasury 状态同步以及 Bookkeeper 的维护。如果少了其中任何一层，代码未必会给出容易理解的错误提示。设想一个团队启动自动付款服务后立刻用新 Profile 转账，测试时可能只看到余额读取失败或 nonce 不存在的提示，但上线后排查问题的人却可能先去怀疑节点和网络是否出了故障，而等待付款的用户承担的则是时间上的延误。

所以我现在评价 W3sper 时不会只问它能不能拼凑出一笔交易，而是会先看示例是否把账户生成、状态同步和可发送交易这几个阶段分开讲清楚。W3sper 并不是把钱包能力藏起来，只是把一部分状态管理责任交给了接入方。对于 @Dusk 的开发者生态来说，真正需要验证的问题是，一个新的团队在第一次尝试发送交易之前，能否主动发现自己的 Bookkeeper 还没有准备就绪。#dusk

#termmax @TermMax 里最容易被低估的，不是利率怎么写，而是到期日把资金锁在了哪一段时间里。
我看固定利率市场的定义时，注意到一个很朴素的字段：债务代币、抵押品之外，还必须有明确的 Maturity Date。FT 到期可以按面值兑换债务代币，这让出借人的回报有了计算终点；可在那一天到来之前，手里的 FT 仍然是一项带剩余期限的市场资产。所谓“固定”，并没有把中途退出变成固定价格。
这会改变出借人的判断。假设市场利率突然上升，新的资金愿意用更高回报出借，旧 FT 的面值没有变，剩余期限却让它在市场上的吸引力下降。持有人如果坚持等到期，拿到的是事先约定的面值；如果临时需要现金，只能接受市场对剩余时间的重新定价。这里真正被定价的，不只是债务代币，还有等待本身。
借款人也会受到影响。临近到期的 FT 可能更接近面值，远期 FT 则需要更大的折价来补偿等待和利率变化。市场看起来都叫固定利率，实际给不同期限的资金安排，完全可能是两种流动性体验。出借人承担的是时间成本，借款人承担的是期限选择带来的融资差异。
所以我看 @TermMax 的到期设计，不会只把 Maturity Date 当成结算日。它更像一条把收益确定性和资金流动性分开的线。$TMX 相关市场后面值得核对的，是不同剩余期限下 FT 的真实成交价和成交深度；只有这两项都能被看清，固定利率才不是一张只在到期日兑现的漂亮承诺。#TermMax

“¿La transacción ya se completó y la página aún no cambió?” — Esta frase, si se la dices al panel de un monedero o a la parte trasera de un exchange, normalmente no es culpa del usuario; es que el sistema se perdió algún evento.

La HTTP API de @Dusk pone la suscripción a eventos de contratos en esta ruta: /on/contracts:<contract_id>/<method>. La suscripción y la cancelación de suscripción se hacen con GET y DELETE, respectivamente, y además hay que contar con el encabezado Rusk-Session-Id para mantener la sesión. A simple vista parece un detalle de la interfaz, pero en realidad está recordando una cosa: que las notificaciones en tiempo real no son el libro contable.

Cuando la conexión funciona bien, el monedero actualiza el saldo con los eventos, y el exchange los usa para avanzar la consolidación o el estado de los pedidos. Pero si la conexión se corta, la session solo puede ayudarte a recuperar la relación de suscripción; no puede demostrar que en medio no se haya perdido nada. Lo que se haya omitido, hay que volver a reconstruirlo desde el estado del bloque, la transacción y el contrato.

Me imagino un caso concreto. La transferencia de DUSK del usuario ya se registró en la cadena, pero la conexión de escucha del exchange se desconectó justo unos minutos. El registro en la cadena está bien, pero el saldo no se actualiza. Entonces el usuario envía la operación otra vez y el backend podría terminar mostrando simultáneamente dos registros pendientes. El soporte ve “no llegó el pago”; el equipo de operaciones se enfrenta a compensar con eventos y a hacer conciliación manual.

Esto me hace exigir una capa extra al endpoint de eventos de @Dusk . Que la documentación describa el punto de entrada de la suscripción es solo el primer paso; lo que realmente determina la calidad de la integración es si el monedero y el exchange, tras reconectar, pueden recuperar el contexto según la session y luego cubrir las brechas usando el estado on-chain. $DUSK debe reflejar la transferencia real de activos; los eventos en tiempo real sirven para avisar, pero el estado final tiene que tener otra vía que permita verificarlo de nuevo. #dusk

#termmax @TermMax He visto que en el Vault aparecen tanto “Curator Fee” como “Protocol Fee”. Primero, una pregunta: ¿estos dos importes se descuentan de mi capital o se separan antes de que yo reciba las ganancias? La diferencia suena sutil, pero si se refleja en la página de depósitos, influye directamente en si me atrevo o no a poner mis activos ahí.
Los depositantes de TermMax explican que el alcance está escrito de forma bastante estrecha: estas dos comisiones solo aplican a los rendimientos pasivos generados por activos ociosos, no se deducen del capital depositado, y la comisión ya está reflejada en el share price. Por lo tanto, no es necesario que el usuario reclame o pague algo por separado. Es decir, el precio de las participaciones que aparece en la página ya es el resultado después de deducir las comisiones. El usuario no tiene que confirmar una segunda vez, pero tampoco puede mezclar el “beneficio bruto” con el cálculo de las participaciones que realmente aumentaron.
Creo que la ventaja de este diseño es que las comisiones no están ocultas en un cobro repentino al momento de retirar. El problema también está aquí: si la mayoría de los activos del Vault gran parte del tiempo no se utilizan en la estrategia, el rendimiento parecerá ir aumentando gradualmente, mientras que el Curator y el protocolo seguirán cobrando esas comisiones con cargo a esa parte de rendimiento pasivo. Si el desempeño de la estrategia se debilita, el precio de la participación podría estancarse o incluso caer, y el usuario se daría cuenta de que “cobrar solo sobre las ganancias” no equivale necesariamente a que “el capital no tenga oportunidad de reducirse”.
Así que, al ver las reglas de comisiones de @TermMax , no lo trataré como un ingreso barato solo porque “solo se cobra la fee por rendimiento”. Explica con claridad a quién se le cobra, pero no cubre con ningún respaldo el resultado de la estrategia. Lo que los Vault relacionados con termmax deberían publicar más adelante, con total claridad, es cómo cambian el rendimiento bruto, las dos comisiones y el share price final, para que los depositantes puedan calcular por sí mismos adónde fue realmente esa parte del dinero.#TermMax

我差点把 @TermMax 的借款 APR 当成最终成本。打开官方费用说明时，结果让我停下来的，是公式里那一段“days to maturity / 365”：借款金额和报价一样，期限不同，交易费也跟着变。

市场页面通常把 APR 放在最显眼的地方，期限却藏在另一个角落。一个人比两个市场，看到相同利率就以为花费差不多；实际被算进去的，还有这笔钱要占用多久。期限越长，时间项越绕不开。资金紧张的时候，差的不只是小数点，是还款计划本身。

我脑补个普通操作。用户急着借一笔钱，看到两个报价差不多，顺手选了期限更长那个。交易确认后才发现，费率没变，最后扣的费用却不一样。算错倒没有，他只是比较时只看了年化数字，没把到期日一起放进账本里。钱都借出来了，比较的机会没法重来。

我现在点开 @TermMax 的报价单，先翻总费用和到期日，APR 排在最后看。TMX 要是想让用户少做这种“看起来会算、实际漏算”的比较，最有用的提示不是把利率再放大，是在确认前把借款金额、期限和最终交易费摆在同一行。#TermMax

¿Después de que falla la transacción, el DUSK que falta en la cartera cuenta como que no valió la pena?👻？

Revisé la página de Tokenomics de Dusk y vi una regla que es fácil pasar por alto: si la transacción agota el gas, se revierte, pero el gas que ya se consumió no se devuelve. En la cadena, lo que la gente llama “fallar” puede tener al menos dos resultados.

El gas limit es el máximo de trabajo que esta llamada puede realizar; el gas price es el precio por unidad de trabajo. Los costos se calculan según el consumo real; lo que no se usa no se cobra. La regla en sí no tiene nada de malo. El problema es que la cartera normalmente solo te muestra un “Failed” con letras blancas sobre un fondo rojo.

Antes seguro que culpaba a los usuarios por no dejar suficiente tarifa. Ahora, mirando hacia atrás, me pregunto si el producto dejó claro el motivo del fallo, porque eso es lo que decide directamente si el usuario está dispuesto a intentarlo otra vez. No es lo mismo si faltó potencia de cálculo (workload), que si hay un problema de permisos, parámetros o el estado de la red; el manejo es completamente distinto.

Pongamos un escenario. Alguien utiliza una cantidad pequeña de DUSK para llamar a un contrato y configura el gas limit demasiado bajo. La transacción falla, la cartera pierde saldo, pero el estado en la cadena no cambia. Lo intenta de nuevo y paga otra vez. Si la raíz fue que los parámetros estaban mal escritos, la tarifa seguirá consumiéndose.

Así que de verdad no creo que el mecanismo de gas de Dusk se pueda resumir simplemente como: “aunque falle, igual se cobra”. El protocolo ya delimitó claramente el margen: se devuelve lo no utilizado y se cobra la parte que se agotó. El producto tiene que traducir ese límite a “lenguaje humano”.@Dusk Si pudiera mostrarse en el registro de fallos junto con el gas limit, el consumo real y el motivo del fallo,$DUSK se reduciría una capa de malentendidos en el umbral de uso.#dusk

@TermMax Ese range order: hay un interruptor poco llamativo. Cuanto más lo miro, más siento que hay que estar alerta.
Al principio creí que la curva era el precio público de la cadena: que todo el mundo puede ver y que cualquiera puede pedir prestado. Pero al leer la documentación encontré una frase: el que crea la orden puede usar el toggle para pausar, y luego volver a activarlo cuando el mercado esté adecuado. Me quedé helado: esa curva no es una promesa de préstamo válida en cualquier momento.

El diseño en sí no está mal. ¿Quién pediría dinero sin que le permitieran sentir miedo al riesgo? Si el mercado no está bien, es normal que te eches para atrás.
Pero el problema se queda justo aquí: la tasa y el monto disponible que ve el prestatario pueden coincidir—solo en ese instante en que tú miras—con la liquidez que de verdad puede cerrar la operación. Como quien crea la orden tiene margen para gestionarlo de forma activa, el prestatario tiene que asumir la posibilidad de que su plan de financiación se interrumpa temporalmente.

Déjame imaginar la escena. Alguien mira la curva de la página, calcula los colaterales, completa el saldo, espera a que se confirme la transacción… y cuando vuelve a pedir prestado, la orden está en pausa.
No hay liquidación, no hay fallos de contrato, ni siquiera alguien actúa con mala intención. Es simplemente que tú crees que ves una cotización, cuando en realidad es la disposición de la otra parte a retirarlo en cualquier momento.

Así que ahora, cuando abro un range order, no me quedo primero con lo bonita que queda la curva. Primero busco esto: ¿cuánta capacidad hay ahora? ¿cuándo se actualizó? ¿está encendido el interruptor de pausa?
En serio, $TMX tiene que hacer que el prestatario pueda confiar en esas cuatro palabras: “ahora se puede pedir prestado”. Si el usuario todavía interpreta la curva histórica como fondos que le esperan, la transparencia todavía le falta un respiro.

#TermMax

Anoche, en el despacho, abrí el ordenador por primera vez y vi que en el ejemplo de Dusk Connect aparecía availableProviders[0]. Me llevé una sorpresa y me quedé con la mano a medias. Cuando se detectan varias carteras compatibles a la vez, y no existe providerId, el código puede escoger la primera; pero, para sugerir a la parte del producto, sigue siendo mejor que el usuario elija la cartera por sí mismo.
Yo antes veía el descubrimiento de providers como una comodidad técnica para ahorrar trabajo de adaptación. Ahora pienso que también está asignando un poder muy concreto: si un dApp decide con qué cartera empieza el usuario, o si la elección se deja para antes de firmar. Para el equipo de carteras, el descubrimiento abierto evita que alguna extensión quede codificada de forma rígida como punto de entrada; para los usuarios, lo importante es si pueden ver por cuenta propia la cartera, la red y la cuenta que están seleccionadas en ese momento.
El mal escenario no es exagerado. En el navegador hay dos carteras compatibles: una para activos de la red principal y otra para pruebas o para cuentas del equipo. Alguna aplicación, con el objetivo de ahorrarse un paso, selecciona automáticamente la primera; el usuario va haciendo clic hasta llegar a la página de firma y entonces descubre que la cuenta no es la correcta. Que la transacción se rechace todavía es suerte; lo peor es cuando el usuario completa una autorización que no debía en un entorno equivocado, y después solo recuerda: “Dusk Wallet se conectó al lugar equivocado”. El costo lo asumen el usuario y el soporte técnico, mientras que quien tomó la decisión de selección automática muchas veces ni siquiera está presente.
Por eso, ahora no considero el descubrimiento de múltiples carteras de Dusk Connect como una capacidad de interfaz meramente técnica.@Dusk lo que realmente hay que proteger es que, una vez hecho el descubrimiento, el derecho a elegir siga en manos del usuario.$DUSK cuantas más aplicaciones haya, más quiero ver que en la pantalla de conexión se muestren de forma clara el provider, la red y la cuenta, y que, cuando exista selección automática, se ofrezca una oportunidad de cambio visible.#dusk

同样叫 DUSK，小数点可能已经对不上了🤔🤔
我以前会直接把 decimals 当成开发者才需要操心的字段。

直到重新读 @Dusk 的 Tokenomics 页面，我才发现，同样叫 DUSK，换到不同链上，小数点可能已经不是同一个小数点了。

主网 DUSK 是 9 位，ERC20 和 BEP20 DUSK 却是 18 位。

主网用 LUX 记账，1 DUSK 等于 1,000,000,000 LUX；以太坊和 BSC 上的版本沿用 18 位标准。这个差别看起来只占文档里一行，却直接影响迁移、充值、提现和余额展示。用户只认得同一个 $DUSK 标签，钱包和交易系统却必须先认清它属于哪条链、哪种标准。

坏场景是，某个接入方把跨链资产当成同一套整数处理，页面余额看起来正常，实际发送或兑换时却出现数量偏差。用户可能以为资金少了，运营人员则要回头核对原始单位、链和合约。文档把 ERC20/BEP20 持有者引向主网迁移指南，已经说明这不是可以靠界面四舍五入掩盖的小事。

它不能证明每个接入方都会出错，却提醒 $DUSK 生态必须把链、标准和 decimals 放在用户确认前。@Dusk 若能让这些字段始终跟着资产一起显示，#dusk 的跨链体验才不会把单位差异留给用户猜。💰💰

你以为手续费都归矿工？Dusk 这套奖励机制，可能让你算的账全白算
我以前看到“手续费进入区块奖励”这种话，基本是直接划过去的。反正就是给矿工嘛，关我什么事？

直到我认真读完 @Dusk 的 Tokenomics 页面，发现自己想得太简单了。

一笔交易付出的 #dusk 不只会落入打包那个人的口袋。

文档里写得清楚：每个区块的奖励 = 新发放的 DUSK + 交易费。区块生成者先拿 70%，然后最多再拿 10%——但这个 10% 不是白给，得看证书里的 credits 有没有达标。没达标？那部分直接销毁，谁都拿不到。

所以，手续费从来不是“自动到账的固定工资”，它更像一套带条件的绩效奖金。

对节点运营者来说，这不是躺赚的买卖
你以为是参加共识就够了？太天真。证书里的 credits 满不满足条件，直接决定你能多拿几个点还是吃零蛋。

对用户来说，你付的 gas 没有直接流向某个单一角色，而是被切碎、分配、甚至销毁——谁拿多少，取决于整个生成、验证、长期建设的博弈。

最尴尬的场景是什么？🥶
节点运营者按“最高能拿满 10%”来做预算，机器租好了，电费付了 结果实际证书没达标。

网络还在正常跑 用户的交易也完成了，但你的收入预期落空了 那额外 10% 被系统一把火烧掉。你说这算谁的？

记住百分比 和真正读懂激励 从来是两码事。

说句实在话
$DUSK 的区块奖励设计，不能证明网络一定繁荣，但至少说明了一点：他们没有把激励包装成固定收益给你看。

这不是坏消息，坏消息是你现在去问十个节点运营者“credits 怎么算、销毁了多少” 可能九个答不上来。

@Dusk 后续如果能做一件事，我会高看一眼：把区块奖励 credits 达成情况和销毁数据 做到任何人随时能查。

参与者只有知道自己到底在为什么提供服务，才愿意继续提供服务。
否则 算得越细，失望越大。🤔

El momento en que los activos regulados más perjudican al usuario 😅: no es que se rechace la operación, sino que después del rechazo nadie aclara con claridad dónde está el error.
Vi en la página de Assets & Regulations de @Dusk que la verificación de transferencias aparece como un requisito independiente: si falla, debe indicarse una razón explícita, y además es mejor simular o comprobar antes de enviarlo.
Este detalle convierte el “acceso” de un pase de entrada único en una regla que sigue aplicándose a cada transferencia. Los criterios que figuran en la documentación no son abstractos: quién puede tener el activo, quién puede recibirlo y qué transferencias deben fallar cambian según la categoría del activo, el lugar o la jurisdicción. Para el emisor, las reglas reducen el riesgo de desajuste; para el inversor, lo realmente importante es saber antes de confirmar si lo van a frenar y, de forma concreta, por qué se le limita.
Las situaciones de presión suelen ocurrir cuando el usuario cree que ya completó todo el proceso: la cuenta pasa las comprobaciones previas de elegibilidad, pero al transferir a otra dirección recibe un mensaje de fallo ambiguo. El activo quizá no se pierda y la cadena quizá no presente anomalías, pero el usuario primero atribuirá el problema a la plataforma, y el soporte tendrá que explicar manualmente una restricción que debería haberse mostrado con antelación. La ventaja de <$DUSK > no es lograr que todas las transferencias salgan adelante, sino que los rechazos necesarios puedan predecirse y explicarse antes de firmar. <@Dusk > Lo que de verdad debería verificarse después es si la aplicación puede poner, antes de firmar, las reglas, los resultados de la simulación y las razones del fallo, en lugar de dejarlas para después de enviar la transacción. <#dusk >

Antes pensaba que “la pausa automática por saldo insuficiente” era una mala experiencia, pero después de leer el informe de reconstrucción del incidente de puente con el código de enlace @Dusk entendí que, si se pausa antes, tal vez sea más bien una forma de hacerse responsable de los activos.
El informe está escrito de manera muy directa: el nuevo puente deja el saldo mínimo operativo únicamente en el extremo del firmante; si baja del umbral, se detiene, y solo se reanuda después de que la billetera fría se reponga manualmente. El puente anterior ponía la firma, el manejo de eventos y la conexión de red en la misma ruta; tras un acceso no autorizado a la billetera de firma, el atacante no necesitaba tocar el consenso de Dusk para poder usar el dinero dentro del puente.
Este umbral no es un simple interruptor de límites. Si el servicio entre cadenas se encarga de transportar los activos del usuario, no puede poner “que el servicio no se detenga” por delante de “poner más dinero en caliente”. La parte operativa obtiene una ventana de pérdidas menor; para los usuarios que esperan la migración, el costo que pagan es un tiempo real.
Cuando hay volatilidad de mercado, muchos usuarios migran al mismo tiempo. Si el puente se pausa por tener un saldo bajo, la transacción del usuario quizá no falle, pero podría quedar atascada en una cola mientras espera el reabastecimiento. Si la página solo muestra “en mantenimiento”, el usuario no puede distinguir si el dinero no llegó, si la solicitud no se procesó, o si el sistema activó de forma proactiva un control de riesgos.
Estoy de acuerdo con que $DUSK haya cedido parte de la disponibilidad a la separación y la contención, pero eso no significa que el riesgo del puente ya haya desaparecido. Para comprobar si esta reconstrución funcionó, hay que ver si @Dusk puede seguir publicando el número de pausas, cuánto tiempo tarda en reanudar y cómo se terminan limpiando las solicitudes acumuladas.#dusk

买了“苹果代币”，你买到的到底是什么？
我本来以为，股票代币最大的误会是价格会不会跟现货脱锚。读完 Ondo Stocks 的法律说明后，更大的误会其实是：看到 $TSLAon 、$AAPLon ，很多人会以为自己成了特斯拉或苹果的股东。
事实没有那么简单。按发行方披露，这类代币是一家BVI特殊目的公司发行的结构性票据。对应的股票由发行方通过受监管托管券商持有；代币持有人拿到的是一项与底层资产价格、分红和公司行动挂钩的经济请求权，而不是股票登记簿上的那一格名字。
这两者的差别，平时看不出来。行情涨跌时，代币确实会给你类似持有股票的经济敞口，分红也会被计入回报。但遇到投票、信息披露或公司决议，权利不会跟着代币进钱包。发行方写得很直白：持有人可以按当时底层资产价值赎回现金或稳定币，却没有股东投票权、信息权或其他股东权利。
我觉得这恰恰是股票代币化最该讲清楚的地方。链上把买卖、转账和结算做得更轻，没把“谁是股东”这个法律问题抹掉。它只是把原本由券商账户承载的一部分经济结果，重新包装成了一份可转移的票据。
所以以后看到“链上美股”这四个字，我不会先看上了多少新标的。我会先问三件事：谁欠我这笔钱，底层资产由谁托管，碰到分红、拆股或并购时，合同到底怎样把结果交到我手里。把这几件事弄明白，才知道自己买的是股票、价格敞口，还是另一种金融产品。

Hermanos🌝 Después de estudiarlo en serio, descubrí que apostar y canjear BTC es bastante engorroso. El tiempo de salida es extremadamente largo😠: canjear BTC requiere esperar una ventana de desafío de aproximadamente 3 días; no es algo que puedas resolver en “salida por ruta” en decenas de minutos.
Además, al momento de pagar hay que pagar de más: como los intereses se acumulan de forma continua, el monto de la deuda que ves cambia cuando la transacción se empaqueta; debes devolver un poco más o, si no, la transacción falla, y te obliga a intentar repetidamente😓.
Vi en la red de pruebas que el envío de vaultBTC revierte directamente; mi primera reacción fue que el monedero o el contrato tenía un problema. Luego entendí que el fallo en sí es parte de la regla: vaultBTC solo funciona dentro del proceso de depósito en una posición de Aave, y no es un “recibo” de BTC que puedas llevarte.
El valor de un ERC-20 común suele venir de que, al cambiarlo de dirección, aún puedes seguir usándolo. vaultBTC es justo lo contrario: está restringido al flujo del contrato con permisos, no puedes transferirlo a otra billetera ni llevarlo a otros protocolos DeFi para seguir apostándolo. Lo que el usuario bloquea en la red de Bitcoin es BTC nativo; del lado de Ethereum, lo que se recibe es un registro que reconoce la relación de préstamo actual.
Esta limitación le da al equipo una especie de certeza: el registro de depósito no se puede desarmar y sacar del control del usuario, y la posición tampoco puede perder de repente una parte de un activo rastreable. El costo que asume el prestatario es, en cambio, muy directo. Supongamos que de pronto aparece una oportunidad de préstamo más conveniente en el mercado: el usuario no puede mover vaultBTC como un activo normal; solo puede primero gestionar la posición original en Aave y luego salir siguiendo la ruta establecida.
Por eso no voy a entender vaultBTC como un token de staking con liquidez; se parece más a un comprobante de depósito que solo funciona dentro del sistema de préstamos específico. Este diseño protege los límites de la posición, pero a la vez comprime la libertad de gestión de capital. @BabylonLabs_io En adelante, si se conectan más aplicaciones, lo más importante que deberían hacer público es el rango de uso de cada aplicación, los límites de las transferencias y las formas de salida. $BABY En la narrativa de BTCfi, al final, la historia tiene que enfrentarse a ese costo de liquidez. #baby