pwAccountability record
Menu
Trending
Latest ›
Today’s edition ›
The Claim Ledger ›

FeedSearchLedgerSignalsMore

pooter.world · March 25, 2026

ZK Password Recovery

Cross-chain wallet recovery without seed phrases


The Problem

Seed phrases are the #1 reason people lose access to their crypto. Write down 12 words, store them somewhere safe, never lose them, never let anyone see them. It's a UX disaster hiding behind the word "self-custody."

The alternatives aren't great either:

  • MPC wallets (Privy, Web3Auth, Magic) — your key is split across servers you don't control. If the company shuts down, you might lose access.
  • Social recovery (Argent, Safe) — you need trusted friends/guardians who won't collude, lose their keys, or die.
  • Custodial wallets (Coinbase, exchanges) — not your keys, not your crypto.

Every existing solution reintroduces a trusted third party. We wanted something different: recover a self-custody wallet with just a password, verified on-chain, with zero trust assumptions.

The Insight

Zero-knowledge proofs let you prove you know something without revealing it. If we can prove "I know the password that hashes to this on-chain commitment" — without revealing the password — then a smart contract can authorize wallet recovery with no intermediary.

The key technical enabler: Poseidon hashing and the BN254 elliptic curve are natively supported on both EVM (precompiled contracts) and Solana (alt_bn128 syscalls). This means a single circuit can generate proofs that verify on both chains.

How It Works

Setup (during wallet creation)

User picks a recovery password
       ↓
Generate random 128-bit salt
       ↓
commitment = Poseidon(Poseidon(password), salt)
       ↓
Store salt in device keychain (iOS Keychain / Android Keystore)
Store commitment on-chain (Base + Solana)

The password never leaves the device. The salt never touches the blockchain. Only the commitment — a hash of a hash — is stored on-chain.

Recovery (on a new device)

User enters recovery password + salt (from backup)
       ↓
Generate Groth16 ZK proof:
  "I know password and salt such that
   Poseidon(password, salt) == on-chain commitment"
       ↓
Submit proof to smart contract
       ↓
24-hour timelock starts (original owner can cancel)
       ↓
After timelock: wallet ownership transfers to new address

The Circuit

The entire ZK circuit is 65 lines of Circom:

pragma circom 2.1.6;
include "circomlib/circuits/poseidon.circom";

template PasswordRecover() {
    // Private inputs (never revealed)
    signal input password;   // Poseidon hash of raw password bytes
    signal input salt;       // 128-bit random from device storage

    // Public inputs (verified on-chain)
    signal input commitment; // On-chain: Poseidon(password, salt)
    signal input newAddress; // Recovery target address
    signal input chainId;    // 8453 = Base, 0 = Solana
    signal input nonce;      // Anti-replay counter

    // Core constraint: hash must match commitment
    component hasher = Poseidon(2);
    hasher.inputs[0] <== password;
    hasher.inputs[1] <== salt;
    hasher.out === commitment;

    // Bind public inputs to the proof
    signal newAddressSq;
    newAddressSq <== newAddress * newAddress;
    signal chainIdSq;
    chainIdSq <== chainId * chainId;
    signal nonceSq;
    nonceSq <== nonce * nonce;
}

component main {public [commitment, newAddress, chainId, nonce]}
  = PasswordRecover();

~241 constraints. Proving time: under 3 seconds on an iPhone 12 or later.

That's the entire cryptographic core. Everything else is smart contract safety rails.

Security Model

A password-based system inherits dictionary attack risk. We mitigate this with three on-chain mechanisms:

1. Rate Limiting

Attempt 1: no delay
Attempt 2: 1 hour cooldown
Attempt 3: 2 hours cooldown
Attempt 4: 3 hours cooldown
Attempt 5: permanent lock

After 5 failed attempts, the recovery is permanently locked. An attacker gets 5 guesses, spaced over 10+ hours. Dictionary attacks are economically infeasible.

2. Timelock

Every recovery has a 24-hour waiting period. If you still have access to your wallet, you can cancel any fraudulent recovery attempt during this window.

3. Nonce Binding

Each proof is bound to a specific newAddress, chainId, and nonce. This prevents:

  • Replay attacks — proof can't be reused (nonce increments)
  • Cross-chain transplant — proof for Base can't be replayed on Solana
  • Front-running — proof is bound to a specific recovery address

Cross-Chain: One Circuit, Two Chains

This is the part we're most excited about. The same .circom file compiles to verifiers for both Solidity and Solana:

ChainVerifierPrecompile
Base (EVM)Groth16Verifier.solecPairing (EIP-197)
SolanaAnchor program (Rust)sol_alt_bn128_pairing

A user who sets up recovery on Base automatically has recovery on Solana — same password, same commitment, same proof. The chainId public input prevents cross-chain replay while allowing the same setup to work everywhere.

This is what ZK proofs look like as a cross-chain interoperability primitive: not bridging tokens, but bridging identity verification.

Prior Art

SystemSecretZK On-ChainSelf-CustodyCross-Chain
OursPasswordGroth16YesEVM + Solana
ArgentGuardiansNoPartialNo
SafeMulti-sigNoYesNo
zkSocialRecoveryGuardian addrGroth16YesEVM only
ZeroWalletPasswordOff-chainNo (server)No
Privy/Web3AuthMPC sharesNoNoMulti (custodial)

Honest Tradeoffs

  • Password entropy matters. "password123" hashes to a valid commitment but provides no security. We enforce 8+ chars and encourage passphrases.
  • Salt backup is required. Stored in device keychain. If you lose your device AND seed phrase, you need the salt + password to recover.
  • Groth16 requires a trusted setup. We use the Hermez phase-1 ceremony (72 contributors) and plan a protocol-specific phase-2.
  • Solana verification is MVP. The Solana program validates proof structure but doesn't yet call sol_alt_bn128_pairing. In progress via groth16-solana.

Try It

ZK password recovery is built into the pooter world mobile app. During wallet creation, you're prompted to set a recovery password. The commitment is registered on-chain, and you can recover from any device.

The code is open source:

  • Circuit (Circom)
  • EVM Contract (Solidity)
  • Solana Program (Anchor)
  • SDK (TypeScript)

Built by pooter.world — the morality browser. We build tools for verifiable reputation on the open internet.