撸毛研究院

#dusk $DUSK @Dusk fiquei olhando os documentos do Dusk por quase quarenta minutos. Fiquei repetindo na cabeça uma pergunta: como, afinal, ficam as coisas entre Moonlight e Phoenix?

A Moonlight segue a rota de conta pública. Saldo, remetente, destinatário e valores ficam todos registrados na blockchain; qualquer pessoa pode ver. Isso é perfeito para cenários em que transparência é obrigatória, como recarga de exchanges e conciliação contábil institucional.

A Phoenix é outra lógica completamente diferente: os ativos viram um note criptografado, escondido dentro de uma árvore de Merkle. Quando você gasta um valor, não fica exposto exatamente qual note foi usado; você apenas envia um nullifier e uma prova ZKP. A rede consegue verificar que você tem saldo e que não houve double-spend, mas não dá para ver o valor nem o remetente. Quando for preciso auditar, dá para divulgar seletivamente usando uma chave de visualização.

No começo do mês, quando escrevi uma nota sobre transferências SEPA, me deparei com um problema parecido: conciliação entre dois sistemas bancários em que os status não batem é uma dor de cabeça enorme. Acabei sendo arrastado até duas da manhã.

Se uma blockchain também montasse dois livros-razão isolados, seria melhor que fosse como o sistema financeiro tradicional.

Naquela hora, eu estava meio irritado, sentindo que o documento não explicava esse ponto com clareza. Eu abri a seção de arquitetura de contratos do módulo Rusk. As duas primeiras partes não me disseram muito—basicamente só descreviam as estruturas de dados do Moonlight e da Phoenix. Foi só na quarta parte que eu entendi a intenção do design: ao ver que, na definição da interface do Transfer Contract, eles usaram um tipo enumerado para o payload.

O Transfer Contract é uma porta de entrada de coordenação. Ele recebe payloads em formatos diferentes—um no formato Moonlight, outro no formato Phoenix. O contrato não se importa de onde veio; ele só se importa com quais campos o payload traz e então faz o roteamento para a lógica de validação correspondente. A validação do Moonlight lê diretamente o estado da conta pública. A validação da Phoenix roda a proof de ZK. Depois que as duas validações passam, o resultado é gravado em uma mesma árvore global de estado.

Eu fiquei um tempo pensando para entender o ponto-chave dessa etapa: se você funde as árvores de estado dos dois sistemas em uma única árvore, então converter uma transação do livro público para uma privacy note nada mais é do que uma conversão de payload—não precisa de ponte entre cadeias, nem de protocolos complexos de sincronização. A atualização de estado é atômica: ou tudo funciona, ou tudo volta ao estado anterior.

#dusk $DUSK @Dusk 2026年1月7号，Dusk主网上线。六年磨一个专门给受监管金融做隐私的Layer 1，PLONK零知识证明背书。我当时刷到推送，扫了眼就划过去了。

真正让我坐不住是四月底。那天在Dusk的Discord里瞎逛，有人甩了条OtterSec的报告链接。点开一看，我靠，后背发凉。

报告说dusk-plonk的验证器有个大坑——验证者在最终验证方程里直接用了证明者给的四个选择子多项式求值，但从来没对这些求值做过KZG打开验证。啥概念？证明者可以把这四个值设成任何能让方程通过的数，验证器照单全收。攻击者能凭空伪造零知识证明，绕过交易电路里所有约束，直接铸造DUSK。当时整个Dusk隐私层保护着大概6000万美金。

我半信半疑，自己去翻PLONK的论文，又去GitHub上扒Dusk的源码。这玩意儿说白了是这样：PLONK把电路拆成一个个门，每个门有左输入、右输入和输出。每个门施加一条约束，PLONK用选择子值（比如设q_M=1表示乘法门，设q_L=1表示加法项）把所有门类型统一成一个表达式。验证方程必须确认这些选择子跟验证者密钥里的可信承诺对得上。结果dusk-plonk压根没做这个检查。等于说门卫从来不看你证件，你说你是谁就是谁。

以前我总觉得，零知识证明这种学术界反复捶打过的东西，数学上没问题，工程上自然就安全。这下我才回过味来，全隐私链就是个黑盒，逻辑漏洞从外面根本摸不着。数学证明只解决“能不能证明”，“证明有没有被正确验证”那是另一码事，中间那条缝宽得能跑马。

我又去翻Porter Adams之前那份审计报告，里面只标了两个低危问题——这种“少写一行检查”的漏洞压根没覆盖到。

Dusk反应倒不算慢，2月14号就提交了修复。NPEX上数亿欧元真实资产在跑，大方向我没意见。但往后谁再跟我提隐私链，我第一句肯定问：你们的验证代码，到底验证了没有

#dusk $DUSK @Dusk Nos dois dias anteriores, tentei rodar um nó nos nodes do Dusk. Depois de instalar o node-installer, quando fui digitar o comando de inicialização, fiquei com a mão pairando sobre a tecla Enter, hesitei por um instante. Não era medo de fazer algo errado—era medo de que acontecesse como nas vezes anteriores: o log rolava algumas linhas e travava, e aí percebia que documentação e código não batiam.

Depois que iniciou, o rusk começou a despejar logs. As fases de Validation e Ratification se alternam. A fase de Validation vem primeiro: um conjunto de membros do comitê verifica a validade dos blocos candidatos. Em seguida, a fase de Ratification: outro conjunto confirma os resultados da validação e, por fim, define e fixa o bloco. Em cada rodada, o log marca a numeração de Round e Iteration, e o intervalo entre a produção de blocos é constante. Fiquei encarando a tela por mais de dez minutos; a altura do bloco foi subindo sem parar. As sombras das execuções anteriores—tipo “travar no meio do caminho”—até então só tinham acontecido em outras redes de teste; aqui, finalmente, se dissiparam.

