Arbitrum Bridge Setup: 10 Steps, 40 Min [2026]

Ethereum mainnet gas fees have settled into a strange rhythm in 2026: cheap during quiet hours, brutal the moment any popular mint or airdrop hits. A basic ETH transfer on Layer 1 now runs $6 to $10, a Uniswap-style swap costs $15 to $30, and adding liquidity to a pool can hit $40 to $80 in gas alone, according to 2026 gas-tracking data. Move the same three actions to Arbitrum, Base, or Optimism and the numbers drop to cents: $0.02 to $0.10 for a transfer, $0.15 to $0.50 for a swap, under $1.20 to add liquidity. That’s a 90-99% cost cut for identical on-chain actions.

This tutorial walks through bridging ETH to Arbitrum step by step, covers how Base and Optimism compare along the way, and ends with a working Node.js script that checks live gas prices across all four networks and estimates your savings before you move a single dollar. We’ll also cover what went wrong in the Taiko bridge exploit from June 2026, because the mistakes behind it are exactly the kind a careful setup process avoids.

You don’t need to be a developer to follow along. The wallet setup and bridging steps work for anyone with a browser extension wallet and a few dollars of ETH. The scripting sections toward the end are aimed at readers who want to automate gas checks or deploy a contract, and they’re written so you can skip them entirely and still come away with a working bridge setup. Either way, by the end you’ll know how to move funds onto Arbitrum, verify they arrived, bring them back, and avoid the handful of mistakes that account for most first-time bridging headaches.

Why Bridging to Layer 2 Became Essential in 2026

Arbitrum One remains the largest Ethereum Layer 2 by total value locked, sitting in the roughly $15 billion to $17 billion range through mid-2026 and holding close to 38% of all L2 DeFi value, per 2026 L2 comparison data. Base has grown into the busiest network by activity, processing an estimated 37% of all Layer 2 transactions while holding around $7 billion to $13 billion in TVL, close to 30% of L2 DeFi share. Optimism trails both by total value locked, generally cited in the $1.3 billion to $6.4 billion range, but it anchors the “Superchain” architecture that Base and a growing list of other OP Stack chains build on.

Combined Layer 2 TVL has been genuinely volatile this year. A mid-July 2026 snapshot put the total near $42 billion, with Arbitrum at $16.85 billion (up 11.91% in seven days), Base at $6.87 billion (up 7.53%), and Optimism at $6.42 billion (up 16.55%). Two weeks later, a separate late-July report measured total L2 TVL crashing to roughly $5 billion, a two-year low, with the same three networks accounting for 96% of that shrunken total. Different providers count TVL differently, and the discrepancy itself is a useful lesson: don’t anchor a bridging decision to a single TVL number pulled from one dashboard. Check a live tracker like L2Beat right before you move funds, not a screenshot from a month-old article.

What hasn’t been volatile is the fee gap. Across every gas comparison run in 2026, Layer 2 rollups have consistently delivered 90% to 99% lower fees than Ethereum mainnet for the same action. That gap is why bridging has gone from an advanced-user trick to a default step for anyone doing more than the occasional mainnet transaction.

It’s worth being specific about who this saves the most money for. If you swap tokens a few times a month, mainnet fees are annoying but survivable. If you’re providing liquidity, running a bot, minting NFTs, or interacting with a protocol daily, mainnet gas alone can eat a meaningful share of your returns before you factor in slippage or strategy performance. That’s the audience this tutorial is really written for: anyone whose on-chain activity is frequent enough that a 90%+ fee cut changes the math, not just the mood.

Action	Ethereum L1	Arbitrum	Base	Optimism
Simple ETH transfer	$6 – $10	$0.03 – $0.08	$0.02 – $0.05	$0.05 – $0.10
Uniswap-style swap	$15 – $30	$0.20 – $0.40	$0.15 – $0.30	$0.25 – $0.50
Add LP liquidity	$40 – $80	$0.50 – $1.00	$0.40 – $0.80	$0.60 – $1.20

How Layer 2 Rollups Actually Work

