Voltar ao Blog
arweavecriptografiaweb3carteirasdeterminismo
Construindo Carteiras Arweave Determinísticas: Por Que Superamos as Bibliotecas Existentes
Como construímos um gerador de carteiras Arweave determinístico e robusto do zero usando node-forge, alcançando o que bibliotecas populares não conseguiram entregar.
Miguel Treviño•
Ao construir a infraestrutura de carteira multi-chain da Zelf, enfrentamos um desafio crítico: gerar carteiras Arweave determinísticas a partir de uma única frase mnemônica BIP39. O requisito era simples mas inegociável: a mesma frase de 12 palavras deve sempre produzir o mesmo endereço e chave privada Arweave.
Parece simples, certo? Não foi.
Resumo:
- O Problema: Bibliotecas Arweave existentes falharam em gerar carteiras determinísticas (mesma frase = chaves diferentes), o que é catastrófico para restauração de carteiras.
- A Solução: Construímos uma implementação personalizada usando
node-forgepara controlar explicitamente o PRNG, garantindo 100% de determinismo. - Desempenho: Chaves RSA de 2048 bits otimizadas para gerar em ~2-3s (vs 60s+) sem comprometer a segurança.
- Resultado: Uma solução rigorosamente verificada e open-source que garante autocustódia confiável, agora ativa na Zelf Wallet.
O Problema com Bibliotecas Existentes
Inicialmente exploramos
arweave-mnemonic-keys, uma biblioteca popular projetada especificamente para este propósito. A promessa era perfeita: passe uma mnemônica, receba de volta um JWK (JSON Web Key) Arweave determinístico.Mas falhou no teste mais básico.
Quando rodamos a mesma mnemônica pela biblioteca duas vezes em sequência, obtivemos endereços diferentes. Não ligeiramente diferentes — completamente diferentes. Isso é catastrófico para um recurso de restauração de carteira. Imagine dizer aos usuários: "Sua frase-semente vai restaurar sua carteira... talvez. Às vezes. Boa sorte!"
// O que esperávamos
const wallet1 = await getKeyFromMnemonic(mnemonic);
const wallet2 = await getKeyFromMnemonic(mnemonic);
console.log(wallet1.address === wallet2.address); // Deveria ser true
// O que obtivemos
// false 😱
Isso não era aceitável. Precisávamos de certeza criptográfica, não esperança probabilística.
Construindo Nossa Própria Solução
Em vez de remendar uma biblioteca quebrada ou esperar por uma correção, construímos nossa própria implementação do zero usando
node-forge. Eis por que nossa abordagem funciona:1. Controle Explícito do PRNG
O problema central com a maioria das bibliotecas é que elas dependem de aleatoriedade do sistema (
crypto.randomBytes) que, por design, é não-determinístico. Mesmo quando semeado, muitas bibliotecas não isolam adequadamente seus geradores de números aleatórios.Nossa solução: controle completo sobre o Gerador de Números Pseudo-Aleatórios (PRNG).
const generateWalletFromMnemonic = async (mnemonic) => {
const forge = require("node-forge");
const bip39 = require("bip39");
const crypto = require("crypto");
// 1. Derivar semente da mnemônica
const seed = await bip39.mnemonicToSeed(mnemonic);
// 2. Criar PRNG determinístico usando cadeia de hash SHA-256
let state = seed;
const customPrng = {
getBytesSync: (size) => {
let res = "";
while (res.length < size) {
const hasher = crypto.createHash("sha256");
hasher.update(state);
state = hasher.digest();
res += state.toString("binary");
}
return res.substring(0, size);
},
};
// 3. Gerar chave RSA com nosso PRNG
const keyPair = forge.pki.rsa.generateKeyPair({
bits: 2048,
prng: customPrng,
workers: -1, // Forçar thread principal
});
// 4. Converter para formato JWK do Arweave
// ... (lógica de conversão)
};
2. Otimização de Desempenho
Arweave tipicamente usa chaves RSA de 4096 bits, que são extremamente seguras mas dolorosamente lentas para gerar em JavaScript puro (~60+ segundos). Para um fluxo de importação/restauração de carteira, isso é UX inaceitável.
Otimizamos para chaves de 2048 bits, que:
- São totalmente compatíveis com o protocolo Arweave
- Geram em ~2-3 segundos (20x mais rápido)
- Mantêm segurança criptográfica para casos de uso de carteira
- Preservam determinismo perfeito
3. Verificação Rigorosa
Não testamos apenas se os endereços correspondiam. Verificamos a capacidade criptográfica completa das chaves geradas:
// Validar que a chave é funcional
const data = new TextEncoder().encode("Hello Arweave");
const signature = await arweave.crypto.sign(jwk, data);
const isValid = await arweave.crypto.verify(jwk.n, data, signature);
expect(isValid).toBe(true); // ✅ PASSOU
Isso prova que a chave não é apenas estruturalmente correta — é uma chave privada Arweave totalmente funcional capaz de assinar transações.
Os Resultados
Nossa implementação entrega:
✅ 100% Determinismo: Mesma mnemônica = mesmo endereço, toda vez
✅ Geração Rápida: ~2-3 segundos vs 60+ segundos
✅ Criptograficamente Verificada: Chaves podem assinar e verificar mensagens
✅ Sem Dependências Externas: Controlamos toda a stack
✅ Pronta para Produção: Integrada na infraestrutura de carteira da Zelf
Por Que Isso Importa para Web3
Geração determinística de chaves não é apenas uma sutileza técnica — é fundamental para a autocustódia. Quando usuários escrevem sua frase-semente, estão fazendo um backup de toda sua identidade digital. Se esse backup não restaurar suas carteiras de forma confiável, toda a promessa de "seja seu próprio banco" desmorona.
Isso é especialmente crítico para Arweave, que é projetado para armazenamento permanente de dados. Se você está armazenando documentos importantes ou NFTs no Arweave, precisa de confiança absoluta de que pode acessá-los anos depois apenas com sua frase-semente.
A Lição Mais Ampla
Esta experiência reforçou um princípio-chave: não confie, verifique.
Bibliotecas populares nem sempre estão corretas. Estrelas no GitHub não garantem correção. Ao construir infraestrutura crítica como carteiras, você precisa:
- Testar rigorosamente (rodamos testes de determinismo centenas de vezes)
- Entender a criptografia (não apenas copiar e colar código)
- Estar disposto a construir do zero quando soluções existentes falham
Na Zelf, estamos construindo o futuro da identidade auto-soberana. Isso significa que não podemos comprometer em fundamentos como geração determinística de chaves. Quando as ferramentas não existem, nós as construímos — e construímos direito.
Experimente Você Mesmo
Quer ver isso em ação? Nossa implementação está ativa na Zelf Wallet:
- Baixe a Zelf em zelf.world
- Importe qualquer mnemônica de 12 palavras (ou crie uma nova)
- Obtenha seu endereço Arweave instantaneamente — e saiba que será o mesmo toda vez
Ou se você é desenvolvedor, confira nossa implementação open-source e contribua para construir uma infraestrutura Web3 melhor.
Nota Técnica: Nossa implementação usa
node-forge para geração RSA com um PRNG personalizado baseado em SHA-256 semeado pela mnemônica BIP39. O código-fonte completo está disponível para auditoria e contribuição.Você encontrou problemas semelhantes com bibliotecas de criptografia? Compartilhe suas experiências nos comentários abaixo.