Depois fui vasculhar o repositório do rusk. Eram 8025 commits: o pipeline de CI roda clippy e testes com nightly. Além disso, o time ainda criou por conta própria o cargo-dusk-analyzer para fazer análise estática. No ferramenta de deploy, o dsk-deploy-cli, notei um detalhe: os parâmetros de linha de comando para Phoenix e Moonlight são separados; na mesma blockchain, dois caminhos de transação chamam de forma independente cada um. Encontrei num issue os dados de gas que alguém tinha colado: transferir com Moonlight gasta cerca de 80 mil gas; porém, de Moonlight para Phoenix custa 25,56 milhões de gas—um diferencial de 300x. É esse o custo real de computação dos proofs em ZK.

Aí fui olhar de novo a camada de rede. O Kadcast é uma implementação oficial em Rust, e os 107 repositórios são todos em Rust. O repositório plonk tem 872 commits—também escritos pelo próprio time; não é aquela coisa de pegar uma lib pronta e só modificar um pouco e já colocar no ar.

Depois fui investigar os bastidores do NPEX. Uma exchange holandesa regulada pela AFM, com licenças de MTF, Broker e ECSP, administrando ativos de 300 milhões de euros. A lista de candidatos do Dusk Trade já foi aberta; na prática, estão montando uma plataforma de trading de RWA.

De 2018 até hoje: sete anos, 8025 commits, 107 repositórios, tudo em Rust. Essa disciplina de engenharia… eu realmente admiro.

#dusk $DUSK @Dusk
Ontem à noite fiquei acordado até as três vendo o código-fonte do Dusk. Quanto mais eu olhava, mais arrepios eu sentia — não por medo, mas porque a profundidade técnica me impressionou. Antes eu tratava $DUSK como uma cadeia de privacidade comum; na prática, a arquitetura dela é totalmente outro tipo em relação ao Zcash.

O núcleo é um modelo de duas transações: o Phoenix usa notas (note-based) com provas ZK para esconder tanto valores quanto as contrapartes; o Moonlight segue um caminho de conta transparente, feito para auditoria e conformidade regulatória. As duas vias rodam em paralelo — privacidade e conformidade não são mutuamente exclusivas. O time do sistema de provas PLONK escreveu tudo do zero em Rust: GitHub com 633 estrelas, adicionaram custom gates e otimizaram o hash do POSEIDON. Eu li as restrições do circuito linha por linha; o design realmente tem substância, não é só um template.

O Citadel SDK faz validação KYC no nível de ZKP e também investiu na Outdid, que usa NFC com verificação por zero knowledge para validar identidade de passaporte. A camada de consenso é a própria SBA — protocolo de tolerância a falhas bizantinas isolado; com “blind bidding” e bloqueio de garantias, o próprio nó que produz o bloco permanece anônimo. A Piecrust VM roda contratos WASM; na versão 2.0, a velocidade subiu 500%. A Kadcast constrói a camada de propagação P2P — 107 repositórios implementados inteiramente em Rust, com disciplina de engenharia muito forte.

Os parceiros também validaram: a NPEX é um MTF licenciado pela AFM da Holanda; a Quantoz emite conformidade MiCA para EURQ. A integração é para rodar liquidações em conformidade sob MiFID II de verdade — não é conversa fiada.

#dusk $DUSK @Dusk Ontem vi uma mensagem: a plataforma NPEX colocou no ar uma solução de custódia baseada em Dusk. Eu rolei a tela e fui lendo — quanto mais eu via, mais interessante ficava. Ela é diferente de todas as soluções de custódia do mercado: os ativos ficam on-chain, as chaves privadas ficam sempre com você e a supervisão/regulação ainda consegue verificar.

Eu nunca tinha visto algo assim.

Quem entende desse ramo de custódia sabe que, até hoje, só existem dois caminhos. Ou você entrega a chave privada a um terceiro custodiante para atender às exigências regulatórias, mas, na essência, os ativos não ficam com você. Ou você gerencia as chaves privadas por conta própria; a segurança fica bem, mas quando a regulação pergunta, você não consegue provar que está em conformidade. Em um dos lados você precisa escolher — não existe uma terceira opção.

A Dusk e a Cordial, com esse esquema de custódia de zero confiança, abriram exatamente esse “terceiro caminho”. Não é custódia por terceiros: é uma tecnologia de carteira self-custody chamada Cordial Treasury. As instituições implantam por conta própria e gerenciam por conta própria; a chave privada permanece o tempo todo no hardware da própria instituição. Quando a NPEX, uma exchange licenciada, adota essa solução, o regulador pode verificar por meio de provas de conhecimento zero se a posição da instituição está em conformidade. Depois que verifica, vai embora — não consegue tocar na chave privada.

Você não precisa entregar as chaves. E também não precisa expor seus ativos para todo mundo. Você consegue comprovar que está seguindo as regras, mas não precisa abrir o patrimônio todo. Esses dois nós — “self-custody” e “compliance” — que se enrolam há dez anos, foram desatados pela primeira vez.

Eu sempre achei que provas de conhecimento zero estavam muito distantes de aplicações práticas, que era algo do meio acadêmico. Desta vez, a Dusk colocou isso dentro de um cenário real de custódia, e ainda rodando em uma plataforma regulada. Não é uma prova de conceito; não é testnet — é algo realmente em uso.

Isso mudou um pouco meu ponto de vista sobre a Dusk. Antes, quando eu observava o consenso, a arquitetura e o modelo econômico, eu achava que era tudo algo do nível técnico. Mas esse esquema de custódia me fez enxergar que ela está resolvendo um problema específico e de longo prazo: como a confiança, na prática, deve ser reestabelecida na blockchain?

A resposta da Dusk é: confiança não é construída ao abrir mão do controle; é construída por verificabilidade. Você não precisa entregar as chaves para que as pessoas acreditem em você.

