Recover an account with your own recovery address

// Recover a Farcaster FID using its onchain recovery address.
//
//   npm install
//   cp .env.example .env        # set FID and RECOVERY_MNEMONIC
//   npm run dry-run             # checks, generates + saves NEW_MNEMONIC, simulates. Sends nothing.
//   npm start                   # same, then broadcasts.
import { chmodSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
import { dirname, join } from 'node:path';
import { fileURLToPath } from 'node:url';
import { createPublicClient, createWalletClient, formatEther, http, parseAbi } from 'viem';
import { english, generateMnemonic, mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
import { optimism } from 'viem/chains';

const ID_REGISTRY = '0x00000000Fc6c5F01Fc30151999387Bb99A9f489b';
const ENV_PATH = join(dirname(fileURLToPath(import.meta.url)), '.env');
const SEND = process.argv.includes('--send');

for (const event of ['uncaughtException', 'unhandledRejection']) {
  process.on(event, (e) => {
    console.error(`\nERROR: ${e?.shortMessage ?? e?.message ?? e}\nNothing was sent.`);
    process.exit(1);
  });
}

if (existsSync(ENV_PATH)) process.loadEnvFile(ENV_PATH);
if (!/^\d+$/.test(process.env.FID?.trim() ?? '')) throw new Error('Set FID in .env to your Farcaster ID (a number, e.g. FID=1234).');
const FID = BigInt(process.env.FID.trim());
const RPC = process.env.OP_RPC_URL?.trim() || 'https://mainnet.optimism.io';

const abi = parseAbi([
  'function custodyOf(uint256 fid) view returns (address)',
  'function recoveryOf(uint256 fid) view returns (address)',
  'function idOf(address owner) view returns (uint256)',
  'function nonces(address owner) view returns (uint256)',
  'function recover(address from, address to, uint256 deadline, bytes sig)',
]);

const pub = createPublicClient({ chain: optimism, transport: http(RPC) });
const read = (functionName, args) => pub.readContract({ address: ID_REGISTRY, abi, functionName, args });
const same = (a, b) => a.toLowerCase() === b.toLowerCase();

const from = await read('custodyOf', [FID]);
const recoveryAddr = await read('recoveryOf', [FID]);
if (same(from, '0x0000000000000000000000000000000000000000')) throw new Error(`fid ${FID} does not exist onchain.`);
console.log(`fid=${FID} custody=${from} recovery=${recoveryAddr}`);
console.log(`Only the recovery wallet ${recoveryAddr} can run this recovery. It also pays the gas on Optimism.`);

// 1. Recovery wallet: the only address allowed to call recover() for this fid. It pays the gas.
let recoveryAccount;
const recoveryMnemonic = process.env.RECOVERY_MNEMONIC?.trim();
const recoveryPrivateKey = process.env.RECOVERY_PRIVATE_KEY?.trim();
if (recoveryMnemonic) recoveryAccount = mnemonicToAccount(recoveryMnemonic);
else if (recoveryPrivateKey) recoveryAccount = privateKeyToAccount(recoveryPrivateKey);

// 2. New custody wallet. Same derivation the Farcaster app uses (m/44'/60'/0'/0/0, 12 english words),
//    so this phrase can be imported via Sign In -> Seed phrase afterwards.
//    Generated once and saved into .env so a crash or retry never loses it.
let newMnemonic = process.env.NEW_MNEMONIC?.trim();
if (SEND && !recoveryAccount) throw new Error('`npm start` needs RECOVERY_MNEMONIC (or RECOVERY_PRIVATE_KEY) in .env.');
if (!recoveryAccount) {
  newMnemonic ||= generateMnemonic(english);
  console.log('\nNo RECOVERY_MNEMONIC / RECOVERY_PRIVATE_KEY in .env: preflight only.');
} else if (!newMnemonic) {
  newMnemonic = generateMnemonic(english);
  saveNewMnemonic(newMnemonic);
  console.log('\n=== NEW FARCASTER SEED PHRASE. Write it down. It becomes your account. ===');
  console.log(newMnemonic);
  console.log(`=== Also saved to ${ENV_PATH} as NEW_MNEMONIC. ===\n`);
} else {
  console.log('Using NEW_MNEMONIC from .env.');
}
const newAccount = mnemonicToAccount(newMnemonic);
console.log(`new custody address: ${newAccount.address}`);

if (same(from, newAccount.address)) {
  console.log(`\nAlready recovered: fid ${FID} belongs to NEW_MNEMONIC. Sign in to the Farcaster app with it.`);
  process.exit(0);
}
if (recoveryAccount && !same(recoveryAccount.address, recoveryAddr)) {
  throw new Error(
    `Your key derives ${recoveryAccount.address}, but the onchain recovery address is ${recoveryAddr}. Wrong seed or derivation path.`,
  );
}
const existingFid = await read('idOf', [newAccount.address]);
if (existingFid !== 0n) throw new Error(`${newAccount.address} already owns fid ${existingFid}. Clear NEW_MNEMONIC in .env to generate a fresh one.`);

const balance = await pub.getBalance({ address: recoveryAddr });
console.log(`recovery wallet ${recoveryAddr} ETH on Optimism: ${formatEther(balance)} (pays the gas)`);

// 3. Consent signature from the NEW custody key: Transfer(fid, to, nonce, deadline).
const nonce = await read('nonces', [newAccount.address]);
const deadline = BigInt(Math.floor(Date.now() / 1000) + 60 * 60);
const sig = await newAccount.signTypedData({
  domain: { name: 'Farcaster IdRegistry', version: '1', chainId: 10, verifyingContract: ID_REGISTRY },
  types: {
    Transfer: [
      { name: 'fid', type: 'uint256' },
      { name: 'to', type: 'address' },
      { name: 'nonce', type: 'uint256' },
      { name: 'deadline', type: 'uint256' },
    ],
  },
  primaryType: 'Transfer',
  message: { fid: FID, to: newAccount.address, nonce, deadline },
});

// 4. Simulate recover() as the recovery wallet. A revert here means nothing is sent.
const { request } = await pub.simulateContract({
  address: ID_REGISTRY,
  abi,
  functionName: 'recover',
  args: [from, newAccount.address, deadline, sig],
  account: recoveryAccount ?? recoveryAddr,
});
console.log('simulation OK: recover() would succeed');

if (!recoveryAccount) {
  console.log('\nPreflight passed. Fill RECOVERY_MNEMONIC in .env and run `npm run dry-run` again.');
  process.exit(0);
}
if (balance === 0n) throw new Error(`Send a little ETH on Optimism to ${recoveryAddr} for gas ($0.05 worth is plenty, one recovery costs well under $0.01), then re-run.`);
if (!SEND) {
  console.log(`\nDry run complete. Nothing was sent.\nThis would move fid ${FID} to ${newAccount.address}.`);
  console.log('Once the NEW seed phrase is written down, run:  npm start');
  process.exit(0);
}

// 5. Broadcast and verify.
const wallet = createWalletClient({ account: recoveryAccount, chain: optimism, transport: http(RPC) });
const hash = await wallet.writeContract(request);
console.log(`sent: https://optimistic.etherscan.io/tx/${hash}`);
const receipt = await pub.waitForTransactionReceipt({ hash });
if (receipt.status !== 'success') throw new Error('tx reverted. Run `npm start` again.');
const custodyNow = await read('custodyOf', [FID]);
if (!same(custodyNow, newAccount.address)) throw new Error(`custody is ${custodyNow}, expected ${newAccount.address}`);
console.log(`\nDONE. fid ${FID} custody is now ${custodyNow}.`);
console.log('Next: Farcaster app -> Sign In -> Seed phrase -> enter NEW_MNEMONIC. It can take a minute for the app to see the transfer.');

function saveNewMnemonic(mnemonic) {
  const line = `NEW_MNEMONIC="${mnemonic}"`;
  let text = existsSync(ENV_PATH) ? readFileSync(ENV_PATH, 'utf8') : '';
  text = text.replace(/^NEW_MNEMONIC=.*(\r?\n|$)/gm, '');
  text += (text && !text.endsWith('\n') ? '\n' : '') + line + '\n';
  writeFileSync(ENV_PATH, text, { mode: 0o600 });
  chmodSync(ENV_PATH, 0o600);
}