Arbitrum, Base, and Optimism are all optimistic rollups. They execute transactions off the Ethereum mainnet, batch the results, and post compressed transaction data back to L1 so Ethereum still acts as the ultimate source of truth. “Optimistic” means the network assumes each batch is valid by default and only runs a fraud-proof check if someone challenges it during a set window, typically around seven days. That challenge period is exactly why withdrawing funds back to mainnet takes longer than depositing onto the rollup, a detail that trips up a lot of first-time bridgers and one we’ll walk through directly.

The alternative design, zero-knowledge rollups, proves validity mathematically with a cryptographic proof at the time of the batch, which removes the need for a challenge window but adds proving overhead. Arbitrum, Base, and Optimism don’t use this model for their main chains, which is why the withdrawal delay matters so much for anyone bridging assets on those three networks specifically. Base runs on the OP Stack, the same open-source codebase as Optimism, which is part of why the two share security assumptions and why Coinbase (which operates Base) and the Optimism Collective coordinate closely on the Superchain roadmap.

Prerequisites: What You Need Before You Bridge

You don’t need much to get started, but get each piece right before moving real funds. Budget 30 to 40 minutes for your first full pass through this tutorial, including the deploy-and-test steps.

Tool	Version / Notes	Purpose
MetaMask or another self-custody wallet	Latest version from the official extension store	Holding funds and signing bridge transactions
Node.js	20 LTS or newer	Running the gas-check and dashboard scripts
npm or pnpm	Latest stable release	Installing viem, ethers, and Hardhat
viem	Latest version (npm install viem)	Reading live gas prices from each chain
Hardhat	Latest version (npx hardhat init)	Compiling and deploying a test contract to Arbitrum
A small amount of mainnet ETH	Enough to cover a test transfer plus L1 gas	Funding your first bridge transaction
A block explorer bookmark	Etherscan and Arbiscan (or Basescan / Optimistic Etherscan)	Verifying transactions on both sides of the bridge

One more thing worth doing before Step 1: if you’re bridging anything beyond a test amount, use a wallet you don’t reuse for high-value cold storage. That’s basic operational hygiene for any on-chain activity, not something specific to Layer 2, but it’s worth restating here since this whole tutorial assumes you’re working from an active, funded wallet rather than a long-term holding address.

None of this requires paid tooling. Every RPC endpoint, block explorer, and bridge interface referenced in this tutorial has a free tier that’s more than sufficient for personal use, and the scripts later on run on the free public RPC endpoints for each chain. If you outgrow the public endpoints’ rate limits, that’s usually a sign you’re running enough volume to justify a dedicated RPC provider, not a sign anything in this guide is broken.

Step 1: Choose Your Layer 2 — Arbitrum vs Base vs Optimism

All three networks are EVM-compatible, all three settle to Ethereum, and all three currently offer a similar order-of-magnitude fee reduction. The differences that actually matter come down to what’s built where. Arbitrum One carries the deepest DeFi liquidity of any L2, which matters if you’re planning to lend, borrow, or trade in size. Base has the largest base of consumer-facing apps and the highest transaction count, useful if you’re chasing an ecosystem with the most day-to-day activity and the tightest integration with Coinbase’s on-ramp. Optimism sits behind both by TVL but is the reference implementation for the OP Stack, which several other chains (including Base) are built on, so its governance token and RetroPGF funding model carry outsized influence on the wider Superchain.

Network	Rollup Type	Approx. TVL (2026)	Share of L2 DeFi TVL	Best For
Arbitrum One	Optimistic rollup	~$15B – $17B	~38%	Deepest DeFi liquidity, largest protocol selection
Base	Optimistic rollup (OP Stack)	~$7B – $13B	~30%	Highest transaction volume, consumer apps, Coinbase integration
Optimism (OP Mainnet)	Optimistic rollup (OP Stack)	~$1.3B – $6.4B	~3% – 6%	Superchain-native apps, OP governance and RetroPGF

This tutorial uses Arbitrum for the walkthrough since it’s the largest by TVL, but every step, including the wallet setup, the bridge mechanics, and the deploy script, works the same way on Base and Optimism with different chain IDs and RPC endpoints. We’ll flag those differences as we go.