#termmax @TermMax Na hora de organizar minhas posições na semana passada, acabei abrindo simultaneamente o mercado TermMax nas duas redes: BNB Chain e Arbitrum. Para o mesmo ativo em USDC, com o mesmo prazo de 30 dias e as mesmas regras de protocolo, a diferença na taxa de juros anualizada entre os dois lados era nada menos que mais de um ponto percentual. Minha primeira reação foi: “Será que eu estou vendo coisas?” Recarreguei a tela de negociações três vezes, e também tirei das últimas ~30 dias todas as 127 negociações para conferir, uma por uma, os valores de slippage, confirmando que não era questão de cache — a taxa realmente era diferente.

Naquele momento, a ideia que passou pela minha cabeça foi: isso não pode ser verdade. É o mesmo protocolo, o mesmo produto… como é que mudar de blockchain muda o preço? Aí comecei a desconfiar se eu teria perdido alguma coisa. Fui ver a documentação oficial e descobri que o TermMax atualmente está em 8 redes: Ethereum, Arbitrum, BNB Chain, Base, Berachain etc. Em cada rede, o pool de liquidez roda de forma independente; o módulo de precificação não sincroniza dados entre cadeias. Os formadores de mercado e os usuários de empréstimo em cada blockchain geram relações independentes de oferta e demanda, e, naturalmente, isso resulta em curvas de taxa de juros completamente diferentes. Só aí eu relaxei: não era erro de cálculo meu — a própria arquitetura é assim.

Mas surgiu um problema novo: dá para fazer “trading” com isso? Eu já tinha pisado numa armadilha de arbitragem falsa entre cadeias antes. Aquele cenário em que, aparentemente, existe uma margem favorável, mas na hora de executar você é totalmente comido pelo slippage. Desta vez, eu conferi explicitamente os endereços dos contratos dos pools de liquidez nas duas redes, confirmando que são pools isolados e independentes, sem compartilhamento de liquidez. Não existe aquela lógica oculta de “parece que falta só um ponto, mas ao fazer a ponte entre redes você é amortecido até zerar”.

No mesmo dia, transferi 3.000 U para testar. Não fiquei indo e voltando usando ponte de cross-chain. Usei o agregador da LI.FI: transferi diretamente do BNB Chain para o Arbitrum. Depois de creditar, dei uma olhada: o gas foi descontado em torno de alguns U, e o restante foi todo depositado no mercado com maior taxa. Eu não usei alavancagem, nem toquei em contrato — foi apenas a lógica mais simples: “guardar na rede de preço mais baixo e emprestar na de preço mais alto”. No fim da rodada de contas, consegui uma rentabilidade anualizada extra de quase 1 ponto percentual. Não é muito, mas é estável. Sem assumir risco adicional de contrato inteligente. É basicamente aproveitar o benefício de uma assimetria de oferta e demanda de liquidez entre duas cadeias.

A maioria das pessoas não percebe esse descompasso de precificação causado por pools de liquidez independentes. Isso não é uma falha; é apenas a consequência direta das relações reais de oferta e demanda em cadeias diferentes.

#dusk $DUSK @Dusk Passo a noite inteira sem conseguir dormir, folheando o whitepaper… cheguei na página sobre os verificadores KYC e eu fiquei literalmente sem palavras. Não foi porque o conteúdo me impressionou; foi porque, de repente, me ocorreu uma pergunta — eu teria coragem de colocar meu dinheiro numa blockchain que é totalmente anônima? Pensei dez segundos e a resposta foi: não. Aí percebi que aquelas instituições que gerem centenas de bilhões provavelmente também não teriam coragem, exatamente como eu.

Na minha cabeça passou uma cena: se eu realmente depositasse dinheiro numa chain anônima e, no dia seguinte, a pool fosse esvaziada, eu ficaria ali, gritando para aquele endereço da carteira: “devolvam meu dinheiro”. Mesmo que a outra parte conseguisse responder alguma coisa do tipo “sou anônimo”, eu já consideraria isso pelo menos um mínimo de educação. E depois? Não teria “depois”. No sistema bancário tradicional, se tiram pouco dinheiro de você, ainda dá para ligar, ir ao balcão e fazer uma cena, ou até processar. Na blockchain, você só consegue ficar encarando o endereço num explorador de blocos.

A Dusk exige que os verificadores sejam identificados. Por fora parece um retrocesso da descentralização, mas, se você calçar o sapato das instituições, entende: o que elas querem não é anonimato e liberdade — é poder encontrar pessoas reais caso algo dê errado.

Mais tarde, eu entendi: a Dusk não quer anonimato puro, nem publicidade totalmente aberta. Ela busca um meio-termo — você consegue provar quem você é, mas não precisa colar seu RG no rosto. O sistema de identidade da Citadel, combinado com provas de conhecimento zero, funciona assim: é como entrar num clube sofisticado; na porta o segurança sabe quem você é, mas os clientes lá dentro não precisam vasculhar a vida uns dos outros. Com o arcabouço regulatório de MiCA e MiFID II, essa solução fica bem mais complexa do que eu tinha imaginado no início, mas também é bem mais prática.

Em 7 de janeiro de 2026, a mainnet entrou oficialmente no ar. Depois de um ciclo de desenvolvimento de seis anos, finalmente chegou ao mundo real. A DuskEVM roda em sincronia; desenvolvedores Solidity já podem construir diretamente em cima. Componentes centrais como DEX e pontes cross-chain também foram atualizados. A rede exige que mais de um terço dos stakers cumpram as regras: quem fizer besteira ou ficar desconectado por muito tempo é penalizado com slashing. O tempo de bloco é de 10 segundos — para ativos tokenizados, essa velocidade é suficiente.

