Detailed Instructions

To begin, the user must call the withdraw or initiateWithdrawal function on the L2 bridge contract (e.g., OptimismPortal on OP Mainnet). This transaction burns the L2 tokens or locks the native asset, generating a withdrawal proof.

• Sub-step 1: Construct the transaction with the target L1 recipient address and the withdrawal amount.
• Sub-step 2: Submit the transaction and pay L2 gas fees. The transaction will emit a WithdrawalInitiated event.
• Sub-step 3: Record the transaction hash and the emitted event logs. The withdrawal hash is a critical identifier for the subsequent challenge period.

solidityCopy
// Example call to OptimismPortal
IOptimismPortal(L2_BRIDGE_ADDRESS).withdraw(
    _to, // L1 recipient address
    _amount // Amount to withdraw
);

Tip: Always verify the transaction succeeded on the L2 block explorer and save the withdrawal hash from the event logs for tracking.

Detailed Instructions

After initiation, the withdrawal enters the fault proof window (typically 7 days). This is the core security mechanism of optimistic rollups, allowing verifiers to submit fraud proofs if the L2 state transition was invalid.

• Sub-step 1: Monitor the elapsed time since the L2 block containing your withdrawal was finalized. The delay is fixed per network (e.g., 7 days for Arbitrum One, ~1 week for OP Mainnet).
• Sub-step 2: Understand that no action is required during this period unless you are a validator challenging state. The delay is enforced at the protocol level by the L1 rollup contract.
• Sub-step 3: Track the status using a block explorer or bridge UI, which will show a countdown until the withdrawal is ready for relay.

Tip: This period is non-negotiable and a fundamental security trade-off for scalability. Fast withdrawal services exist but involve third-party liquidity providers and fees.

Detailed Instructions

Once the challenge period elapses, the user (or a relayer) must submit a withdrawal proof to the L1 bridge contract. This proves the withdrawal transaction was included and finalized on L2.

• Sub-step 1: Fetch the Merkle proof (output root, inclusion proof) for your withdrawal transaction. This can be generated via the rollup node's RPC (eth_getProof) or a bridge SDK.
• Sub-step 2: Call the proveWithdrawalTransaction function on the L1 bridge contract (e.g., OptimismPortal on Ethereum). Pass the L2 transaction data and the Merkle proof.
• Sub-step 3: Pay the L1 gas fee for this proof transaction. Successful execution stores the proof, making the withdrawal proven and starting a short finalization timer.

solidityCopy
// Example proving a withdrawal on L1
L1OptimismPortal.proveWithdrawalTransaction(
    _tx, // Withdrawal transaction data
    _l2OutputIndex, // Index of the L2 output root
    _outputRootProof, // Merkle proof components
    _withdrawalProof // Inclusion proof
);

Tip: This step can be gas-intensive. Public relayers often batch proofs for efficiency.

Detailed Instructions

After a short finalization window (e.g., 24 hours on OP Mainnet post-proof), the withdrawal can be completed. This step transfers the asset from the bridge custody to the user's L1 address.

• Sub-step 1: Wait for the finalization period to pass after the proof was accepted. This is a second, shorter delay for added security.
• Sub-step 2: Call the finalizeWithdrawalTransaction function on the same L1 bridge contract, passing the original withdrawal transaction data.
• Sub-step 3: The contract validates the proof is finalized and then releases the locked ETH or mints the canonical token on L1 to the recipient address.

solidityCopy
// Example finalizing a withdrawal
L1OptimismPortal.finalizeWithdrawalTransaction(_tx);

Tip: Always check that the recipient address on L1 has sufficient gas (ETH) to pay for the finalization transaction, which is executed on the Ethereum network.