pooter.world · March 25, 2026
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:
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.
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.
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.
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 addressThe 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.
A password-based system inherits dictionary attack risk. We mitigate this with three on-chain mechanisms:
Attempt 1: no delay
Attempt 2: 1 hour cooldown
Attempt 3: 2 hours cooldown
Attempt 4: 3 hours cooldown
Attempt 5: permanent lockAfter 5 failed attempts, the recovery is permanently locked. An attacker gets 5 guesses, spaced over 10+ hours. Dictionary attacks are economically infeasible.
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.
Each proof is bound to a specific newAddress, chainId, and nonce. This prevents:
This is the part we're most excited about. The same .circom file compiles to verifiers for both Solidity and Solana:
| Chain | Verifier | Precompile |
|---|---|---|
| Base (EVM) | Groth16Verifier.sol | ecPairing (EIP-197) |
| Solana | Anchor 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.
| System | Secret | ZK On-Chain | Self-Custody | Cross-Chain |
|---|---|---|---|---|
| Ours | Password | Groth16 | Yes | EVM + Solana |
| Argent | Guardians | No | Partial | No |
| Safe | Multi-sig | No | Yes | No |
| zkSocialRecovery | Guardian addr | Groth16 | Yes | EVM only |
| ZeroWallet | Password | Off-chain | No (server) | No |
| Privy/Web3Auth | MPC shares | No | No | Multi (custodial) |
sol_alt_bn128_pairing. In progress via groth16-solana.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:
Built by pooter.world — the morality browser. We build tools for verifiable reputation on the open internet.