Antes, eu lia os whitepapers e passava direto por capítulos como “mecanismo de verificadores”, achando que não tinha nada a ver comigo. Eu reli esta página da Dusk várias vezes — não porque ela fosse tão bem escrita, mas porque ela me fez perceber uma coisa: para avaliar se um projeto é bom ou não, não é olhar para o barulho do slogan. É ver se ele tem a coragem de resolver antes aquela situação do “não consigo ter coragem”. “Não vou” é uma decisão que pode ser antecipada — ou não.

#termmax @TermMax 白皮书第6节有个细节：对比固定利率撮合和浮动利率AMM，想证明“更稳”。但细读会发现，单期限池兑付安全性与清算效率死死绑在一起。

我们可以看到，LTV达阈值由Chainlink自动触发，设2小时开放窗口，任何清算人参与可得5%奖励。部分清算后剩余抵押品会退还给借款人；只有2小时窗口内未被完全清算时，才触发实物交割——FT持有者按比例获得抵押品。问题就出在2小时——极端行情下价格可能再砸穿一层，清算人若观望，坏账最终由全池用户买单。白皮书提“物理交割”兜底，但这本质是用 lenders 的收益换抵押物，并非无损。

就像生鲜店临期品打折窗口2小时，平稳时没问题，暴跌时要么不够要么浪费。TermMax踩的正是这个两难：窗口太短清算不充分，太长坏账累积，没有完美解。

白皮书说权限限于利率曲线、费用率等参数，清算由预言机和执行者决定。但参数即利益——清算罚金10%，5%给清算人、5%进协议储备金库。金库用途由TMX治理决定，这才是该盯的地方。好在协议设了制衡：关键参数更改须经时锁等待期（最短1天、最长30天），期间守护者可审查并撤销。但筹码集中时，治理方向仍可能向大户倾斜——制衡机制只能延缓，不能逆转。

如果你问我的看法，我的想法就是别被“固定利率”的数学公式唬住，每个参数设置都是利益分配。筹码分散，机制可接近无风险；筹码集中，就是镀金的隐性资金池。
DYOR，关注参数谁设、怎么调。清算窗口是给用户更稳保障，还是给大户留操作空间？评论区见。

#dusk $DUSK Esta semana revisei novamente os materiais de @Dusk . Eu queria começar vendo a narrativa de privacidade, mas no fim foi a “fronteira de divulgação” que ficou mais tempo parado na minha cabeça. Antes eu sempre achava que o núcleo dos acordos de privacidade era “esconder”: desde que a criptografia, o anonimato e essas provas fossem fortes o suficiente, o sistema funcionaria. Mas, ao olhar com mais profundidade, percebi que o problema mais real não é “se dá para ocultar”, e sim em que condições deve ser visto.

A Dusk coloca privacidade e conformidade juntas e, essencialmente, busca uma divulgação controlável. As vantagens desse design são bem claras: instituições não precisam abandonar a eficiência on-chain para atender à conformidade, e desenvolvedores não precisam enfiar toda a lógica em uma estrutura unificada e pesada. Só que o custo também começa a aparecer: quais informações podem ser mantidas, quais devem ser expostas, para quem será feita a exposição e até que nível de granularidade — nada disso se resolve diretamente só com quatro palavras “tecnologia de privacidade”. O que realmente é difícil não é a criptografia; é quem detém o poder de divulgação.

Esse ponto de silêncio é bem parecido com o roteiro mais comum no mercado de cripto. Muitos projetos adoram falar sobre “proteção de privacidade”, mas quando chega a hora de colocar em prática, a primeira coisa que surge geralmente não é um problema técnico — é um problema de controle. Quem decide quando desbloquear as informações é quem ganha o novo poder de interpretação; quem controla as exceções pode acabar virando um novo ponto central. À primeira vista, isso parece amigável para a conformidade, mas, olhando mais de perto, também pode puxar a “privacidade descentralizada” de volta para uma estrutura do tipo processo/aprovação.

Eu não nego que esse design tem valor. Na fase de inicialização, sempre é preciso que alguém escreva primeiro um rascunho das regras — assim como, quando uma casa é entregue, você precisa definir primeiro o controle de acesso e as permissões para visitantes. Só que há muitos projetos no mercado que transformam “divulgação controlável” em uma resposta universal; no fim, tudo o que fazem é criar mais uma camada de autorização ainda mais complexa. O que a Dusk mais merece atenção agora não é se ela consegue falar bonito sobre privacidade, mas se ela vai transformar o poder de divulgação em um novo centro.

A arquitetura técnica pode ser auditada; já a distribuição de poder por trás das fronteiras de divulgação é muito mais difícil de auditar. DYOR: a privacidade pode ser criptografada, mas a fronteira não desaparece sozinha. Você acha que a divulgação controlável, no fim, vai virar uma nova porta de entrada centralizada?

#dusk $DUSK @Dusk 这几年看链上协议出问题，我养成了一个习惯：不太关心黑客有没有暴力破解，反而先看掌握网络共识安全的核心组件，到底靠什么机制把验证者死死按住了。见过太多节点作恶，根子不是算法被攻破，是共识设计从一开始就默认“验证者会老实听话”，这个默认只要失效一次，罚没机制就会沦为空谈。

最近拆解 Dusk 的 SA 共识与 Slashing 设计时，让我停下来的正是这一层。@Dusk

Dusk 的 Succinct Attestation（SA）共识采用委员会型 PoS 模型，通过确定性抽签算法选出出块者和投票委员会。它把恶意行为和过失行为分开处理，对应 Hard Slashing 和 Soft Slashing 两套机制。Soft Slashing 针对节点未出块这类非恶意过失——第一次警告，之后每次连续违规扣除 N×10% 的质押权益并从共识中移除 N 个 epoch，但罚没的 DUSK 不销毁，只是从活跃质押中移除，节点仍可提取。Hard Slashing 则针对明确恶意行为：生成无效区块扣 10% 质押并销毁，双重投票或双倍出块扣 20% 并销毁。这套设计让 Dusk 具备可追责性，但验证者一旦作恶代价极重。

