Cross-chain messaging
for the Optimism Superchain

import 'dotenv/config'
import { encodeFunctionData } from 'viem'
import { InteropMessenger, supersimL2A, supersimL2B } from 'op-interop-sdk'

// Start Supersim: supersim --interop.autorelay
// L2A http://localhost:9545 chainId 901
// L2B http://localhost:9546 chainId 902

const messenger = new InteropMessenger({ privateKey: process.env.PRIVATE_KEY as `0x${string}` })

const result = await messenger.sendMessage({
  sourceChain: supersimL2A,
  destChain:   supersimL2B,
  target: '0x0000000000000000000000000000000000000001',
  message: encodeFunctionData({ abi: [{ name: 'ping', type: 'function', inputs: [{ type: 'uint256' }], outputs: [] }], functionName: 'ping', args: [42n] }),
})

// Supersim auto-relays — just check status after 2s
await new Promise(r => setTimeout(r, 2000))

const status = await messenger.getMessageStatus({ msgHash: result.msgHash, destChain: supersimL2B })
console.log(status) // -> 'relayed'

// Greeter.sol — deploy on Zora Sepolia
contract Greeter {
  address constant MESSENGER = 0x4200000000000000000000000000000000000023;
  string public greeting;

  function setGreeting(string calldata s) external {
    require(msg.sender == MESSENGER, "Only messenger");
    greeting = s;
  }
}

// Then from OP Sepolia:
const result = await messenger.sendMessage({
  sourceChain: optimismSepolia,
  destChain:   zoraSepolia,
  target:      GREETER_ADDRESS,
  message:     encodeFunctionData({ abi, functionName: 'setGreeting', args: ['Hello from OP Sepolia'] }),
})

await messenger.relayMessage({ identifier: result.identifier, sourceChain: optimismSepolia, destChain: zoraSepolia })

// Verify on Zora Sepolia
const greeting = await client.readContract({ address: GREETER_ADDRESS, abi, functionName: 'getGreeting' })
// -> "Hello from OP Sepolia"

async function waitForRelay(
  msgHash: `0x${string}`,
  destChain: Chain,
  timeoutMs = 120_000,
  intervalMs = 3_000,
): Promise<'relayed' | 'failed' | 'timeout'> {
  const start = Date.now()

  while (Date.now() - start < timeoutMs) {
    const status = await messenger.getMessageStatus({ msgHash, destChain })
    if (status === 'relayed' || status === 'failed') return status
    await new Promise(r => setTimeout(r, intervalMs))
  }
  return 'timeout'
}

const result = await waitForRelay(msgHash, zoraSepolia)

if (result === 'relayed') {
  // safe to read destination chain state
} else if (result === 'timeout') {
  // L2 node still propagating — retry later
}

import { ContractFunctionRevertedError } from 'viem'

// 1. NotInAccessList — slot not populated yet
//    Retry with backoff until slot is ready
for (let i = 0; i < 10; i++) {
  try {
    await messenger.relayMessage(params); break
  } catch (err) {
    if (err instanceof ContractFunctionRevertedError
        && err.reason?.includes('NotInAccessList') && i < 9) {
      await new Promise(r => setTimeout(r, 5_000))
    } else throw err
  }
}

// 2. MessageAlreadyRelayed — guard before relaying
const status = await messenger.getMessageStatus({ msgHash, destChain })
if (status !== 'relayed') await messenger.relayMessage(params)

// 3. TargetCallFailed — target contract reverted
//    Message stays 'pending', fix target logic and retry

// Key rule: always pass result.msgHash to getMessageStatus,
// and result.identifier to relayMessage. Never mix the two.