0x0200000000000000000000000000000000000008

┌─────────────────────┐                    ┌─────────────────────┐
│   Source Chain      │                    │   Destination Chain │
│   (C-Chain)         │                    │   (Subnet/A-Chain)  │
├─────────────────────┤                    ├─────────────────────┤
│                     │                    │                     │
│  1. sendWarpMessage │                    │  4. Execute action  │
│     (emit event)    │─────────────────▶  │     with payload    │
│                     │  BLS Aggregation   │                     │
│  2. Validators sign │  (67% threshold)   │  3. getVerified     │
│     message hash    │                    │     WarpMessage     │
└─────────────────────┘                    └─────────────────────┘

interface IWarpMessenger {
    /// @notice Send a message to another chain
    /// @param payload The message payload
    /// @return messageID Unique identifier for the message
    function sendWarpMessage(bytes calldata payload) external returns (bytes32 messageID);

    /// @notice Get a verified incoming message
    /// @param index The message index in the block
    /// @return message The verified WarpMessage
    function getVerifiedWarpMessage(uint32 index)
        external view
        returns (WarpMessage calldata message);

    /// @notice Get verified block hash from another chain
    /// @param index The message index
    /// @return blockHash The verified block hash
    function getVerifiedWarpBlockHash(uint32 index)
        external view
        returns (bytes32 blockHash);
}

struct WarpMessage {
    bytes32 sourceChainID;
    address originSenderAddress;
    bytes payload;
}

import "@luxfi/standard/src/interfaces/IWarpMessenger.sol";

contract CrossChainSender {
    IWarpMessenger constant WARP = IWarpMessenger(0x0200000000000000000000000000000000000008);

    function sendCrossChain(bytes calldata data) external returns (bytes32) {
        // Encode the payload with destination info
        bytes memory payload = abi.encode(
            msg.sender,    // Original sender
            data           // Action data
        );

        // Send via Warp precompile
        return WARP.sendWarpMessage(payload);
    }
}

contract CrossChainReceiver {
    IWarpMessenger constant WARP = IWarpMessenger(0x0200000000000000000000000000000000000008);

    bytes32 public immutable trustedSourceChain;
    address public immutable trustedSender;

    function receiveMessage(uint32 warpIndex) external {
        // Get verified message (BLS signatures validated by precompile)
        WarpMessage memory message = WARP.getVerifiedWarpMessage(warpIndex);

        // Verify source chain
        require(message.sourceChainID == trustedSourceChain, "Untrusted chain");

        // Verify sender
        require(message.originSenderAddress == trustedSender, "Untrusted sender");

        // Decode and execute
        (address sender, bytes memory data) = abi.decode(message.payload, (address, bytes));
        _executeAction(sender, data);
    }
}

contract WarpBridge {
    IWarpMessenger constant WARP = IWarpMessenger(0x0200000000000000000000000000000000000008);
    IERC20 public token;
    bytes32 public remoteChainID;
    address public remoteBridge;

    /// @notice Bridge tokens to remote chain
    function bridge(uint256 amount, address recipient) external returns (bytes32) {
        // Lock tokens
        token.transferFrom(msg.sender, address(this), amount);

        // Send warp message
        bytes memory payload = abi.encode(
            amount,
            recipient,
            msg.sender
        );

        return WARP.sendWarpMessage(payload);
    }

    /// @notice Claim bridged tokens
    function claim(uint32 warpIndex) external {
        WarpMessage memory message = WARP.getVerifiedWarpMessage(warpIndex);

        require(message.sourceChainID == remoteChainID, "Wrong chain");
        require(message.originSenderAddress == remoteBridge, "Wrong bridge");

        (uint256 amount, address recipient,) = abi.decode(
            message.payload,
            (uint256, address, address)
        );

        token.transfer(recipient, amount);
    }
}

function verifyRemoteState(
    uint32 warpIndex,
    bytes32 expectedBlockHash
) external view returns (bool) {
    bytes32 blockHash = WARP.getVerifiedWarpBlockHash(warpIndex);
    return blockHash == expectedBlockHash;
}