How do I move assets between Ethereum and a ZK rollup like Linea, and why do withdrawals take hours?

Moving assets between Ethereum and a ZK rollup like Linea through the canonical bridge is asymmetric. A deposit (Ethereum to Linea) arrives in minutes, because Linea only has to see your transaction on Ethereum. A withdrawal (Linea to Ethereum) takes hours, because Ethereum won't release anything until a validity proof covering your transaction has been verified and finalized on L1, and after that you still have to claim the funds in a separate transaction. Third-party bridges are faster because they front you liquidity and take on the waiting themselves.

Linea in brief

Linea is a zkEVM rollup developed by Consensys. Gas is paid in ETH, and it runs Solidity contracts compiled with standard tooling. Its token, LINEA, launched in 2025 and is not used for gas. Alongside the token, Linea introduced a dual burn: part of the network's net ETH fee income is burned as ETH, and the rest is used to buy and burn LINEA. The split and mechanics are set by the Linea organisations, so check the current details if they matter to you.

The canonical bridge is a message service

Everything crossing Linea's canonical bridge is a message. There is a message service contract on each side, L1MessageService on Ethereum and L2MessageService on Linea, with the same core interface:

interface IMessageService {
    // msg.value = value delivered on the other side + _fee
    function sendMessage(address _to, uint256 _fee, bytes calldata _calldata) external payable;
}

A message carries ETH value, optional calldata to execute on the destination, and a fee for whoever claims it there. ETH bridges as the value of a message with empty calldata. ERC-20s go through a TokenBridge contract on each side (you approve it, then call bridgeToken), which locks the token on the origin chain and sends a message telling the other side to mint or release the matching amount.

Every message is delivered in two steps: it is sent on the origin chain, and later claimed on the destination chain once the destination can verify it. Claiming is a normal transaction, so someone has to pay gas for it.

Deposits: Ethereum to Linea

1. You call the bridge on Ethereum. The L1 message service records the message hash and emits an event.
2. After the L1 block is sufficiently confirmed, Linea's coordinator anchors the message hashes on L2 by writing them into the L2 message service.
3. The message is claimed on Linea: the L2 contract checks that the hash was anchored and executes it, crediting ETH or minting the bridged token.

Nothing needs proving here. L2 is simply reading L1, which it already trusts, so the delay is L1 confirmation plus anchoring, typically minutes. Deposits made through the official bridge are normally claimed on Linea for you by Linea's postman service, either paid out of the fee in the message or sponsored by Linea for simple deposits under a gas limit. If a deposit ever sits unclaimed, you can claim it yourself on L2.

Withdrawals: Linea to Ethereum

The reverse direction is where the time goes.

1. Send. You call sendMessage on the L2 message service (or the L2 TokenBridge). The L2 contract enforces a minimum fee, and the message hash is recorded in L2 state.
2. Prove and finalize. Linea's blocks are grouped into batches, execution proofs are generated for them, and those proofs are aggregated into a single proof covering many batches. The coordinator submits the aggregated proof to the L1 rollup contract, which verifies it and finalizes the new state, along with a Merkle root of all L2-to-L1 messages in that range.
3. Claim. You submit your message plus a Merkle proof to L1MessageService (claimMessageWithProof), which checks it against the finalized root and releases the ETH or tokens.

Step 2 is why it takes hours. Generating zkEVM proofs is expensive, and verifying a proof on Ethereum costs a significant amount of gas, so the operator proves large ranges of blocks at once rather than proving each one as it comes. Your withdrawal waits until the range containing it is proven and finalized. Linea's documentation has quoted windows ranging from several hours to around a day; the bridge interface shows the current estimate.

Step 3 usually falls to you. On Ethereum, gas is expensive enough that L2-to-L1 messages are generally not auto-claimed: the bridge UI shows the withdrawal as ready to claim, and you sign an L1 transaction and pay L1 gas. Anyone can submit the claim, since the funds always go to the _to address in the message, and if you attached a fee above the minimum, a relayer may claim it and keep that fee. A withdrawal you never claim stays in the L1 contract indefinitely; it is not lost, but it isn't in your wallet either.

