Construindo Carteiras Arweave Determinísticas: Por Que Superamos as Bibliotecas Existentes

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-forge para 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.

Comece a Construir | Baixe a Zelf

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.