How do estimate the cost of interop messages (spoiler: nearly nothing)

pages/interop/_meta.json

@@ -13,6 +13,7 @@
     "predeploy": "Superchain interop predeploys",
     "message-passing": "Superchain interop message passing",
     "message-expiration": "Message expiration",
+    "estimate-costs": "Cost of interop messages",
     "reading-logs": "Reading logs",
     "op-supervisor": "OP Supervisor",
     "superchain-eth-bridge": "Superchain ETH bridge",

pages/interop/estimate-costs.mdx

@@ -0,0 +1,116 @@
+---
+title: Estimating the cost of interop messages
+description: Estimate the gas cost of Superchain interop messages.
+lang: en-US
+content_type: guide
+topic: interop-gas-estimate
+personas:
+  - protocol-developer
+  - app-developer
+categories:
+  - interoperability
+  - cross-chain-messaging
+  - superchain
+  - message-passing
+  - gas-cost
+is_imported_content: 'false'
+---
+
+import { Callout } from 'nextra/components'
+import { InteropCallout } from '@/components/WipCallout'
+
+<InteropCallout />
+
+# Estimating the cost of interop messages
+
+<Callout type="info">
+  At the time of writing (May 2025) the cost of a hundred interop messages is just a few cents.
+  Unless the cost of OP Stack transactions rises significantly, the cost of interop is not an important consideration.
+
+  To see the current cost of gas, go to a [block explorer](https://optimism.blockscout.com/) and look at a recent transaction.
+</Callout>
+
+There are several factors that determine the cost of an [interop transaction](/interop/message-passing):
+
+*   How you pass the message.
+    You can either use [`CrossL2Inbox`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/CrossL2Inbox.sol) directly, or use the cross domain messenger, [`L2ToL2CrossDomainMessenger`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/L2ToL2CrossDomainMessenger.sol), which uses `CrossL2Inbox` internally.
+*   The transaction type.
+    Every interop message has two transactions, an [initiating message](/interop/message-passing#initiating-message) in a transaction to the source chain, and an [executing message](/interop/message-passing#executing-message) in the destination chain.
+*   Whether autorelay is turned on.
+    If it is turned on for a particular chain, there is still an executing message when using `L2ToL2CrossDomainMessenger`, but the chain operator pays for it so you may not care.
+
+## CrossL2Inbox
+
+This is the low level protocol used by all interop protocols, including `L2ToL2CrossDomainMessenger`.
+
+### Initiating message
+
+The initiating message here is just any log entry.
+A log entry emitted by Solidity code has 1–4 topics (t) and an unlimited number of unstructured data bytes (n).
+The gas cost is  [*375(t+1)+8n*](https://www.evm.codes/?fork=cancun#a1).
+
+### Executing message
+
+The executing message cost has several components:
+
+1.  The cost of posting the transaction.
+2.  The cost of hashing the message.
+3.  The cost of `CrossL2Inbox.validateMessage`.
+4.  The cost of using the message.
+
+The first and second components depend on the log entry.
+`CrossL2Inbox.validateMessage` only requires a 32 byte hash of the log entry, but actually using it typically requires the information that has been hashed.
+
+Additionally, you need to provide the `CrossL2Inbox` with how to find the log entry.
+This is encoded in a [five member structure](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/CrossL2Inbox.sol#L7-L19), so *32×5=160* bytes.
+And, of course, you need to call a function which requires a four byte selector.
+
+So the number of bytes required is *164+32t+n*.
+
+Every transaction posted costs at least *21,000* gas.
+Compared with that, the hashing which costs approximately [*30+0.2×\<number of bytes>*](https://www.evm.codes/?fork=cancun#20), is negligible.
+We can usually ignore the [memory expansion cost](https://www.evm.codes/about#memoryexpansion), unless the validating contract uses a really large amount of memory.
+
+The cost of using the message is beyond the scope here, because it depends on your application.
+
+So the main cost drivers are the 21,000 transaction gas cost has plus the cost of posting a *164+32t+n* byte transaction.
+
+## Cross domain messenger
+
+This higher level protocol adds some expenses, mostly because replay protection requires storage, and [writing to storage](https://www.evm.codes/?fork=cancun#55) is a relatively expensive operation.
+
+### Initiating message
+
+The initiating message is sent by [`L2ToL2CrossDomainMessenger.sendMessage`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/L2ToL2CrossDomainMessenger.sol#L128-L161). This function writes to storage twice.
+
+It writes to [specify that the hash has a sent message](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/L2ToL2CrossDomainMessenger.sol#L157).
+This would typically be written to previously empty storage, so the cost is *22,100* gas.
+
+Then it [increments the nonce value](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/L2ToL2CrossDomainMessenger.sol#L158).
+Overwriting previously used storage (which means storage where the present value is *not* zero) only costs *5,000* gas.
+
+So, the initiating message costs a little over *27,100* gas, plus the negligible cost of emitting the log message, a few if statements, etc.
+Of course, it is created as part of a transaction, so we might want to include the *21,000* transaction cost too.
+
+### Executing message
+
+If autorelay is turned on in a blockchain, then you don't care about the cost of the executing message.
+The chain operator will bear the cost.
+
+If autorelay is not turned on, the executing message is a call to [`L2ToL2CrossDomainMessenger.relayMessage`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/L2ToL2CrossDomainMessenger.sol#L197-L256).
+The only storage operation here is [noting the hash has been used for a message already](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/L2ToL2CrossDomainMessenger.sol#L241).
+This is previously unwritten storage, so we can expect to pay the tull *22,100* in gas.
+Plus, of course, the *21,000* that any transaction costs.
+All the other gas costs are negligible.
+
+## Conclusion
+
+Unless the message is *extremely* long, the cost of an interop message, taking both sides together, is unlikely to exceed *100,000* gas.
+At the time of writing, each gas unit costs approximately `$3×10^-9`, so it would take about thirty messages to add up to a full cent.
+
+## Next steps
+
+*   Build a [revolutionary app](/app-developers/get-started) that uses multiple blockchains within the Superchain
+*   Deploy a [SuperchainERC20](/interop/tutorials/deploy-superchain-erc20) to the Superchain
+*   Learn [how messages get from one chain to another chain](/interop/message-passing)
+*   Watch [this video](https://www.youtube.com/watch?v=FKc5RgjtGes), which gives an overview of Superchain interoperability.

words.txt

@@ -85,7 +85,6 @@ counterfactually
 Crosschain
 crosschain
 Crossmint
-custom-bridge
 Dapphub
 daserver
 DATACAP
@@ -94,8 +93,8 @@ DATADIR
 datadir
 devdocs
 Devnet
-Devnets
 devnet
+Devnets
 devnets
 direnv
 DISABLETXPOOLGOSSIP