The L1 message service also enforces a rate limit on how much ETH can be withdrawn per period, as a safety measure. Ordinary users rarely hit it, but very large withdrawals can be delayed by it.

Sending a withdrawal with ethers

A minimal ETH withdrawal from Linea using ethers v6. Take the message service address from Linea's official docs rather than copying it from elsewhere:

import { ethers } from "ethers";

const abi = [
  "function sendMessage(address _to, uint256 _fee, bytes _calldata) payable",
  "function minimumFeeInWei() view returns (uint256)",
];

const provider = new ethers.JsonRpcProvider("https://rpc.linea.build");
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY!, provider);
const messageService = new ethers.Contract(process.env.L2_MESSAGE_SERVICE!, abi, wallet);

const amount = ethers.parseEther("0.05");
const fee: bigint = await messageService.minimumFeeInWei();

// value sent = amount to receive on Ethereum + fee kept on Linea
const tx = await messageService.sendMessage(wallet.address, fee, "0x", {
  value: amount + fee,
});
await tx.wait();
console.log("withdrawal sent:", tx.hash);

After finalization, claim through the bridge UI or build the proof and call claimMessageWithProof with the Linea SDK.

Why optimistic rollups are slower still

On an optimistic rollup such as Arbitrum One or OP Mainnet, no proof is ever produced unless there is a dispute. A withdrawal is final only once the challenge window, about seven days, has passed without a successful challenge. A ZK rollup replaces that week of waiting with the time needed to generate and verify a proof, which is why "hours" is the ZK answer and "a week" is the optimistic one. Both still need an L1 claim or finalize transaction at the end.

	Linea (ZK)	Optimistic rollup
Deposit	Minutes, usually auto-claimed	Minutes
Withdrawal gated by	Proof verified and finalized on L1	Seven-day challenge window
Typical canonical withdrawal	Hours	About a week
Final step	Claim on L1 with Merkle proof	Execute on L1 (OP Stack also needs a prove step first)

Fast bridges and their trade-offs

Third-party bridges such as Across, and the aggregators that route through them, get you funds on Ethereum in minutes. In the common intent model, a relayer pays you on the destination chain from its own funds and is reimbursed later, often via the slow canonical path, charging a fee for the capital and risk.

That speed is a different trust model:

• You rely on the bridge's contracts and on whatever verifies that the relayer filled your order (an optimistic oracle, a validator set or a committee), not only on Linea's proofs.
• Lock-and-mint bridges give you their own wrapped token on the destination chain, which is only as good as that bridge. A bridge hack can leave it unbacked.
• Liquidity is finite, so large transfers may be slow, expensive or refused.

For large amounts where waiting is acceptable, the canonical bridge carries the fewest extra assumptions.

Token addresses differ on L2

A token on Linea is a separate contract at a different address from its Ethereum original. The canonical TokenBridge deploys its own bridged token on first use, and other bridges may deploy their own versions of the same asset. Those versions aren't interchangeable: a DEX pool or lending market will list one specific contract.

USDC is the usual trap. Linea's USDC has changed form over time, from a bridged token towards Circle-issued native USDC that moves across chains through Circle's CCTP. Before you bridge stablecoins or hard-code an address, check the token list in Linea's docs and Circle's published addresses.

Also check the destination address itself. An EOA exists on every EVM chain, but a smart-contract wallet such as a Safe exists only on chains where it has been deployed. Withdrawing to a contract address that doesn't exist on Ethereum can make funds unrecoverable.

Summary

1. Deposits need no proof: L1 messages are anchored on Linea and claimed, usually automatically, within minutes.
2. Withdrawals wait for Linea to prove and finalize the relevant blocks on Ethereum, which takes hours, then need a separate L1 claim that you typically pay for.
3. Optimistic rollups wait out a week-long challenge window instead.
4. Fast bridges trade extra trust in their contracts and relayers for speed.
5. Verify token contract addresses on each chain, especially for USDC, and make sure the receiving address exists on the destination.