我也不会把它捧上天。架构再精妙，如果验证者为了降低运维成本而集中托管节点，或者长期在线率低于 95% 触发 Soft Slashing 累积扣减，协议精心构建的安全边界就会面临真正考验。未来若为了省事把验证节点集中在少数几个实体手里，所谓的“去中心化”就只剩心理安慰。

在我看来 $DUSK 的价值最终看有多少验证者愿意为了安全牺牲便利。以后合规资产上链会越来越多，我更在意的不是收益率有多高，是谁能证明在巨大的利益诱惑面前，这套让作恶者付出真金白银代价的机制依然能被严格执行。

#termmax @TermMax 翻TermMax主网V2的链上交互日志时，最先让我停下来的不是TVL破亿的增长数据，是它把「资金归集」和「到期计息」拆成了两个完全独立的权限域。
入金进来的资产先落在公共Deposit Pool里，这是个仅支持充值、提现的中转账户，不能直接生成计息头寸。想参与固定收益策略得手动把指定金额划转进对应到期日的Term Segment分片，这步操作会自动触发链上时间锁校验，没有任何后门可以跳过。资金全程待在隔离的静态池，计息权限单独开了一道独立的执行门。
这套权限逻辑我在券商固收托管系统里见得很多，之前帮朋友做资管系统外包的时候，光资金隔离这块就改了三版需求，机构做大额资金管理，资金调拨和产品计息清算从来不会共用同一套密钥。但链上绝大多数借贷协议默认钱包地址等于全量操作权限，上个月群里还有个兄弟私钥漏了半仓USDC直接被转空，连申诉的地方都找不到。TermMax文档里标注的TBAC时间基访问控制，走的就是这个隔离思路，和Aave的全局统一权限体系完全不同，连治理多签都没有修改Term Segment到期参数的权限，让每一步操作只对应它该有的最小权限。
顺着这条线看它的固定到期原语架构，逻辑完全自洽。上层产品组合层开放接口，对接各类结构化收益工具做玩法延伸；底层清算层完全锚定Term Auction荷兰拍卖模块做最终链上执行。专业资金不用为了稳定收益牺牲资产隔离性，所有到期状态又能全节点可验证。
我觉得TermMax真正在解决的，对大额资金来说，缺的从来不是年化收益，是一套能完全信任的时间边界规则。
当然假如，极端行情下大量头寸同步到期时，系统能不能扛住集中清算的压力，还要再观察。但这个设计思路让我觉得，链上固收要承接更大体量的资金，从来不是单纯拼收益率这么简单。

#termmax @TermMax TermMax V2的技术文档翻完之后，最戳我的其实是昨晚蹲在沙发上啃文档，半杯冰可乐洒在键盘上，擦屏幕的时候才扫到的那句很容易被划走的说明：TermMax本身不是一个借贷产品，只是个固定到期资产原语，真正的收益产品、结构化工具是外面接的那些。

我当时擦着可乐印盯着屏幕愣了半分钟，顺着往下读才明白，一笔固定期限的借贷合约一创建，到期时间、清算阈值、结算币种三样就直接锁死在链上，不是先存进去再动态调参数。等于说这个合约从生下来就知道自己哪天到期、怎么清算、用什么结算，跟以前Aave、Compound这类永续借贷“先存进去再说，利率随时变、清算线随时调”的路数完全不一样，去年我在Aave上存ETH半夜被插针清算走半仓的阴影瞬间就上来了，用户根本不用担心中途突然被插针清算或者利率暴跌。
行业数据说现在DeFi里90%以上的借贷都是浮动利率的永续模式，固定收益类占比不到10%，看完这套设计我大概能懂为什么之前固定收益一直做不起来——不是用户不需要，是底层原语就没做对。
拿它最近上线的阶梯收益结构化产品顺一遍就更好懂：USDC存进TermMax这边的90天固定期合约，状态在外部结构化协议那头变成分层收益凭证，优先级拿固定利息，劣后吃超额收益。到期自动本息结算，不用用户手动赎回；要是底层抵押品跌破清算线，合约会自动触发荷兰拍卖清算，全程不用治理投票，也不用人工干预。这套清算能做到这么顺滑，底子是它原生的时间锁+链上拍卖模块，把清算逻辑直接写进合约底层，比传统借贷靠第三方清算人抢跑的模式稳太多，Gas成本低60%以上，跟活期借贷那套实时喂价、实时清算的逻辑完全是两条路，别搞混了。
产品交给别人接”这个设计思路，才是它能不停长出新玩法、不用每次都重新造轮子的根本原因。

#dusk $DUSK @Dusk 第一次看到 Dusk 提到 Selective Disclosure（选择性披露）时，我其实没有太在意。当时我的理解很简单：隐私协议不就是隐藏交易信息吗？把金额、地址、交易关系保护起来，让别人看不到，不就完成隐私保护了吗？

直到前几天整理 Dusk 白皮书笔记，我把 Phoenix 交易模型和合规资产场景放到一起重新梳理。看到 Selective Disclosure 这一部分时，我停了下来。因为我发现一个之前忽略的问题：如果 Phoenix 已经隐藏交易状态，那么机构、审计方和监管者，到底如何确认这笔交易符合规则？

这个问题让我重新理解了 Dusk 的设计。我原本以为隐私的核心是“不让别人看到”，但研究之后才发现，机构真正需要的不是完全隐藏，而是控制信息在什么时候、向谁、以什么方式被验证。

Phoenix解决的是交易隐私本身。通过 shielded notes 和零知识证明，网络可以验证交易有效性，而不需要公开完整余额、交易关系和资产状态。但对于证券、基金等受监管资产来说，仅隐藏信息还不够，金融市场需要审计，需要确认规则执行，也需要在特定情况下提供证明。