There’s no rule against running all three. A growing number of active DeFi users hold a small working balance on each L2 rather than picking one permanently, since it means you’re never locked out of a protocol, an airdrop, or a liquidity opportunity that happens to launch on whichever chain you didn’t choose. The setup cost of adding two extra networks to your wallet is a few minutes; the flexibility it buys is worth more than that over a year of active use.

Step 2: Set Up a Dedicated Bridging Wallet

Install MetaMask (or your preferred EVM wallet) and create a fresh account inside it dedicated to L2 activity, separate from any wallet holding long-term savings. This isn’t paranoia, it’s just sound practice for a wallet that will regularly sign transactions and interact with new contracts. Fund it with a small amount of mainnet ETH, enough to cover a test bridge transaction plus L1 gas.

Write down the seed phrase offline and never enter it into a website, a support chat, or a Discord bot. Every legitimate bridge interface only ever asks for a transaction signature through your wallet’s own popup, never for your seed phrase directly.

Step 3: Add Layer 2 Networks to Your Wallet

MetaMask can add Arbitrum, Base, and Optimism automatically the first time you visit their official bridge sites, but it’s worth knowing the raw network parameters, both so you can verify them and so you can add them programmatically if you’re scripting wallet setup for a team. Each network is added through the EIP-3085 wallet_addEthereumChain method.

// Add Arbitrum One to a browser wallet via EIP-3085
const arbitrumOne = {
  chainId: '0xa4b1', // 42161 in decimal
  chainName: 'Arbitrum One',
  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
  rpcUrls: ['https://arb1.arbitrum.io/rpc'],
  blockExplorerUrls: ['https://arbiscan.io'],
};

const base = {
  chainId: '0x2105', // 8453 in decimal
  chainName: 'Base',
  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
  rpcUrls: ['https://mainnet.base.org'],
  blockExplorerUrls: ['https://basescan.org'],
};

const optimism = {
  chainId: '0xa', // 10 in decimal
  chainName: 'OP Mainnet',
  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
  rpcUrls: ['https://mainnet.optimism.io'],
  blockExplorerUrls: ['https://optimistic.etherscan.io'],
};

await window.ethereum.request({
  method: 'wallet_addEthereumChain',
  params: [arbitrumOne],
});

Double-check the chain ID against a source you trust, such as Chainlist or the network’s own documentation, before adding it. A wallet with the wrong RPC endpoint pointed at a chain ID will still let you sign transactions, it just won’t be talking to the network you think it is.

Step 4: Check Gas Prices Before You Move Funds

Ethereum mainnet gas isn’t flat throughout the day, and neither is the L1 data-posting cost that L2 rollups pass on to users. Before bridging, it’s worth pulling live gas prices from each network so you’re not paying a premium during a mainnet congestion spike. Here’s a script using viem, a lightweight TypeScript library for talking to EVM chains, that checks gas prices across all four networks at once.

// check-gas.js
import { createPublicClient, http, formatGwei } from 'viem';
import { mainnet, arbitrum, base, optimism } from 'viem/chains';

const networks = [
  { name: 'Ethereum', chain: mainnet },
  { name: 'Arbitrum', chain: arbitrum },
  { name: 'Base', chain: base },
  { name: 'Optimism', chain: optimism },
];

async function main() {
  for (const net of networks) {
    const client = createPublicClient({ chain: net.chain, transport: http() });
    const gasPrice = await client.getGasPrice();
    console.log(`${net.name.padEnd(10)} ${formatGwei(gasPrice)} gwei`);
  }
}

main();

Run it with node check-gas.js. Expect output roughly like this, though the exact numbers move constantly:

Ethereum   18.42 gwei
Arbitrum   0.0100 gwei
Base       0.0010 gwei
Optimism   0.0009 gwei

Raw gwei on L2s looks almost free because it only reflects the rollup’s own execution gas. The real cost driver on an optimistic rollup is the L1 calldata fee, the cost of posting your transaction’s data back to Ethereum for settlement. That’s a separate line item baked into what your wallet quotes you at signing time, which is why the fee table earlier in this piece is the more useful reference than raw gwei alone.

Step 5: Choose a Bridge — Official vs Third-Party Routes

