Cross Chain Developer

Source Chain                          Destination Chain
┌──────────────┐                    ┌──────────────┐
│ User locks   │   Verification    │ Bridge mints │
│ 100 USDC in  │ ──────────────>  │ 100 bUSDC to │
│ bridge vault │   (relayer/proof) │ user address  │
└──────────────┘                    └──────────────┘

On return: burn bUSDC on destination, unlock USDC on source

Source Chain                          Destination Chain
┌──────────────┐                    ┌──────────────┐
│ Token burned  │   Attestation    │ Token minted │
│ on source    │ ──────────────>  │ on dest      │
│ (supply -= n)│   (oracle network)│ (supply += n)│
└──────────────┘                    └──────────────┘

Total supply across all chains remains constant

Source Chain                          Destination Chain
┌──────────────┐                    ┌──────────────┐
│ User sends to│   Liquidity pool  │ LP sends to  │
│ LP on source │ <──────────────> │ user on dest  │
│              │   Rebalancing     │              │
└──────────────┘                    └──────────────┘

No wrapped tokens -- native assets on both sides

// Sending a cross-chain message with LayerZero V2
import { OApp, Origin, MessagingFee } from "@layerzerolabs/oapp-evm/contracts/oapp/OApp.sol";

contract CrossChainCounter is OApp {
    uint256 public count;

    constructor(address _endpoint, address _delegate) OApp(_endpoint, _delegate) {}

    // Send increment message to another chain
    function incrementRemote(
        uint32 _dstEid,      // destination endpoint ID
        bytes calldata _options
    ) external payable {
        bytes memory payload = abi.encode(count + 1);
        _lzSend(
            _dstEid,
            payload,
            _options,
            MessagingFee(msg.value, 0),
            payable(msg.sender)
        );
    }

    // Receive message from another chain
    function _lzReceive(
        Origin calldata _origin,
        bytes32 _guid,
        bytes calldata _message,
        address _executor,
        bytes calldata _extraData
    ) internal supersede {
        count = abi.decode(_message, (uint256));
    }

    // Quote the fee for sending
    function quote(
        uint32 _dstEid,
        bytes calldata _options
    ) external view returns (MessagingFee memory) {
        return _quote(_dstEid, abi.encode(count + 1), _options, false);
    }
}

import {IRouterClient} from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IRouterClient.sol";
import {Client} from "@chainlink/contracts-ccip/src/v0.8/ccip/libraries/Client.sol";
import {CCIPReceiver} from "@chainlink/contracts-ccip/src/v0.8/ccip/applications/CCIPReceiver.sol";

contract CrossChainSender {
    IRouterClient public router;
    IERC20 public linkToken;

    function sendMessage(
        uint64 destinationChainSelector,
        address receiver,
        bytes calldata data
    ) external returns (bytes32 messageId) {
        Client.EVM2AnyMessage memory message = Client.EVM2AnyMessage({
            receiver: abi.encode(receiver),
            data: data,
            tokenAmounts: new Client.EVMTokenAmount[](0),
            feeToken: address(linkToken),
            extraArgs: Client._argsToBytes(
                Client.EVMExtraArgsV1({gasLimit: 200_000})
            )
        });

        uint256 fees = router.getFee(destinationChainSelector, message);
        linkToken.approve(address(router), fees);
        messageId = router.ccipSend(destinationChainSelector, message);
    }
}

contract CrossChainReceiver is CCIPReceiver {
    constructor(address _router) CCIPReceiver(_router) {}

    function _ccipReceive(
        Client.Any2EVMMessage memory message
    ) internal supersede {
        address sender = abi.decode(message.sender, (address));
        bytes memory data = message.data;
        // Process cross-chain message
    }
}

// Using CREATE2 via a factory for deterministic addresses
contract DeterministicFactory {
    function deploy(bytes32 salt, bytes calldata bytecode)
        external
        returns (address deployed)
    {
        assembly {
            deployed := create2(0, add(bytecode, 0x20), mload(bytecode), salt)
        }
        require(deployed != address(0), "Deploy failed");
    }
}

// Pre-compute the address
function computeAddress(bytes32 salt, bytes32 bytecodeHash)
    external view returns (address)
{
    return address(uint160(uint256(keccak256(abi.encodePacked(
        bytes1(0xff),
        address(this),
        salt,
        bytecodeHash
    )))));
}

// script/DeployMultiChain.s.sol
contract DeployMultiChain is Script {
    function run() external {
        // Deploy to each chain using fork URLs
        string[3] memory chains = ["ethereum", "arbitrum", "base"];
        address[3] memory endpoints; // LayerZero endpoints per chain

        for (uint i = 0; i < chains.length; i++) {
            vm.createSelectFork(vm.envString(
                string.concat("RPC_", chains[i])
            ));
            vm.startBroadcast(vm.envUint("PRIVATE_KEY"));

            MyOApp app = new MyOApp{salt: bytes32("v1")}(
                endpoints[i],
                vm.envAddress("OWNER")
            );

            vm.stopBroadcast();
        }
    }
}

// hardhat.config.ts multi-chain setup
const config: HardhatUserConfig = {
  networks: {
    ethereum: { url: CONFIG.ETH_RPC, chainId: 1 },
    arbitrum: { url: CONFIG.ARB_RPC, chainId: 42161 },
    optimism: { url: CONFIG.OP_RPC, chainId: 10 },
    base:     { url: CONFIG.BASE_RPC, chainId: 8453 },
    polygon:  { url: CONFIG.POLY_RPC, chainId: 137 },
  }
};

// Deployment registry -- track addresses across chains
// deploy-registry.json
{
  "MyOApp": {
    "1":     "0xabc...123",
    "42161": "0xabc...123",  // same address via CREATE2
    "10":    "0xabc...123",
    "8453":  "0xabc...123"
  }
}

User Intent: "Swap 100 USDC on Arbitrum for ETH on Base"

┌─────────────┐     ┌──────────────┐     ┌─────────────┐
│ User signs  │────>│ Solver fills │────>│ Settlement  │
│ intent      │     │ order cross- │     │ verifies    │
│ (off-chain) │     │ chain        │     │ fulfillment │
└─────────────┘     └──────────────┘     └─────────────┘

Benefits: User doesn't choose bridge, solver optimizes routing
Examples: Across, UniswapX, Socket

Single Account, Multi-Chain:
- User has one smart account address (same on all EVM chains)
- Paymaster sponsors gas on destination chain
- Session keys allow automated cross-chain operations
- Bundler submits UserOperations on appropriate chain

ERC-4337 + Cross-chain:
1. User signs UserOp on source chain
2. Bundler detects cross-chain intent
3. Message sent via bridge protocol
4. Destination bundler executes corresponding UserOp

1. Message Replay Protection
   - Include source chain ID in message payload
   - Track processed message IDs (nonce or hash)
   - Verify source chain and sender address

2. Finality Requirements
   - Ethereum: wait 12-15 minutes (finalized epoch)
   - Arbitrum/Optimism: 7-day challenge period for full security
   - Fast confirmations trade security for speed

3. Trust Model Assessment
   Questions for every bridge integration:
   - How many validators/guardians must collude to forge a message?
   - What is the economic security (stake at risk)?
   - Is there a fraud proof mechanism?
   - What happens if the bridge is paused?

4. Rate Limiting
   - Cap maximum transfer size per transaction
   - Cap maximum volume per time window
   - Implement circuit breakers for anomalous activity