这就是 Selective Disclosure 存在的意义。它不是打破隐私，而是在隐私基础上建立验证出口：默认保护交易数据，当授权主体需要检查时，只披露必要信息，而不是公开全部交易历史。

重新把这两个机制连接起来后，我才理解 Phoenix 和 Selective Disclosure 并不是两个独立模块。前者解决“如何隐藏并证明交易正确”，后者解决“隐藏之后如何满足现实金融规则”。过去公开区块链的问题是透明但缺少隐私，传统金融的问题是信息可控但依赖中心化验证。
它改变的不是简单的信息隐藏方式，而是链上金融里的信任边界。未来 RWA 真正进入链上，挑战不会只是发行Token，而是如何让资产同时满足隐私、监管和自动执行。

#termmax @TermMax 上周刷链上收益榜单偶然刷到TermMax的时候，它的TVL才刚摸到7100万，我对着它的借贷利率曲线翻了十分钟，觉得产品逻辑挺顺但毕竟是新项目，总觉得"再观察两周，等数据稳点再进"，随手把合约地址存进了我的观察钱包，转头就去忙别的事了。

上周刷链上数据看板，看见它TVL冲到9000万的时候，我盯着观察钱包里的空地址犹豫了五分钟，手指都放到确认转账的按钮上了，最后还是缩了回来，总觉得"涨这么快肯定有回调空间，再等等能拿到更舒服的仓位"，还自我安慰反正没踏空行情，晚两天进也不亏。

昨晚刷官方公告看见它TVL正式破亿，我坐起来翻完了它的全量链上数据。翻到产品架构那一页我真正看进去了——FT以折扣价买入、到期按面值赎回，GT把抵押物和债务打包成独立头寸。以前我看固定利率协议最怕资金闲置，挂单等匹配时钱就卡着不动。TermMax直接把底层接到Morpho，挂单时自动跑浮动收益，撮合成功无缝切固定利率。这套逻辑比我预想的成熟得多，但越成熟，我越后悔——当初怎么就没下手呢？上线才一年就从主网迭代到V2版本，已经部署了10条EVM链，总用户直接破了110万，这完全不是靠短期挖矿激励堆出来的虚高数据，是真的有大量用户在高频使用它的借贷产品。

之前炒山寨币浮亏几万我都没这么难受，亏钱是自己踩坑认栽，割肉就能重来。但这种遗憾完全不一样，你明明从最早期就看见了它，两次站在车门口都没抬脚上去，眼睁睁看着它从"有潜力的新项目"长成赛道头部，每一步增长你都看在眼里，却全因为自己的犹豫错过了。

我现在又盯着观察钱包的空地址发呆，有没有老玩家说句实话，现在上车$TMX还来得及不？@TermMax

#dusk $DUSK 这些年看隐私链翻车，我慢慢养成一个习惯：不太关心加密算法有没有被破解，反而先看留着合规后门的那个人到底被约束住了没有。见过太多隐私项目暴雷，根子不是零知识证明被攻破，是权限设计从一开始就默认“项目方不会乱碰用户数据”，这个默认只要有一次不成立，用户的资产、交易数据裸奔就是迟早的事。
拆@dusk_foundation 主网RC版本的ZkKYC执行流程，让我停下来的正是这一层。它不是给隐私链多装一个合规模块，而是把“谁能看我的数据”直接变成“零知识电路能核验的硬规则”。用户开通审计权限前，规则先过原生Citadel模块的电路判断，身份凭证自持本地、交易状态靠Pedersen承诺加密，校验逻辑全链上公开。哪怕是项目方也没法绕过电路直接调取用户数据，零知识证明保证权限校验过程本身没被篡改，没到用户设定的授权范围，任何审计请求根本调不到明文数据。
#dusk 这个思路很像去银行开资产证明，柜员没法直接翻你全账户流水，只能按你申请的金额、用途开对应证明，多一点信息都拿不到。链上过去一直缺这道隐私确权的关卡，Dusk想补的不是匿名性有多强，是给隐私使用划一条用户可控的边界。
我也不会把它捧上天。用户弄丢本地KYC凭证就没法再开合规审计证明；零知识电路如果出逻辑bug，权限校验照样会出漏洞。真正要验证的不是叙事漂亮不漂亮，是真实RWA资产跑上去之后这套隐私约束扛不扛得住。
以后链上合规资产会越来越多，我更在意的不是它能不能做匿名交易，是谁能证明你的隐私只有你自己说了算@Dusk

#dusk $DUSK Ontem às duas da manhã, fiquei encolhido na escrivaninha do escritório alugado, folheando o whitepaper branco do @Dusk por horas. A quina da mesa ficou aberta por meia hora e a Coca gelada congelada escorreu até acabar; as gotinhas de água condensada na borda do copo pingavam no mousepad, abrindo um círculo pequeno e escuro.

O Dusk foca em privacidade para cenários financeiros na sua Layer1. O consenso Succinct Attestation desenvolvido por eles — em outras palavras, é especificamente para tratar os velhos buracos em PoS que eu já pisei inúmeras vezes: grandes detentores monopolizando a produção de blocos, a fonte de aleatoriedade sendo fácil de manipular, e a confirmação de blocos demorando. Tudo o que prometem é um “final determinístico em 3 segundos”, aguentar ataques de 51% e não permitir que alguns grandes holders fiquem com o poder de dizer as regras na produção de blocos.

Olhando assim, não tem nada de errado.

