Communicating between OP Stack and Ethereum in Solidity

This tutorial explains how to write Solidity contracts on OP Stack and Ethereum that can talk to each other. Here you'll use a contract on OP Stack that can set a "greeting" variable on a contract on Ethereum, and vice-versa. This is a simple example, but the same technique can be used to send any kind of message between the two chains.

You won't actually be deploying any smart contracts as part of this tutorial. Instead, you'll reuse existing contracts that have already been deployed to OP Stack and Ethereum. Later in the tutorial you'll learn exactly how these contracts work so you can follow the same pattern to deploy your own contracts.

Message passing basics

OP Stack uses a smart contract called the CrossDomainMessenger to pass messages between OP Stack and Ethereum. Both chains have a version of this contract (the L1CrossDomainMessenger and the L2CrossDomainMessenger). Messages sent from Ethereum to OP Stack are automatically relayed behind the scenes. Messages sent from OP Stack to Ethereum must be explicitly relayed with a second transaction on Ethereum. Read more about message passing in the guide to Sending Data Between L1 and L2.

Dependencies

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

Get ETH on Sepolia and OP Sepolia

This tutorial explains how to send messages from Sepolia to OP Sepolia. You will need to get some ETH on both of these testnets.

Review the contracts

You're about to use two contracts that have already been deployed to Sepolia and OP Sepolia, the Greeter contracts. You can review the source code for the L1 Greeter contract here on Etherscan (opens in a new tab). You can review the source code for the L2 Greeter contract here on Etherscan (opens in a new tab). Both contracts have exactly the same source code.

Feel free to review the source code for these two contracts now if you'd like. This tutorial will explain how these contracts work in detail later on in the How It Works section below.

Interact with the L1 Greeter

You're first going to use the L1 Greeter contract to set the greeting on the L2 Greeter contract. You'll send a transaction directly to the L1 Greeter contract which will ask the L1CrossDomainMessenger to send a message to the L2 Greeter contract. After just a few minutes, you'll see the corresponding greeting set on the L2 Greeter contract.

Interact with the L2 Greeter

Now you're going to use the L2 Greeter contract to set the greeting on the L1 Greeter contract. You'll send a transaction directly to the L2 Greeter contract which will ask the L2CrossDomainMessenger to send a message to the L1 Greeter contract. Unlike the previous step, you'll need to relay the message from L2 to L1 yourself! You'll do this by sending two transactions on Sepolia, one proving transaction and one relaying transaction.

mkdir cross-dom
cd cross-dom

pnpm init

pnpm add viem

export TUTORIAL_PRIVATE_KEY=0x...

export TUTORIAL_TRANSACTION_HASH=0x...

node

const { createPublicClient, http } = require('viem');
const { optimismSepolia } = require('viem/chains');
const {  publicActionsL1, publicActionsL2} = require('viem/op-stack');

const transactionHash = process.env.TUTORIAL_TRANSACTION_HASH

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

console.log('Waiting for message to be provable...')
await l1Provider.getWithdrawalStatus({ 
  receipt, 
  targetChain: l2Provider.chain, 
}) 

console.log('Proving message...')
const receipt = await l2Provider.getTransactionReceipt(transactionHash)
const output = await l1Provider.waitToProve({ 
  receipt, 
  targetChain: l2Provider.chain, 
}) 

console.log('Waiting for message to be relayable...')
await l1Provider.getWithdrawalStatus({ 
  receipt, 
  targetChain: l2Provider.chain, 
}) 

console.log('Relaying message...')
const [message] = getWithdrawals(receipt)
await l1Provider.waitToFinalize({ withdrawalHash: message.withdrawalHash, targetChain: l2Provider.chain }) 

console.log('Waiting for message to be relayed...')
await l1Provider.getWithdrawalStatus({ receipt, targetChain: l2Provider.chain }) 

How it works

Congratulations! You've successfully sent a message from L1 to L2 and from L2 to L1. This section will explain how the Greeter contracts work so you can follow the same pattern to deploy your own contracts. Luckily, both Greeter contracts are exactly the same so it's easy to see how everything comes together.

The Messenger variable

The Greeter contract has a MESSENGER variable that keeps track of the CrossDomainMessenger contract on the current chain. Check out the Contract Addresses page to see the addresses of the CrossDomainMessenger contracts on whichever network you'll be using.

    ICrossDomainMessenger public immutable MESSENGER;

The other Greeter variable

The Greeter contract also has an OTHER_GREETER variable that keeps track of the Greeter contract on the other chain. On L1, this variable is set to the address of the L2 Greeter contract, and vice-versa.

    Greeter public immutable OTHER_GREETER;

The Greetings mapping

The Greeter contract keeps track of the different greetings that users have sent inside a greetings mapping. By using a mapping, this contract can keep track of greetings from different users at the same time.

    mapping (address => string) public greetings;

The Constructor

The Greeter has a simple constructor that sets the MESSENGER and OTHER_GREETER variables.

    constructor(
        ICrossDomainMessenger _messenger,
        Greeter _otherGreeter
    ) {
        MESSENGER = _messenger;
        OTHER_GREETER = _otherGreeter;
    }

The sendGreeting function

The sendGreeting function is the most important function in the Greeter contract. This is what you called earlier to send messages in both directions. All this function is doing is using the sendMessage function found within the CrossChainMessenger contract to send a message to the Greeter contract on the other chain.

Here, the first parameter is the address of the recipient of the message (the Greeter contract on the other chain). The second parameter is the ABI-encoded function call to the setMessage function. The final parameter is the gas limit that gets used when the message is relayed on the other side.

    function sendGreeting(string memory _greeting) public {
        MESSENGER.sendMessage(
            address(OTHER_GREETER),
            abi.encodeCall(
                this.setGreeting,
                (
                    msg.sender,
                    _greeting
                )
            ),
            200000
        );
    }

The setGreeting function

The setMessage function is the function that actually sets the greeting. This function is called by the CrossDomainMessenger contract on the other chain. It checks explicitly that the function can only be called by the CrossDomainMessenger contract. It also checks that the CrossChainMessenger is saying that the message came from the Greeter contract on the other chain. Finally, it sets the greeting in the greetings mapping.

    function setGreeting(address _sender, string memory _greeting) public {
        require(
            msg.sender == address(MESSENGER),
            "Greeter: Direct sender must be the CrossDomainMessenger"
        );
 
        require(
            MESSENGER.xDomainMessageSender() == address(OTHER_GREETER),
            "Greeter: Remote sender must be the other Greeter contract"
        );
 
        greetings[_sender] = _greeting;
    }

Conclusion

You just learned how you can write Solidity contracts on Sepolia and OP Sepolia that can talk to each other. You can follow the same pattern to write contracts that can talk to each other on Ethereum and OP Stack.

This sort of cross-chain communication is useful for a variety of reasons. For example, the Standard Bridge contracts use this same system to bridge ETH and ERC-20 tokens between Ethereum and OP Stack.

One cool way to take advantage of cross-chain communication is to do most of your heavy lifting on OP Stack and then send a message to Ethereum only when you have important results to share. This way you can take advantage of the low gas costs on OP Stack while still being able to use Ethereum when you need it.