You have two broad options for moving ETH from mainnet to Arbitrum: the canonical bridge built into the protocol, or a third-party liquidity bridge that fronts you funds on the destination chain instantly and settles behind the scenes. Canonical bridges are the safest default for standard deposits since they’re the same smart contracts audited as part of the rollup’s core security model. Third-party bridges trade a small fee for speed, useful when you don’t want to wait through a deposit confirmation window.

Bridge	Type	Typical Deposit Time	Typical Cost
Official Arbitrum Bridge	Canonical, protocol-native	~10 – 15 minutes	Gas only
Official Base Bridge	Canonical, protocol-native	~10 – 15 minutes	Gas only
Across	Third-party liquidity bridge, UMA optimistic oracle	~1 – 5 minutes	Small LP fee + gas
Orbiter Finance	Third-party liquidity bridge, maker-based	~1 – 3 minutes	Small fee + gas

For this tutorial’s walkthrough, we’ll use the official Arbitrum bridge, since it’s the lowest-trust option and the one you should default to unless speed is a genuine priority.

Step 6: Bridge ETH to Arbitrum — the Full Walkthrough

Navigate to Arbitrum’s official bridge interface directly from Arbitrum’s documentation rather than clicking a link from search results or a social media post, since fake bridge front-ends that mirror the real UI are a persistent phishing pattern in this space. Connect your dedicated bridging wallet, confirm it’s set to Ethereum Mainnet as the source network and Arbitrum One as the destination, then enter the amount of ETH you want to move.

Before confirming, run a small test transaction first, something like $5 to $10 worth of ETH, even if your real transfer is much larger. This costs a few extra minutes but confirms the destination address, network, and bridge contract are all behaving as expected before you commit a meaningful sum. Once the test lands, submit your real transfer. You’ll sign one transaction on Ethereum mainnet, which locks your ETH in the bridge’s smart contract, and the corresponding funds will appear on Arbitrum once the deposit is confirmed, typically within about 10 to 15 minutes under normal network conditions.

Step 7: Verify Your Transaction and Understand Finality

Copy your transaction hash from the mainnet confirmation and check it on Etherscan first, then switch your wallet’s network to Arbitrum One and confirm the same funds show up on Arbiscan. This two-sided check matters because a transaction can show “success” on the source chain while the corresponding funds are still in transit or, in a worst case, never arrive on the destination chain due to a bridge malfunction.

Deposits onto an optimistic rollup are fast because the rollup trusts the L1 deposit as final almost immediately. Withdrawals run the opposite direction and are slower by design: funds leaving Arbitrum, Base, or Optimism back to Ethereum mainnet sit in a challenge period, typically around seven days, before they can be claimed on L1. That delay exists specifically so fraud proofs have time to catch an invalid state transition before funds settle. Plan around it; if you think you might need funds back on mainnet quickly, a liquidity bridge like Across can front you the withdrawal instantly for a fee, skipping the native challenge window entirely.

Step 8: Deploy a Test Contract on Arbitrum with Hardhat

Once your wallet has funds on Arbitrum, it’s worth confirming you can actually interact with the chain beyond a simple transfer. Set up a minimal Hardhat project (npx hardhat init, choosing the JavaScript starter), then point it at Arbitrum’s testnet and mainnet RPC endpoints.

// hardhat.config.js
require('@nomicfoundation/hardhat-toolbox');
require('dotenv').config();

module.exports = {
  solidity: '0.8.24',
  networks: {
    arbitrumOne: {
      url: 'https://arb1.arbitrum.io/rpc',
      chainId: 42161,
      accounts: [process.env.PRIVATE_KEY],
    },
    arbitrumSepolia: {
      url: 'https://sepolia-rollup.arbitrum.io/rpc',
      chainId: 421614,
      accounts: [process.env.PRIVATE_KEY],
    },
  },
};

Store your private key in a .env file, never in the config file itself, and add .env to .gitignore before you do anything else. Test on Arbitrum Sepolia (the testnet) first, funded with free testnet ETH from a faucet, before ever pointing a deploy script at mainnet.

// scripts/deploy.js
const hre = require('hardhat');

