Quick end-to-end test on testnet

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.30;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract TestToken is ERC20 {
    constructor() ERC20("Test Token", "TST") {
        _mint(msg.sender, 1_000_000 * 10 ** decimals());
    }

    function decimals() public pure override returns (uint8) {
        return 6;
    }

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

import { createPublicClient, createWalletClient, http, defineChain } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { sepolia } from 'viem/chains'
import {
  publicActionsL1,
  publicActionsL2,
  walletActionsL1,
  getWithdrawals,
} from 'viem/op-stack'

const whitechainSepolia = defineChain({
  id: 1874,
  name: 'Whitechain Sepolia',
  nativeCurrency: { name: 'WhiteBIT Token', symbol: 'WBT', decimals: 18 },
  rpcUrls: { default: { http: ['https://rpc.testnet.whitechain.io'] } },
  sourceId: 11155111,
  contracts: {
    portal: { 11155111: { address: '0xff9b597b0781457ae6aa7256ca5ed5839bf7d0c3' } },
    disputeGameFactory: { 11155111: { address: '0xfaa2faa8912c069c01abc169c33713c79027c833' } },
    l1StandardBridge: { 11155111: { address: '0x0c50be539ab5d72d226038928f2eb25100899ded' } },
  },
})

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`)

const L1_RPC = 'https://ethereum-sepolia-rpc.publicnode.com'
const publicL1 = createPublicClient({ chain: sepolia, transport: http(L1_RPC) }).extend(publicActionsL1())
const walletL1 = createWalletClient({ account, chain: sepolia, transport: http(L1_RPC) }).extend(walletActionsL1())
const publicL2 = createPublicClient({ chain: whitechainSepolia, transport: http() }).extend(publicActionsL2())

const L2_WITHDRAWAL_TX = process.env.L2_WITHDRAWAL_TX as `0x${string}`
const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms))

async function main() {
  const receipt = await publicL2.getTransactionReceipt({ hash: L2_WITHDRAWAL_TX })
  const [withdrawal] = getWithdrawals(receipt)

  // Wait for a dispute game that covers the withdrawal's L2 block, then prove.
  const { output, withdrawal: w } = await publicL1.waitToProve({ receipt, targetChain: whitechainSepolia })
  const proveArgs = await publicL2.buildProveWithdrawal({ output, withdrawal: w })
  const proveHash = await walletL1.proveWithdrawal(proveArgs)
  const proveReceipt = await publicL1.waitForTransactionReceipt({ hash: proveHash })
  if (proveReceipt.status !== 'success') throw new Error(`Prove tx reverted: ${proveHash}`)

  // Poll status until both delays elapse (fault-proof chain: not waitToFinalize).
  let status = await publicL1.getWithdrawalStatus({ receipt, targetChain: whitechainSepolia })
  while (status !== 'ready-to-finalize' && status !== 'finalized') {
    await sleep(60_000)
    status = await publicL1.getWithdrawalStatus({ receipt, targetChain: whitechainSepolia })
  }

  // Finalize on L1.
  if (status !== 'finalized') {
    const finalizeHash = await walletL1.finalizeWithdrawal({ targetChain: whitechainSepolia, withdrawal: w })
    const finalizeReceipt = await publicL1.waitForTransactionReceipt({ hash: finalizeHash })
    if (finalizeReceipt.status !== 'success') throw new Error(`Finalize tx reverted: ${finalizeHash}`)
  }

  console.log('withdrawal finalized', withdrawal.withdrawalHash)
}

main()