Bridging ETH to OP Mainnet with Viem

This tutorial explains how you can use Viem (opens in a new tab) to bridge ETH from L1 (Ethereum or Sepolia) to L2 (OP Mainnet or OP Sepolia). Viem is a TypeScript interface for Ethereum that provides low-level stateless primitives for interacting with Ethereum. It offers an easy way to add bridging functionality to your JavaScript-based application.

Behind the scenes, Viem uses the Standard Bridge contracts to transfer ETH and ERC-20 tokens. Make sure to check out the Standard Bridge guide if you want to learn more about how the bridge works under the hood.

Supported networks

Viem supports any of the Superchain networks. The OP Stack networks are included in Viem by default. If you want to use a network that isn't included by default, you can add it to Viem's chain configurations.

Dependencies

• node (opens in a new tab)
• pnpm (opens in a new tab)

Create a demo project

You're going to use Viem for this tutorial. Since Viem is a Node.js (opens in a new tab) library, you'll need to create a Node.js project to use it.

mkdir bridge-eth
cd bridge-eth

pnpm init

pnpm add viem

Get ETH on Sepolia

This tutorial explains how to bridge ETH from Sepolia to OP Sepolia. You will need to get some ETH on Sepolia to follow along.

Add a private key to your environment

You need a private key in order to sign transactions. Set your private key as an environment variable with the export command. Make sure this private key corresponds to an address that has ETH on Sepolia.

export TUTORIAL_PRIVATE_KEY=0x...

Start the Node REPL

You're going to use the Node REPL to interact with Viem. To start the Node REPL run the following command in your terminal:

node

This will bring up a Node REPL prompt that allows you to run JavaScript code.

Import dependencies

You need to import some dependencies into your Node REPL session.

const { createPublicClient, http, createWalletClient, parseEther, formatEther } = require('viem');
const { sepolia, optimismSepolia } = require('viem/chains');
const { privateKeyToAccount } = require('viem/accounts');
const { getL2TransactionHashes, publicActionsL1, publicActionsL2, walletActionsL1, walletActionsL2 } = require('viem/op-stack');

const PRIVATE_KEY = process.env.TUTORIAL_PRIVATE_KEY;
const account = privateKeyToAccount(PRIVATE_KEY);

const publicClientL1 = createPublicClient({
    chain: sepolia,
    transport: http("https://rpc.ankr.com/eth_sepolia"),
}).extend(publicActionsL1()) 

const walletClientL1 = createWalletClient({
    account,
    chain: sepolia,
    transport: http("https://rpc.ankr.com/eth_sepolia"),
}).extend(walletActionsL1());

const publicClientL2 = createPublicClient({
    chain: optimismSepolia,
    transport: http("https://sepolia.optimism.io"),
}).extend(publicActionsL2());

const walletClientL2 = createWalletClient({
    account,
    chain: optimismSepolia,
    transport: http("https://sepolia.optimism.io"),
}).extend(walletActionsL2());

Get ETH on Sepolia

You're going to need some ETH on L1 that you can bridge to L2. You can get some Sepolia ETH from this faucet (opens in a new tab).

Deposit ETH

Now that you have some ETH on L1 you can deposit that ETH into the L1StandardBridge contract. You'll then receive the same number of ETH on L2 in return.

const l1Balance = await publicClientL1.getBalance({ address: account.address });
console.log(`L1 Balance: ${formatEther(l1Balance)} ETH`); 

const depositArgs = await publicClientL2.buildDepositTransaction({
    mint: parseEther("0.0001"),
    to: account.address,
});

const depositHash = await walletClientL1.depositTransaction(depositArgs);
console.log(`Deposit transaction hash on L1: ${depositHash}`);

const depositReceipt = await publicClientL1.waitForTransactionReceipt({ depositHash });
console.log('L1 transaction confirmed:', depositReceipt);

const [l2Hash] = getL2TransactionHashes(depositReceipt);
console.log(`Corresponding L2 transaction hash: ${l2Hash}`);

const l2Receipt = await publicClientL2.waitForTransactionReceipt({
    hash: l2Hash,
}); 
console.log('L2 transaction confirmed:', l2Receipt);
console.log('Deposit completed successfully!');

Withdraw ETH

You just bridged some ETH from L1 to L2. Nice! Now you're going to repeat the process in reverse to bridge some ETH from L2 to L1.

//Add the same imports used in DepositETH function
const withdrawalArgs = await publicClientL2.buildWithdrawalTransaction({
value: parseEther('0.0001'),
to: account.address,
});

const withdrawalHash = await walletClientL2.initiateWithdrawal(withdrawalArgs);
console.log(`Withdrawal transaction hash on L2: ${withdrawalHash}`);

const withdrawalReceipt = await publicClientL2.waitForTransactionReceipt({ hash: withdrawalHash });
console.log('L2 transaction confirmed:', withdrawalReceipt);

const { output, withdrawal } = await publicClientL1.waitToProve({
withdrawalReceipt,
targetChain: walletClientL2.chain
});

const proveArgs = await publicClientL2.buildProveWithdrawal({
output,
withdrawal,
});

const proveHash = await walletClientL1.proveWithdrawal(proveArgs);
 
const proveReceipt = await publicClientL1.waitForTransactionReceipt({ hash: proveHash });

const awaitWithdrawal = await publicClientL1.waitToFinalize({
targetChain: walletClientL2.chain,
withdrawalHash: withdrawal.withdrawalHash,
});

const finalizeHash = await walletClientL1.finalizeWithdrawal({
targetChain: walletClientL2.chain,
withdrawal,
});

const finalizeReceipt = await publicClientL1.waitForTransactionReceipt({
hash: finalizeHash
});

const status = await publicClientL1.getWithdrawalStatus({
receipt,
targetChain: walletClientL2.chain
})
console.log('Withdrawal completed successfully!');

Important Considerations

Next Steps

• Develop a user interface for easier interaction with these bridging functions.
• Implement robust error handling and retry mechanisms for production use.

You've just deposited and withdrawn ETH using viem/op-stack. You should now be able to write applications that use viem/op-stack to transfer ETH between L1 and L2. Although this tutorial used Sepolia and OP Sepolia, the same process works for Ethereum and OP Mainnet.