ETH Withdrawal Guide

import { createPublicClient, createWalletClient, http, parseAbi, type Hash, type Hex } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { blast, mainnet } from 'viem/chains';
import { getWithdrawals, publicActionsL1, publicActionsL2, walletActionsL1 } from 'viem/op-stack';

// Any Ethereum account with ETH for gas can prove and finalize.
const account = privateKeyToAccount(process.env.PRIVATE_KEY as Hex);

const publicClientL1 = createPublicClient({ chain: mainnet, transport: http(process.env.L1_RPC_URL) })
  .extend(publicActionsL1());
const walletClientL1 = createWalletClient({ account, chain: mainnet, transport: http(process.env.L1_RPC_URL) })
  .extend(walletActionsL1());
const publicClientL2 = createPublicClient({ chain: blast, transport: http() })
  .extend(publicActionsL2());

async function prove(l2TxHash: Hash) {
  const receipt = await publicClientL2.getTransactionReceipt({ hash: l2TxHash });
  const [withdrawal] = getWithdrawals(receipt);

  // Prove against the latest L2 output posted to Ethereum. Any output at or after the withdrawal's
  // block works, and public Blast RPCs only serve storage proofs for recent blocks.
  const latestL2Block = await publicClientL1.readContract({
    address: blast.contracts.l2OutputOracle[mainnet.id].address,
    abi: parseAbi(['function latestBlockNumber() view returns (uint256)']),
    functionName: 'latestBlockNumber',
  });
  const output = await publicClientL1.getL2Output({ l2BlockNumber: latestL2Block, targetChain: blast });

  const args = await publicClientL2.buildProveWithdrawal({ output, withdrawal });
  return walletClientL1.proveWithdrawal(args);
}

async function finalize(l2TxHash: Hash) {
  const receipt = await publicClientL2.getTransactionReceipt({ hash: l2TxHash });
  const [withdrawal] = getWithdrawals(receipt);
  const portal = blast.contracts.portal[mainnet.id].address;

  // ETH is paid out of Blast's ETH withdrawal queue, so the portal needs the queue checkpoint (hintId)
  // for this withdrawal's request. The requestId was assigned when the withdrawal was proven.
  const [, , , requestId] = await publicClientL1.readContract({
    address: portal,
    abi: parseAbi(['function provenWithdrawals(bytes32) view returns (bytes32, uint128, uint128, uint256)']),
    functionName: 'provenWithdrawals',
    args: [withdrawal.withdrawalHash],
  });
  const ethYieldManager = {
    address: '0x98078db053902644191f93988341E31289E1C8FE',
    abi: parseAbi([
      'function getLastCheckpointId() view returns (uint256)',
      'function findCheckpointHint(uint256 requestId, uint256 start, uint256 end) view returns (uint256)',
    ]),
  } as const;
  const lastCheckpointId = await publicClientL1.readContract({ ...ethYieldManager, functionName: 'getLastCheckpointId' });
  const hintId = await publicClientL1.readContract({
    ...ethYieldManager,
    functionName: 'findCheckpointHint',
    args: [requestId, 1n, lastCheckpointId],
  });
  if (hintId === 0n) throw new Error('The ETH withdrawal queue has not processed this withdrawal yet');

  // Blast's portal takes the hintId before the withdrawal, so call it directly instead of using viem's
  // finalizeWithdrawal.
  const finalizeCall = {
    address: portal,
    abi: parseAbi([
      'struct WithdrawalTransaction { uint256 nonce; address sender; address target; uint256 value; uint256 gasLimit; bytes data; }',
      'function finalizeWithdrawalTransaction(uint256 hintId, WithdrawalTransaction _tx)',
    ]),
    functionName: 'finalizeWithdrawalTransaction',
    args: [hintId, withdrawal],
  } as const;

  // The portal reverts with "SafeCall: Not enough gas" if the gas limit is too low. 900,000 is enough for a
  // withdrawal initiated with _minGasLimit 200000; increase it if you used a higher _minGasLimit.
  return walletClientL1.writeContract({ ...finalizeCall, gas: 900_000n });
}

L2OutputOracle.latestBlockNumber() >= l2BlockNumber

(bytes32 outputRoot, uint128 timestamp, uint128 l2OutputIndex, uint256 requestId)
    = OptimismPortal.provenWithdrawals(withdrawalHash);

block.timestamp >= timestamp + L2OutputOracle.FINALIZATION_PERIOD_SECONDS()

ETHYieldManager.getLastFinalizedRequestId() >= requestId

OptimismPortal.finalizedWithdrawals(withdrawalHash) == true