USDB Withdrawal Guide

import {
  createPublicClient,
  createWalletClient,
  encodeFunctionData,
  http,
  isAddressEqual,
  parseAbi,
  parseEventLogs,
  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);

  // Blast's portal takes a hintId before the withdrawal, so call it directly instead of using viem's
  // finalizeWithdrawal. The hintId is only used for ETH withdrawals; for USDB it is always 0.
  const hintId = 0n;
  const finalizeCall = {
    address: blast.contracts.portal[mainnet.id].address,
    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. 1,600,000 is enough for a
  // withdrawal initiated with _minGasLimit 800000; increase it if you used a higher _minGasLimit.
  return walletClientL1.writeContract({ ...finalizeCall, gas: 1_600_000n });
}

const usdYieldManager = {
  address: '0xa230285d5683C74935aD14c446e137c8c8828438',
  abi: parseAbi([
    'event WithdrawalRequested(uint256 indexed requestId, address indexed requestor, address indexed recipient, uint256 amount)',
    'function getLastFinalizedRequestId() view returns (uint256)',
    'function getLastCheckpointId() view returns (uint256)',
    'function findCheckpointHint(uint256 requestId, uint256 start, uint256 end) view returns (uint256)',
    'function claimWithdrawal(uint256 requestId, uint256 hintId) returns (bool)',
  ]),
} as const;

// Builds the claim call from the hash of your finalize transaction on Ethereum. The claim must be sent
// by the recipient, so submit the returned call from your L1 recipient contract.
async function buildClaim(l1FinalizeTxHash: Hash) {
  // Finalizing created a DAI withdrawal request for your recipient: find its requestId.
  const receipt = await publicClientL1.getTransactionReceipt({ hash: l1FinalizeTxHash });
  const [request] = parseEventLogs({
    abi: usdYieldManager.abi,
    eventName: 'WithdrawalRequested',
    logs: receipt.logs.filter((log) => isAddressEqual(log.address, usdYieldManager.address)),
  });
  const { requestId, recipient } = request.args;

  const lastFinalizedRequestId = await publicClientL1.readContract({
    ...usdYieldManager,
    functionName: 'getLastFinalizedRequestId',
  });
  if (lastFinalizedRequestId < requestId) throw new Error('The USD withdrawal queue has not processed this request yet');

  const lastCheckpointId = await publicClientL1.readContract({ ...usdYieldManager, functionName: 'getLastCheckpointId' });
  const hintId = await publicClientL1.readContract({
    ...usdYieldManager,
    functionName: 'findCheckpointHint',
    args: [requestId, 1n, lastCheckpointId],
  });

  return {
    from: recipient,
    to: usdYieldManager.address,
    data: encodeFunctionData({ abi: usdYieldManager.abi, functionName: 'claimWithdrawal', args: [requestId, hintId] }),
  };
}

L2OutputOracle.latestBlockNumber() >= l2BlockNumber

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

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

OptimismPortal.finalizedWithdrawals(withdrawalHash) == true

USDYieldManager.getLastFinalizedRequestId() >= requestId

USDYieldManager.getWithdrawalStatus([requestId])
// returns (amount, recipient, timestamp, isFinalized, isClaimed) for each request