Cross-chain messaging

// contracts/MyCustomAxelarGatewayDuplex.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import {AxelarGatewayDuplex, AxelarExecutable} from "@openzeppelin/community-contracts/crosschain/axelar/AxelarGatewayDuplex.sol";
import {IAxelarGateway} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGateway.sol";

abstract contract MyCustomAxelarGatewayDuplex is AxelarGatewayDuplex {
    /// @dev Initializes the contract with the Axelar gateway and the initial owner.
    constructor(IAxelarGateway gateway, address initialOwner) AxelarGatewayDuplex(gateway, initialOwner) {}
}

// contracts/MyERC7786GatewaySource.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {IERC7786GatewaySource} from "@openzeppelin/community-contracts/interfaces/IERC7786.sol";
import {InteroperableAddress} from "@openzeppelin/contracts/utils/draft-InteroperableAddress.sol";

abstract contract MyERC7786GatewaySource is IERC7786GatewaySource {
    error UnsupportedNativeTransfer();

    /// @inheritdoc IERC7786GatewaySource
    function supportsAttribute(bytes4 /*selector*/) public pure returns (bool) {
        return false;
    }

    /// @inheritdoc IERC7786GatewaySource
    function sendMessage(
        bytes calldata recipient, // Binary Interoperable Address
        bytes calldata payload,
        bytes[] calldata attributes
    ) external payable returns (bytes32 sendId) {
        require(msg.value == 0, UnsupportedNativeTransfer());
        // Use of `if () revert` syntax to avoid accessing attributes[0] if it's empty
        if (attributes.length > 0)
            revert UnsupportedAttribute(attributes[0].length < 0x04 ? bytes4(0) : bytes4(attributes[0][0:4]));

        // Emit event
        sendId = bytes32(0); // Explicitly set to 0. Can be used for post-processing
        emit MessageSent(
            sendId,
            InteroperableAddress.formatEvmV1(block.chainid, msg.sender),
            recipient,
            payload,
            0,
            attributes
        );

        // Optionally: If this is an adapter, send the message to a protocol gateway for processing
        // This may require the logic for tracking destination gateway addresses and chain identifiers

        return sendId;
    }
}

// contracts/MyERC7786ReceiverContract.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
import {ERC7786Receiver} from "@openzeppelin/community-contracts/crosschain/utils/ERC7786Receiver.sol";

contract MyERC7786ReceiverContract is ERC7786Receiver, AccessManaged {
    constructor(address initialAuthority) AccessManaged(initialAuthority) {}

    /// @dev Check if the given instance is a known gateway.
    function _isKnownGateway(address /* instance */) internal view virtual override returns (bool) {
        return true;
    }

    /// @dev Internal endpoint for receiving cross-chain message.
    function _processMessage(
        address gateway,
        bytes32 receiveId,
        bytes calldata sender,
        bytes calldata payload,
        bytes[] calldata attributes
    ) internal virtual override restricted {
        // Process the message here
    }
}

// contracts/MyERC7786ReceiverContract.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {AxelarGatewaySource} from "@openzeppelin/community-contracts/crosschain/axelar/AxelarGatewaySource.sol";
import {AxelarGatewayBase} from "@openzeppelin/community-contracts/crosschain/axelar/AxelarGatewayBase.sol";
import {IAxelarGateway} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGateway.sol";

abstract contract MyCustomAxelarGatewaySource is AxelarGatewaySource {
    /// @dev Initializes the contract with the Axelar gateway and the initial owner.
    constructor(IAxelarGateway gateway, address initialOwner) Ownable(initialOwner) AxelarGatewayBase(gateway) {}
}

// contracts/MyCustomAxelarGatewayDestination.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import {AxelarGatewayDestination, AxelarExecutable} from "@openzeppelin/community-contracts/crosschain/axelar/AxelarGatewayDestination.sol";
import {IAxelarGateway} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGateway.sol";

abstract contract MyCustomAxelarGatewayDestination is AxelarGatewayDestination {
    /// @dev Initializes the contract with the Axelar gateway and the initial owner.
    constructor(IAxelarGateway gateway, address initialOwner) AxelarExecutable(address(gateway)) {}
}

function sendMessage(
    string calldata destinationChain,
    string memory receiver,
    bytes memory payload,
    bytes[] memory attributes
) public payable virtual whenNotPaused returns (bytes32 outboxId) {

    // ... Initialize variables and prepare payload ...

    // Post on all gateways
    Outbox[] memory outbox = new Outbox[](_gateways.length());
    bool needsId = false;
    for (uint256 i = 0; i < outbox.length; ++i) {
        address gateway = _gateways.at(i);
        // send message
        bytes32 id = IERC7786GatewaySource(gateway).sendMessage(
            destinationChain,
            bridge,
            wrappedPayload,
            attributes
        );
        // if ID, track it
        if (id != bytes32(0)) {
            outbox[i] = Outbox(gateway, id);
            needsId = true;
        }
    }

    // ... Handle message tracking and return value ...
}

function executeMessage(
    string calldata /*messageId*/, // gateway specific, empty or unique
    string calldata sourceChain, // CAIP-2 chain identifier
    string calldata sender, // CAIP-10 account address (does not include the chain identifier)
    bytes calldata payload,
    bytes[] calldata attributes
) public payable virtual whenNotPaused returns (bytes4) {

    // ... Validate message format and extract message ID ...

    // If call is first from a trusted gateway
    if (_gateways.contains(msg.sender) && !tracker.receivedBy[msg.sender]) {
        // Count number of time received
        tracker.receivedBy[msg.sender] = true;
        ++tracker.countReceived;
        emit Received(id, msg.sender);

        // if already executed, leave gracefully
        if (tracker.executed) return IERC7786Receiver.executeMessage.selector;
    } else if (tracker.executed) {
        revert ERC7786OpenBridgeAlreadyExecuted();
    }

    // ... Validate sender and prepare payload for execution ...

    // If ready to execute, and not yet executed
    if (tracker.countReceived >= getThreshold()) {
        // prevent re-entry
        tracker.executed = true;

        // ... Prepare execution context and validate state ...
        bytes memory call = abi.encodeCall(
            IERC7786Receiver.executeMessage,
            (uint256(id).toHexString(32), sourceChain, originalSender, unwrappedPayload, attributes)
        );

        (bool success, bytes memory returndata) = receiver.parseAddress().call(call);

        // ... Handle the result ...
    }

    return IERC7786Receiver.executeMessage.selector;
}