async function main() {
  const Greeter = await hre.ethers.getContractFactory('Greeter');
  const greeter = await Greeter.deploy('Deployed from Arbitrum');
  await greeter.waitForDeployment();
  console.log('Greeter deployed to:', await greeter.getAddress());
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Run it with npx hardhat run scripts/deploy.js --network arbitrumSepolia. A successful deploy prints the contract’s address:

Greeter deployed to: 0x71C7656EC7ab88b098defB751B7401B5f6d8976

Paste that address into Arbiscan’s testnet explorer to confirm the deployment and inspect the transaction. Once you’re comfortable with the flow, switch the --network flag to arbitrumOne and repeat with real (small) funds.

Step 9: Automate Gas Monitoring Across Chains

If you bridge regularly, checking gas manually every time gets old fast. Extend the gas-check script from Step 4 into a cron job that logs prices at a fixed interval, so you have a running record of when fees dip low enough to time a larger transfer.

# crontab -e
# Log gas prices across all four networks every 15 minutes
*/15 * * * * cd /home/you/l2-tools && node check-gas.js >> gas-log.txt 2>&1

Over a week or two, this gives you a rough sense of your own usage patterns, useful mainly for timing large mainnet-side transactions (deposits and withdrawals both start with an L1 transaction, so L1 fees still matter even though your day-to-day activity moves to L2).

Step 10: Bridge Back to Ethereum Mainnet

Withdrawing follows the same interface in reverse: switch your wallet to Arbitrum One, open the bridge, select Arbitrum as the source and Ethereum as the destination, and initiate the withdrawal. This starts the challenge period covered in Step 7. After roughly seven days, you’ll need to return to the bridge interface and submit a second “claim” transaction on mainnet to actually receive the funds, an easy step to forget since the wallet doesn’t always prompt you again once the window closes.

If seven days is too long for your situation, route the withdrawal through a liquidity bridge like Across instead. You’ll pay a small fee for the convenience, but you receive funds on mainnet in minutes rather than waiting out the native challenge window.

Complete Working Project: The L2 Gas Savings Dashboard

Putting the pieces from Steps 4 and 9 together, here’s a full script that checks live gas prices across Ethereum, Arbitrum, Base, and Optimism, estimates the cost of a standard ETH transfer on each, and prints your percentage savings versus mainnet. This is the tool worth keeping around if you bridge more than occasionally.

// l2-dashboard.js
// Compares live gas prices across Ethereum L1 and three L2s, estimates the
// cost of a standard 21,000-gas ETH transfer, and prints savings vs mainnet.
import { createPublicClient, http, formatEther } from 'viem';
import { mainnet, arbitrum, base, optimism } from 'viem/chains';

const TRANSFER_GAS_UNITS = 21000n;

const networks = [
  { name: 'Ethereum', chain: mainnet },
  { name: 'Arbitrum', chain: arbitrum },
  { name: 'Base', chain: base },
  { name: 'Optimism', chain: optimism },
];

async function getExecutionCost(chain) {
  const client = createPublicClient({ chain, transport: http() });
  const gasPrice = await client.getGasPrice();
  return gasPrice * TRANSFER_GAS_UNITS;
}

async function main() {
  const results = [];
  for (const net of networks) {
    const costWei = await getExecutionCost(net.chain);
    results.push({ name: net.name, costWei });
  }

  const mainnetCost = results.find((r) => r.name === 'Ethereum').costWei;

  console.log('Network      Execution Cost (ETH)    Savings vs L1');
  for (const r of results) {
    const savings =
      r.name === 'Ethereum'
        ? '-'
        : `${(100 - Number((r.costWei * 100n) / mainnetCost)).toFixed(1)}%`;
    console.log(`${r.name.padEnd(12)} ${formatEther(r.costWei).padEnd(24)} ${savings}`);
  }
}

main();

Run it with node l2-dashboard.js. A typical run looks like this:

Network      Execution Cost (ETH)    Savings vs L1
Ethereum     0.000387024000000000    -
Arbitrum     0.000000210000000000    99.9%
Base         0.000000021000000000    99.9%
Optimism     0.000000189000000000    99.9%

One caveat worth building into your mental model: this script only measures raw execution gas, not the L1 calldata-posting fee that rollups add on top for real transactions. Actual fees you pay in your wallet will land closer to the ranges in the earlier fee table, still a 90%+ cut from mainnet, just not quite as extreme as the raw gwei math above suggests. Extend the script with a fixed calldata-fee estimate per chain if you want a number that matches what your wallet quotes at signing time.

Common Pitfalls When Bridging to Layer 2

Bridging tokens but forgetting gas. Sending USDC or another ERC-20 to Arbitrum without also bridging a small amount of ETH leaves you holding funds you can’t move, since every L2 transaction still needs the network’s native gas token.
Clicking a bridge link from a search ad or a Discord DM. Fake front-ends that copy the real interface pixel for pixel are one of the most common phishing vectors in this space. Always navigate from official documentation.
Not adding the network before checking your balance. Funds that land on Arbitrum won’t show up in a wallet still pointed at Ethereum Mainnet. This looks like “missing” funds and causes a fair amount of unnecessary panic.
Ignoring the withdrawal challenge period. Assuming a withdrawal from Arbitrum, Base, or Optimism back to mainnet completes as fast as a deposit is one of the most common first-time mistakes, and it can strand funds for a week if you needed them sooner.
Granting unlimited token approvals to a bridge contract. Approve only the amount you’re bridging where the interface allows it, so a future exploit against that contract can’t touch your full balance.
Confusing similarly named networks. Arbitrum One and Arbitrum Nova are different chains with different security models and use cases; sending funds to the wrong one means starting the whole recovery process over.
Skipping the test transaction on large transfers. A wrong chain selection on a six-figure bridge is a far more expensive mistake than the few minutes a $5 test transfer costs.

Troubleshooting: Bridge Errors and What They Mean

Even a careful bridge transaction can run into friction. Most of it traces back to one of a handful of root causes: network congestion on L1, a wallet pointed at the wrong chain, or a misunderstanding of how the deposit and withdrawal timelines differ. Here’s what the most common errors mean and how to resolve them.

Transaction stuck pending on mainnet. Usually a gas price set too low during network congestion. Most wallets let you speed up a pending transaction by resubmitting with a higher gas price and the same nonce.
Funds bridged but not visible in your wallet. Almost always a wrong network selection. Switch your wallet to Arbitrum One (or Base, or Optimism) and confirm the token contract address matches the official one for that chain.
“Insufficient funds for gas” despite holding tokens on L2. You have the token you’re trying to move but no ETH to pay for the transaction itself. Bridge a small amount of ETH separately.
Deposit shows complete on Etherscan but not on Arbiscan. Deposits typically need several block confirmations on L1 before the L2 sequencer picks them up. Wait the full 10-15 minute window before assuming something’s wrong.
Withdrawal stuck in the challenge period. This is expected behavior, not an error. Track the exact time remaining on the bridge interface’s transaction history page rather than guessing.
Wallet shows the wrong chain ID after adding a network. Remove the network entry and re-add it, double-checking the chain ID against Chainlist or the network’s official docs rather than a copy-pasted value from an unofficial source.
High fees during a bridge attempt despite L2’s reputation for cheap gas. L1 calldata costs spike during Ethereum mainnet congestion, and since deposits and withdrawals both touch L1, your bridge transaction (though not your subsequent L2 activity) can still get expensive during a busy period.
RPC errors or “could not detect network” in a script. The public RPC endpoint may be rate-limiting you. Swap in a dedicated RPC provider’s endpoint for anything beyond light personal use.
Nonce errors when deploying or interacting with a contract. Usually caused by a previous transaction still pending. Wait for it to confirm or clear your wallet’s transaction queue before retrying.

Advanced Tips for Power Users and Teams

Once the basic flow is second nature, a few habits pay off over time. Diversify across more than one L2 rather than concentrating everything on a single network; the TVL swings covered earlier in this piece show how quickly conditions can shift on any one rollup. Follow each network’s official status page and security Twitter/X account so you hear about an incident, like the Taiko exploit, within minutes rather than days.

That incident is worth understanding in detail because it’s a clean case study in what actually goes wrong on a rollup bridge. On June 22, 2026, Taiko, a separate Ethereum L2, halted block production and suspended all bridge activity after an exploit drained roughly $1.7 million from its bridge and vault contracts. The root cause traced back to a compromised SGX signing key that had been accidentally exposed on GitHub, letting the attacker forge withdrawal proofs the network accepted as valid. Taiko’s team patched the vulnerability, replenished reserves to full 1:1 backing, and restored bridge operations by July 2, 2026, following an independent security review. The lesson isn’t “avoid Taiko,” it’s that key management failures, not cryptographic breaks, are the most common way a rollup bridge actually fails, which is exactly why sticking to canonical bridges and watching official channels matters more than picking the “most secure-sounding” protocol on paper.

For teams managing multiple wallets, script the network-addition step from Step 3 into an onboarding tool rather than asking every new team member to manually add three chains by hand. And if you’re deploying contracts across Arbitrum, Base, and Optimism regularly, keep a single Hardhat config with all three networks defined side by side rather than maintaining separate project folders per chain, it makes cross-chain deploys and address bookkeeping far less error-prone.

Finally, treat your L2 gas savings dashboard as a living tool rather than a one-off script. Add a Slack or email alert when a chain’s L1 calldata cost drops below a threshold you set, and you’ll naturally start timing large transfers around cheap windows instead of paying whatever the network happens to charge the moment you remember to bridge. Over months of regular use, that habit alone tends to save more than the difference between any two L2s’ base fees.

Frequently Asked Questions

How much does it actually cost to bridge ETH to Arbitrum in 2026?

The bridge transaction itself costs whatever Ethereum mainnet gas is at the time you submit it, since a deposit is an L1 transaction. Once your funds land on Arbitrum, ongoing activity costs $0.03 to $0.08 for a simple transfer and $0.20 to $0.40 for a typical swap, based on 2026 gas comparisons.

How long does bridging to Arbitrum take?

Deposits from Ethereum to Arbitrum typically complete in 10 to 15 minutes under normal conditions. Withdrawals back to mainnet take roughly seven days due to the optimistic rollup’s fraud-proof challenge period, unless you route through a third-party liquidity bridge that fronts the funds instantly for a fee.

Is bridging to a Layer 2 safe after the Taiko exploit?

The Taiko incident was specific to Taiko’s own bridge and its SGX key management, not a flaw shared by Arbitrum, Base, or Optimism’s canonical bridges. That said, no bridge is risk-free. Using the official bridge for each network, verifying contract addresses independently, and avoiding unlimited token approvals reduces your exposure regardless of which L2 you use.

Can I bridge directly from Coinbase or Binance to Arbitrum?

Coinbase supports direct withdrawals to Base natively, and several major exchanges support direct withdrawal to Arbitrum One as a network option, skipping the mainnet bridge step entirely. Check your specific exchange’s supported withdrawal networks before assuming this option is available, since not every exchange lists every L2.

What’s the real difference between Arbitrum, Base, and Optimism?

All three are optimistic rollups settling to Ethereum, but Arbitrum uses its own rollup technology stack (Arbitrum Nitro) while Base and Optimism both run on the shared OP Stack codebase. Arbitrum carries the most DeFi liquidity, Base sees the highest transaction volume, and Optimism anchors the broader Superchain governance model that Base itself participates in.

Do I need a separate wallet for each Layer 2?

No. The same wallet address works across Ethereum, Arbitrum, Base, and Optimism since they’re all EVM-compatible chains. You do need to add each network separately inside your wallet software and hold that network’s native gas token (ETH on all three) to transact.

Why did my withdrawal from Arbitrum take a week?

That’s the optimistic rollup’s fraud-proof challenge period working as designed, not a malfunction. The roughly seven-day window gives validators time to dispute an invalid state transition before funds are considered final on mainnet. If you need funds faster, a liquidity bridge like Across can front the withdrawal for a fee.

Which Layer 2 has the lowest fees right now?

Based on 2026 gas comparisons, Base has consistently posted the lowest fees among the three for simple transfers, at roughly $0.02 to $0.05, with Arbitrum close behind and Optimism slightly higher. The gap between all three is small enough that network choice should come down to ecosystem and liquidity needs rather than fee differences alone.