Descentralização, segurança e alto desempenho — as três dores que a indústria briga há anos — ele diz que cobre todas? Aí, quando vou até a parte de geração de sementes por sorteio aleatório, o whitepaper fica particularmente vago: ele só solta “gerado por agregação de hash do bloco anterior”, e pronto. Eu empurrei o mouse para o lado, fiquei encarando a tela por dois segundos sem mexer. Se o desempenho da aleatoriedade no sorteio dos nós produtores de blocos puder ser antecipado por poucos nós grandes, ou até conspirar e manipular, então a tal “aleatoriedade justa para selecionar validadores” é pura encenação. O atributo de descentralização mais central de uma blockchain de privacidade cai pela metade. A pergunta — “essa semente aleatória pode ser adulterada por conluio?” — qualquer pessoa que trabalha com consenso distribuído entende; é muito mais difícil do que simplesmente acelerar a produção de blocos. Se houver brechas no design da fonte de aleatoriedade, alto desempenho e resistência a ataques viram mensagens promocionais em conflito entre si, sem chegar ao chão. @Dusk

Aqui tem uma contradição central: um protocolo que promete atender liquidações de ativos em nível institucional. Se a lógica verificável do sorteio aleatório não estiver explicada completamente, a credibilidade do consenso SA ainda precisa ser validada com dados de execução contínua na mainnet, e não pelas alegações em texto do whitepaper.

O valor de longo prazo do $DUSK , de certa forma, fica totalmente preso a saber se esse mecanismo de consenso realmente consegue funcionar de verdade.

Quando você pesquisa um projeto, qual parte do whitepaper é o que mais te preocupa por estar escrita de forma vaga? Conversem no campo de comentários.

#dusk $DUSK Ontem atualizei o site oficial do Dusk e a barra de navegação inteira foi trocada.

As antigas entradas que eu usava há quase um ano simplesmente desapareceram, limpas e sem deixar nada. Eu fiquei alternando entre as duas seções "stack técnico" e "desenvolvedores" quatro ou cinco vezes até finalmente achar a documentação do nó. Sinceramente, fiquei um pouco irritado — mas seguindo o novo site oficial, descendo do protocolo de base até chegar no topo, e depois de ler as três atualizações principais, acabei ficando feliz por aquela noite não ter sido em vão.

Primeiro, DuskEVM — é a coisa que eu mais queria reclamar e, ao mesmo tempo, a que mais me surpreendeu.

Eu sempre achei que a máquina virtual Rusk tinha privacidade no máximo, mas o desenvolvimento de contratos nativos em Rust tem uma barreira muito alta. Só que desta vez o DuskEVM basicamente bloqueou minhas reclamações: ele não é uma ponte cross-chain; ele vem com um tradutor embutido de bytecode. O que isso significa? Eu jogo um contrato original em Solidity e ele converte automaticamente em um código de execução privado que atende às restrições de circuitos PLONK, e eu nem preciso me preocupar com a camada ZK por baixo.

Na prática é ainda mais direto. Ontem à noite, no testnet, peguei um contrato de Swap que eu já tinha e testei. Do processo de compilação até a implantação, levou 12 minutos. Comparado com antes, quando eu tinha que escrever contratos nativos em Rust na marra, a eficiência é incomparável — não é nem uma ordem de grandeza, é mais. Esse tradutor é hoje o ponto que eu mais quero recomendar.

Dusk Trade foi o segundo que me pegou de surpresa.

Ele é baseado na arquitetura Phoenix zkUTXO. Eu fiquei olhando por um bom tempo até entender: você pode imaginar que cada transação é um ticket criptografado independente, e só quem tem a chave consegue ver o conteúdo. Não existe Mempool público, então robôs de pinça não conseguem disparar para roubar. Ao mesmo tempo, há uma interface embutida de chaves de visualização direcionada — quando instituições de market-making precisam passar por auditoria MiCA da União Europeia, elas podem autorizar de forma direcionada para visualizar registros de transações. Desta vez, conformidade e privacidade não precisam ficar em escolha excludente.

Os fluxos de trabalho de mercado com conformidade já compilam KYC e período de bloqueio dentro da prova ZK. Quando a transação é enviada on-chain, a conformidade é verificada automaticamente; a revisão manual simplesmente é dispensada.

Antes eu sempre dizia que privacidade e conformidade só podiam ser escolhidas separadamente. Com essa solução da Dusk, a opção "ou uma ou outra" deixa de existir.

O único problema é... quando é que voltaremos a construir aplicações on-chain? Eu abandonei na época porque a barreira de desenvolvimento era alta. Então, quando vocês pretendem voltar? @Dusk

#dusk $DUSK Lembra da recompensa no teste do Dusk que estava rolando? Quando tentei fazer a etapa de depósito, a plataforma me impediu por causa de uma validação da origem dos fundos. Eu já estava pronto — inclusive tinha deixado em ordem o histórico de transações do endereço por uns seis meses. Antes, quando eu jogava Zcash, eu fazia esse tipo de prova de conformidade: só para mandar os prints, eu fiquei quase 20 minutos. O Gas ainda queimou quase 0,1 de uma moeda, e eu acabei expondo toda a posição do meu endereço para o verificador. Toda vez que aparece uma exigência assim, eu fico com a cabeça cheia.

No final, no wallet do Dusk, eu cliquei três vezes e em dois minutos a validação passou. Nem mesmo o verificador chegou a ver quantos tokens de teste restavam no meu endereço.

Minha visão do Dusk antes era bem limitada: “uma blockchain de privacidade”. Eu até presumía que ele era igual a outras chains anônimas — que, para ter privacidade, abre mão de auditabilidade. Eu levei quase duas horas para ler o código Rust do modelo de transações do Phoenix; quando entendi direito, foi como se o design acertasse exatamente os pontos doloridos.

Ele não tem um interruptor simples do tipo “tudo público/tudo anônimo”. Na camada de prova com zk-SNARKs, ele implementa um desenho de credenciais criptográficas verificáveis (VEP), usando o algoritmo Plookup para comprimir o tamanho do corpo da prova para dentro de 1KB. Em outras ZK chains de privacidade, provas desse tipo geralmente precisam gerar pelo menos 10KB ou mais; a verificação ainda leva dezenas de segundos. Já a verificação on-chain dele só precisa de 2 milissegundos. Para provar que o dinheiro veio de uma exchange legítima, basta gerar uma prova direcionada para aquela transação de depósito — não é necessário expor o endereço completo, o total de holdings, nem outros registros de transações, e nem mesmo é preciso dizer qual é o endereço de recebimento para o outro lado. Quando eu gerei a prova, gastei apenas 0,0003 DUSK de Gas — mais barato do que uma simples transferência. O verificador pôde validar a veracidade diretamente via contrato on-chain; eu nem precisei repetir o processo de upload de prints. Conferindo no explorer de blocos, nessa transação só aparece o hash da prova — não existe metade dos dados em texto claro.

Antes, todas as outras chains de privacidade ficavam presas nesse beco sem saída: “se quiser privacidade, não tem como cumprir conformidade; se quiser conformidade, perde privacidade”. O Dusk devolve totalmente o controle de privacidade para o usuário: quando você precisa esconder transações, não há nenhum texto claro para consultar na chain; quando precisa fazer a prova de conformidade, você mostra ao outro lado somente o mínimo de informações necessárias. Nem um tiquinho de privacidade extra precisa ser vazado.

Vocês já passaram por aquela situação constrangedora de, para fazer autenticação na blockchain, serem forçados a expor todas as holdings? @Dusk

#dusk $DUSK 老伙计深夜甩来两条60秒语音，语气跟当年喊我冲土狗一样急：Dusk主网上线，质押节点能跑了，隐私赛道头矿。

我心想跟Sui、Aptos那会儿差不多吧，装二进制挂着就行。结果三天通宵才啃明白。

第一天就卡壳。./dusk-node跑起来，ZK证明生成到87%必崩，终端吐一句"witness construction failed"，内存从4G顶到12G，风扇跟楼下夜宵摊抽油烟机似的。重装五次程序、重下三次快照，都没用。最后翻GitHub示例，一行注释小得差点漏过去："key expects BigInt, string will break witness construction."改完传参方式，重启，8秒证明生成。

静下心翻源码才懂。Dusk的隐私方案不是给EVM套层壳，而是Rusk这个原生隐私虚拟机直接把PLONK零知识证明电路、Poseidon哈希、BLS签名这些密码学组件内置进去。开发者写合约时不用手动处理加密逻辑，编译完就是零知识友好的WASM字节码。合约代码自动转成约束电路，多笔交易能递归聚合成一个批量证明，节点只验证明哈希，地址、金额全程不上链，但每笔交易的合规性都能被数学证明验证。

共识层是SBA（隔离拜占庭协议） 。验证者至少要锁1000枚$DUSK ，每轮出块不仅要打包交易，还得附一份证明出块行为合法的ZK证明。Dusk的罚没分两种：软罚没针对漏块，会暂时移出共识并降低有效质押额；硬罚没针对作恶——出无效块罚没10%，双签或双块罚没20%，直接销毁。硬件方面，官方建议4核CPU、8GB内存起步。

跑了三周，收益没营销号吹得夸张。但跑通那晚机箱风扇安静下来，回头看三天值了，不是赚多少，是把一条新链的底子从头啃了一遍。@Dusk

#baby $BABY Na noite anterior eu fiz uma coisa: testei o script de staking do Babylon usando um UTXO que eu mesmo coloquei na minha rede de testes.

Queria ver como exatamente funcionam aqueles três modos de saída.

Primeiro, testei o mais simples — depois do vencimento do stake, basta usar apenas a minha própria assinatura para desbloquear aquele UTXO e transmitir para a rede de testes do Bitcoin. Os nós validaram, a transação foi empacotada. Não precisa que um Finality Provider dê o aval, não precisa que a cadeia do Babylon esteja online; minha assinatura por si só já basta. Na hora, eu pensei: este é o sentimento de segurança mais “primitivo”. Enquanto a rede do Bitcoin continuar rodando, o staker consegue recuperar os próprios fundos.

Depois testei a segunda opção: simular que eu não quero esperar o período completo de staking e quero sair antes. Aqui é preciso minha própria assinatura, além da assinatura do comitê Covenant. A minha assinatura é fácil; do lado do comitê, eu simulei o fluxo de assinatura. Depois de transmitir, a validação do nó passou e o UTXO foi desbloqueado com sucesso. Entendi então: o comitê só serve para confirmar que “esse pedido de saída antecipada cumpre as regras”; ele não assume os ativos, nem tem controle sobre eles.

Quando testei a terceira opção, eu travuei. O caminho de slashing requer três chaves: minha assinatura, a assinatura EOTS do Finality Provider e a assinatura do comitê Covenant. Na hora eu pensei: por que o slashing ainda precisaria da minha própria assinatura? Isso não estaria me obrigando a participar da punição de mim mesmo?

Mais tarde, ao revisar o relatório de auditoria, entendi o motivo. A assinatura do comitê Covenant é uma assinatura adaptadora — após criptografada, ela é direcionada ao Finality Provider. Eu pré-assinei o caminho de slashing, mas essa assinatura permanece “travada” em condições normais. Só quando o FP usar o mesmo nonce aleatório para assinar dois blocos diferentes na mesma altura, expondo a chave privada, é que a assinatura adaptadora é decifrada e passa a valer.

Isso significa que eu não preciso confiar em ninguém para que não faça maldades. Se o FP fizer maldade → a matemática revela a chave privada → a assinatura adaptadora se descriptografa automaticamente → o caminho de slashing é desbloqueado. Eu não preciso que um administrador decida “se deve punir ou não”, nem preciso de qualquer aprovação de alguém.

Eu testei as três formas de saída. Qual caminho seguir não depende de alguém; depende somente se as condições “hard-coded” no script são satisfeitas.

@BabylonLabs_io