@diwantanushh/rapiddex-contracts 1.0.0

package/lib/openzeppelin-contracts-master/contracts/crosschain/CrosschainRemoteExecutor.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.27;
+
+import {IERC7786GatewaySource} from "../interfaces/draft-IERC7786.sol";
+import {ERC7786Recipient} from "./ERC7786Recipient.sol";
+import {ERC7579Utils, Mode, CallType, ExecType} from "../account/utils/draft-ERC7579Utils.sol";
+import {Bytes} from "../utils/Bytes.sol";
+
+/**
+ * @dev Helper contract used to relay transactions received from a controller through an ERC-7786 gateway. This is
+ * used by the {GovernorCrosschain} governance module for the execution of cross-chain actions.
+ *
+ * A {CrosschainRemoteExecutor} address can be seen as the local identity of a remote executor on another chain. It
+ * holds assets and permissions for the sake of its controller.
+ */
+contract CrosschainRemoteExecutor is ERC7786Recipient {
+    using Bytes for bytes;
+    using ERC7579Utils for *;
+
+    /// @dev Gateway used by the remote controller to relay instructions to this executor.
+    address private _gateway;
+
+    /// @dev InteroperableAddress of the remote controller that is allowed to relay instructions to this executor.
+    bytes private _controller;
+
+    /// @dev Emitted when the gateway or controller of this remote executor is updated.
+    event CrosschainControllerSet(address gateway, bytes controller);
+
+    /// @dev Reverted when a non-controller tries to relay instructions to this executor.
+    error AccessRestricted();
+
+    constructor(address initialGateway, bytes memory initialController) {
+        _setup(initialGateway, initialController);
+    }
+
+    /// @dev Accessor that returns the address of the gateway used by this remote executor.
+    function gateway() public view virtual returns (address) {
+        return _gateway;
+    }
+
+    /**
+     * @dev Accessor that returns the interoperable address of the controller allowed to relay instructions to this
+     * remote executor.
+     */
+    function controller() public view virtual returns (bytes memory) {
+        return _controller;
+    }
+
+    /**
+     * @dev Endpoint allowing the controller to reconfigure the executor. This must be called by the executor itself
+     * following an instruction from the controller.
+     */
+    function reconfigure(address newGateway, bytes memory newController) public virtual {
+        require(msg.sender == address(this), AccessRestricted());
+        _setup(newGateway, newController);
+    }
+
+    /// @dev Internal setter to reconfigure the gateway and controller.
+    function _setup(address gateway_, bytes memory controller_) internal virtual {
+        // Sanity check, this should revert if gateway is not an ERC-7786 implementation. Note that since
+        // supportsAttribute returns data, accounts without code would fail that test (nothing returned).
+        IERC7786GatewaySource(gateway_).supportsAttribute(bytes4(0));
+
+        _gateway = gateway_;
+        _controller = controller_;
+
+        emit CrosschainControllerSet(gateway_, controller_);
+    }
+
+    /// @inheritdoc ERC7786Recipient
+    function _isAuthorizedGateway(
+        address instance,
+        bytes calldata sender
+    ) internal view virtual override returns (bool) {
+        return gateway() == instance && controller().equal(sender);
+    }
+
+    /// @inheritdoc ERC7786Recipient
+    function _processMessage(
+        address /*gateway*/,
+        bytes32 /*receiveId*/,
+        bytes calldata /*sender*/,
+        bytes calldata payload
+    ) internal virtual override {
+        // split payload
+        (CallType callType, ExecType execType, , ) = Mode.wrap(bytes32(payload[0x00:0x20])).decodeMode();
+        bytes calldata executionCalldata = payload[0x20:];
+
+        if (callType == ERC7579Utils.CALLTYPE_SINGLE) {
+            executionCalldata.execSingle(execType);
+        } else if (callType == ERC7579Utils.CALLTYPE_BATCH) {
+            executionCalldata.execBatch(execType);
+        } else if (callType == ERC7579Utils.CALLTYPE_DELEGATECALL) {
+            executionCalldata.execDelegateCall(execType);
+        } else revert ERC7579Utils.ERC7579UnsupportedCallType(callType);
+    }
+}

package/lib/openzeppelin-contracts-master/contracts/crosschain/ERC7786Recipient.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.6.0) (crosschain/ERC7786Recipient.sol)
+
+pragma solidity ^0.8.20;
+
+import {IERC7786Recipient} from "../interfaces/draft-IERC7786.sol";
+
+/**
+ * @dev Base implementation of an ERC-7786 compliant cross-chain message receiver.
+ *
+ * This abstract contract exposes the `receiveMessage` function that is used for communication with (one or multiple)
+ * destination gateways. This contract leaves two functions unimplemented:
+ *
+ * * {_isAuthorizedGateway}, an internal getter used to verify whether an address is recognised by the contract as a
+ * valid ERC-7786 destination gateway. One or multiple gateway can be supported. Note that any malicious address for
+ * which this function returns true would be able to impersonate any account on any other chain sending any message.
+ *
+ * * {_processMessage}, the internal function that will be called with any message that has been validated.
+ *
+ * ERC-7786 requires the gateway to ensure messages are not delivered more than once. Therefore, we don't need to keep
+ * track of the processed receiveId.
+ *
+ * @custom:stateless
+ */
+abstract contract ERC7786Recipient is IERC7786Recipient {
+    /// @dev Error thrown if the gateway is not authorized to send messages to this contract on behalf of the sender.
+    error ERC7786RecipientUnauthorizedGateway(address gateway, bytes sender);
+
+    /// @inheritdoc IERC7786Recipient
+    function receiveMessage(
+        bytes32 receiveId,
+        bytes calldata sender, // Binary Interoperable Address
+        bytes calldata payload
+    ) external payable returns (bytes4) {
+        // Check authorization
+        if (!_isAuthorizedGateway(msg.sender, sender)) {
+            revert ERC7786RecipientUnauthorizedGateway(msg.sender, sender);
+        }
+
+        _processMessage(msg.sender, receiveId, sender, payload);
+
+        return IERC7786Recipient.receiveMessage.selector;
+    }
+
+    /**
+     * @dev Virtual getter that returns whether an address is a valid ERC-7786 gateway for a given sender.
+     *
+     * The `sender` parameter is an interoperable address that include the source chain. The chain part can be
+     * extracted using the {InteroperableAddress} library to selectively authorize gateways based on the origin chain
+     * of a message.
+     */
+    function _isAuthorizedGateway(address gateway, bytes calldata sender) internal view virtual returns (bool);
+
+    /**
+     * @dev Virtual function that should contain the logic to execute when a cross-chain message is received.
+     *
+     * NOTE: This function should revert on failure. Any silent failure from this function will result in the message
+     * being marked as received and not being retryable.
+     */
+    function _processMessage(
+        address gateway,
+        bytes32 receiveId,
+        bytes calldata sender,
+        bytes calldata payload
+    ) internal virtual;
+}

package/lib/openzeppelin-contracts-master/contracts/crosschain/README.adoc

@@ -0,0 +1,44 @@
+= Cross chain interoperability
+
+[.readme-notice]
+NOTE: This document is better viewed at https://docs.openzeppelin.com/contracts/api/crosschain
+
+This directory contains contracts for sending and receiving cross chain messages that follows the ERC-7786 standard.
+
+* {CrosschainLinked}: helper to facilitate communication between a contract on one chain and counterparts on remote chains through ERC-7786 gateways.
+* {CrosschainRemoteExecutor}: executor contract that relays transaction from a controller on a remote chain.
+* {ERC7786Recipient}: generic ERC-7786 crosschain contract that receives messages from a trusted gateway.
+
+Additionally there are multiple bridge constructions:
+
+* {BridgeFungible}: Core bridging logic for crosschain ERC-20 transfer. Used by {BridgeERC20}, {BridgeERC7802} and {ERC20Crosschain},
+* {BridgeNonFungible}: Core bridging logic for crosschain ERC-721 transfer. Used by {BridgeERC721} and {ERC721Crosschain},
+* {BridgeMultiToken}: Core bridging logic for crosschain ERC-1155 transfer. Used by {BridgeERC1155} and {ERC1155Crosschain},
+* {BridgeERC20}: Standalone bridge contract to connect an ERC-20 token contract with counterparts on remote chains,
+* {BridgeERC721}: Standalone bridge contract to connect an ERC-721 token contract with counterparts on remote chains,
+* {BridgeERC1155}: Standalone bridge contract to connect an ERC-1155 token contract with counterparts on remote chains,
+* {BridgeERC7802}: Standalone bridge contract to connect an ERC-7802 token contract with counterparts on remote chains.
+
+== Helpers
+
+{{CrosschainLinked}}
+
+{{CrosschainRemoteExecutor}}
+
+{{ERC7786Recipient}}
+
+== Bridges
+
+{{BridgeFungible}}
+
+{{BridgeNonFungible}}
+
+{{BridgeMultiToken}}
+
+{{BridgeERC20}}
+
+{{BridgeERC721}}
+
+{{BridgeERC1155}}
+
+{{BridgeERC7802}}

package/lib/openzeppelin-contracts-master/contracts/crosschain/bridges/BridgeERC1155.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.26;
+
+import {IERC1155} from "../../interfaces/IERC1155.sol";
+import {IERC1155Receiver} from "../../interfaces/IERC1155Receiver.sol";
+import {IERC1155Errors} from "../../interfaces/draft-IERC6093.sol";
+import {ERC1155Holder} from "../../token/ERC1155/utils/ERC1155Holder.sol";
+import {BridgeMultiToken} from "./abstract/BridgeMultiToken.sol";
+
+/**
+ * @dev This is a variant of {BridgeMultiToken} that implements the bridge logic for ERC-1155 tokens that do not expose
+ * a crosschain mint and burn mechanism. Instead, it takes custody of bridged assets.
+ */
+// slither-disable-next-line locked-ether
+abstract contract BridgeERC1155 is BridgeMultiToken, ERC1155Holder {
+    IERC1155 private immutable _token;
+
+    constructor(IERC1155 token_) {
+        _token = token_;
+    }
+
+    /// @dev Return the address of the ERC1155 token this bridge operates on.
+    function token() public view virtual returns (IERC1155) {
+        return _token;
+    }
+
+    /**
+     * @dev Transfer `amount` tokens to a crosschain receiver.
+     *
+     * Note: The `to` parameter is the full InteroperableAddress (chain ref + address).
+     */
+    function crosschainTransferFrom(address from, bytes memory to, uint256 id, uint256 value) public returns (bytes32) {
+        uint256[] memory ids = new uint256[](1);
+        uint256[] memory values = new uint256[](1);
+        ids[0] = id;
+        values[0] = value;
+
+        return crosschainTransferFrom(from, to, ids, values);
+    }
+
+    /**
+     * @dev Transfer `amount` tokens to a crosschain receiver.
+     *
+     * Note: The `to` parameter is the full InteroperableAddress (chain ref + address).
+     */
+    function crosschainTransferFrom(
+        address from,
+        bytes memory to,
+        uint256[] memory ids,
+        uint256[] memory values
+    ) public virtual returns (bytes32) {
+        // Permission is handled using the ERC1155's allowance system. This check replicates `ERC1155._checkAuthorized`.
+        address spender = _msgSender();
+        require(
+            from == spender || token().isApprovedForAll(from, spender),
+            IERC1155Errors.ERC1155MissingApprovalForAll(spender, from)
+        );
+
+        // Perform the crosschain transfer and return the handler
+        return _crosschainTransfer(from, to, ids, values);
+    }
+
+    /// @dev "Locking" tokens is done by taking custody
+    function _onSend(address from, uint256[] memory ids, uint256[] memory values) internal virtual override {
+        token().safeBatchTransferFrom(from, address(this), ids, values, "");
+    }
+
+    /// @dev "Unlocking" tokens is done by releasing custody
+    function _onReceive(address to, uint256[] memory ids, uint256[] memory values) internal virtual override {
+        token().safeBatchTransferFrom(address(this), to, ids, values, "");
+    }
+
+    /// @dev Support receiving tokens only if the transfer was initiated by the bridge itself.
+    function onERC1155Received(
+        address operator,
+        address /* from */,
+        uint256 /* id */,
+        uint256 /* value */,
+        bytes memory /* data */
+    ) public virtual override returns (bytes4) {
+        return
+            msg.sender == address(_token) && operator == address(this)
+                ? IERC1155Receiver.onERC1155Received.selector
+                : bytes4(0);
+    }
+
+    /// @dev Support receiving tokens only if the transfer was initiated by the bridge itself.
+    function onERC1155BatchReceived(
+        address operator,
+        address /* from */,
+        uint256[] memory /* ids */,
+        uint256[] memory /* values */,
+        bytes memory /* data */
+    ) public virtual override returns (bytes4) {
+        return
+            msg.sender == address(_token) && operator == address(this)
+                ? IERC1155Receiver.onERC1155BatchReceived.selector
+                : bytes4(0);
+    }
+}

package/lib/openzeppelin-contracts-master/contracts/crosschain/bridges/BridgeERC20.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.6.0) (crosschain/bridges/BridgeERC20.sol)
+
+pragma solidity ^0.8.26;
+
+import {IERC20, SafeERC20} from "../../token/ERC20/utils/SafeERC20.sol";
+import {BridgeFungible} from "./abstract/BridgeFungible.sol";
+
+/**
+ * @dev This is a variant of {BridgeFungible} that implements the bridge logic for ERC-20 tokens that do not expose a
+ * crosschain mint and burn mechanism. Instead, it takes custody of bridged assets.
+ */
+// slither-disable-next-line locked-ether
+abstract contract BridgeERC20 is BridgeFungible {
+    using SafeERC20 for IERC20;
+
+    IERC20 private immutable _token;
+
+    constructor(IERC20 token_) {
+        _token = token_;
+    }
+
+    /// @dev Return the address of the ERC20 token this bridge operates on.
+    function token() public view virtual returns (IERC20) {
+        return _token;
+    }
+
+    /// @dev "Locking" tokens is done by taking custody
+    function _onSend(address from, uint256 amount) internal virtual override {
+        token().safeTransferFrom(from, address(this), amount);
+    }
+
+    /// @dev "Unlocking" tokens is done by releasing custody
+    function _onReceive(address to, uint256 amount) internal virtual override {
+        token().safeTransfer(to, amount);
+    }
+}

package/lib/openzeppelin-contracts-master/contracts/crosschain/bridges/BridgeERC721.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.26;
+
+import {IERC721} from "../../interfaces/IERC721.sol";
+import {IERC721Errors} from "../../interfaces/draft-IERC6093.sol";
+import {BridgeNonFungible} from "./abstract/BridgeNonFungible.sol";
+
+/**
+ * @dev This is a variant of {BridgeNonFungible} that implements the bridge logic for ERC-721 tokens that do not expose
+ * a crosschain mint and burn mechanism. Instead, it takes custody of bridged assets.
+ */
+// slither-disable-next-line locked-ether
+abstract contract BridgeERC721 is BridgeNonFungible {
+    IERC721 private immutable _token;
+
+    constructor(IERC721 token_) {
+        _token = token_;
+    }
+
+    /// @dev Return the address of the ERC721 token this bridge operates on.
+    function token() public view virtual returns (IERC721) {
+        return _token;
+    }
+
+    /**
+     * @dev Transfer `tokenId` from `from` (on this chain) to `to` (on a different chain).
+     *
+     * The `to` parameter is the full InteroperableAddress that references both the destination chain and the account
+     * on that chain. Similarly to the underlying token's {ERC721-transferFrom} function, this function can be called
+     * either by the token holder or by anyone that is approved by the token holder. It reuses the token's allowance
+     * system, meaning that an account that is "approved for all" or "approved for tokenId" can perform the crosschain
+     * transfer directly without having to take temporary custody of the token.
+     */
+    function crosschainTransferFrom(address from, bytes memory to, uint256 tokenId) public virtual returns (bytes32) {
+        // Permission is handled using the ERC721's allowance system. This check replicates `ERC721._isAuthorized`.
+        address spender = _msgSender();
+        require(
+            from == spender || token().isApprovedForAll(from, spender) || token().getApproved(tokenId) == spender,
+            IERC721Errors.ERC721InsufficientApproval(spender, tokenId)
+        );
+
+        // This call verifies that `from` is the owner of `tokenId` (in `_onSend`), and the previous checks ensure
+        // that `spender` is allowed to move tokenId on behalf of `from`.
+        //
+        // Perform the crosschain transfer and return the send id
+        return _crosschainTransfer(from, to, tokenId);
+    }
+
+    /// @dev "Locking" tokens is done by taking custody
+    function _onSend(address from, uint256 tokenId) internal virtual override {
+        // slither-disable-next-line arbitrary-send-erc20
+        token().transferFrom(from, address(this), tokenId);
+    }
+
+    /// @dev "Unlocking" tokens is done by releasing custody
+    function _onReceive(address to, uint256 tokenId) internal virtual override {
+        // slither-disable-next-line arbitrary-send-erc20
+        token().transferFrom(address(this), to, tokenId);
+    }
+}

package/lib/openzeppelin-contracts-master/contracts/crosschain/bridges/BridgeERC7802.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.6.0) (crosschain/bridges/BridgeERC7802.sol)
+
+pragma solidity ^0.8.26;
+
+import {IERC7802} from "../../interfaces/draft-IERC7802.sol";
+import {BridgeFungible} from "./abstract/BridgeFungible.sol";
+
+/**
+ * @dev This is a variant of {BridgeFungible} that implements the bridge logic for ERC-7802 compliant tokens.
+ */
+// slither-disable-next-line locked-ether
+abstract contract BridgeERC7802 is BridgeFungible {
+    IERC7802 private immutable _token;
+
+    constructor(IERC7802 token_) {
+        _token = token_;
+    }
+
+    /// @dev Return the address of the ERC20 token this bridge operates on.
+    function token() public view virtual returns (IERC7802) {
+        return _token;
+    }
+
+    /// @dev "Locking" tokens using an ERC-7802 crosschain burn
+    function _onSend(address from, uint256 amount) internal virtual override {
+        token().crosschainBurn(from, amount);
+    }
+
+    /// @dev "Unlocking" tokens using an ERC-7802 crosschain mint
+    function _onReceive(address to, uint256 amount) internal virtual override {
+        token().crosschainMint(to, amount);
+    }
+}

package/lib/openzeppelin-contracts-master/contracts/crosschain/bridges/abstract/BridgeFungible.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.6.0) (crosschain/bridges/abstract/BridgeFungible.sol)
+
+pragma solidity ^0.8.26;
+
+import {InteroperableAddress} from "../../../utils/draft-InteroperableAddress.sol";
+import {Context} from "../../../utils/Context.sol";
+import {ERC7786Recipient} from "../../ERC7786Recipient.sol";
+import {CrosschainLinked} from "../../CrosschainLinked.sol";
+
+/**
+ * @dev Base contract for bridging ERC-20 between chains using an ERC-7786 gateway.
+ *
+ * In order to use this contract, two functions must be implemented to link it to the token:
+ * * {_onSend}: called when a crosschain transfer is going out. Must take the sender tokens or revert.
+ * * {_onReceive}: called when a crosschain transfer is coming in. Must give tokens to the receiver.
+ *
+ * This base contract is used by the {BridgeERC20}, which interfaces with legacy ERC-20 tokens, and {BridgeERC7802},
+ * which interface with ERC-7802 to provide an approve-free user experience. It is also used by the {ERC20Crosschain}
+ * extension, which embeds the bridge logic directly in the token contract.
+ */
+abstract contract BridgeFungible is Context, CrosschainLinked {
+    /// @dev Emitted when a crosschain ERC-20 transfer is sent.
+    event CrosschainFungibleTransferSent(bytes32 indexed sendId, address indexed from, bytes to, uint256 amount);
+
+    /// @dev Emitted when a crosschain ERC-20 transfer is received.
+    event CrosschainFungibleTransferReceived(bytes32 indexed receiveId, bytes from, address indexed to, uint256 amount);
+
+    /**
+     * @dev Transfer `amount` tokens to a crosschain receiver.
+     *
+     * Note: The `to` parameter is the full InteroperableAddress (chain ref + address).
+     */
+    function crosschainTransfer(bytes memory to, uint256 amount) public virtual returns (bytes32) {
+        return _crosschainTransfer(_msgSender(), to, amount);
+    }
+
+    /**
+     * @dev Internal crosschain transfer function.
+     *
+     * Note: The `to` parameter is the full InteroperableAddress (chain ref + address).
+     */
+    function _crosschainTransfer(address from, bytes memory to, uint256 amount) internal virtual returns (bytes32) {
+        _onSend(from, amount);
+
+        (bytes2 chainType, bytes memory chainReference, bytes memory addr) = InteroperableAddress.parseV1(to);
+        bytes memory chain = InteroperableAddress.formatV1(chainType, chainReference, hex"");
+
+        bytes32 sendId = _sendMessageToCounterpart(
+            chain,
+            abi.encode(InteroperableAddress.formatEvmV1(block.chainid, from), addr, amount),
+            new bytes[](0)
+        );
+
+        emit CrosschainFungibleTransferSent(sendId, from, to, amount);
+
+        return sendId;
+    }
+
+    /// @inheritdoc ERC7786Recipient
+    function _processMessage(
+        address /*gateway*/,
+        bytes32 receiveId,
+        bytes calldata /*sender*/,
+        bytes calldata payload
+    ) internal virtual override {
+        // NOTE: Gateway is validated by {_isAuthorizedGateway} (implemented in {CrosschainLinked}). No need to check here.
+
+        // split payload
+        (bytes memory from, bytes memory toEvm, uint256 amount) = abi.decode(payload, (bytes, bytes, uint256));
+        address to = address(bytes20(toEvm));
+
+        _onReceive(to, amount);
+
+        emit CrosschainFungibleTransferReceived(receiveId, from, to, amount);
+    }
+
+    /// @dev Virtual function: implementation is required to handle token being burnt or locked on the source chain.
+    function _onSend(address from, uint256 amount) internal virtual;
+
+    /// @dev Virtual function: implementation is required to handle token being minted or unlocked on the destination chain.
+    function _onReceive(address to, uint256 amount) internal virtual;
+}

package/lib/openzeppelin-contracts-master/contracts/crosschain/bridges/abstract/BridgeMultiToken.sol

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.26;
+
+import {InteroperableAddress} from "../../../utils/draft-InteroperableAddress.sol";
+import {Context} from "../../../utils/Context.sol";
+import {ERC7786Recipient} from "../../ERC7786Recipient.sol";
+import {CrosschainLinked} from "../../CrosschainLinked.sol";
+
+/**
+ * @dev Base contract for bridging ERC-1155 between chains using an ERC-7786 gateway.
+ *
+ * In order to use this contract, two functions must be implemented to link it to the token:
+ * * {_onSend}: called when a crosschain transfer is going out. Must take the sender tokens or revert.
+ * * {_onReceive}: called when a crosschain transfer is coming in. Must give tokens to the receiver.
+ *
+ * This base contract is used by the {BridgeERC1155}, which interfaces with legacy ERC-1155 tokens. It is also used by
+ * the {ERC1155Crosschain} extension, which embeds the bridge logic directly in the token contract.
+ *
+ * This base contract implements the crosschain transfer operation though internal functions. It is for the the "child
+ * contracts" that inherit from this to implement the external interfaces and make this functions accessible.
+ */
+abstract contract BridgeMultiToken is Context, CrosschainLinked {
+    using InteroperableAddress for bytes;
+
+    event CrosschainMultiTokenTransferSent(
+        bytes32 indexed sendId,
+        address indexed from,
+        bytes to,
+        uint256[] ids,
+        uint256[] values
+    );
+    event CrosschainMultiTokenTransferReceived(
+        bytes32 indexed receiveId,
+        bytes from,
+        address indexed to,
+        uint256[] ids,
+        uint256[] values
+    );
+    /**
+     * @dev Internal crosschain transfer function.
+     *
+     * Note: The `to` parameter is the full InteroperableAddress (chain ref + address).
+     */
+    function _crosschainTransfer(
+        address from,
+        bytes memory to,
+        uint256[] memory ids,
+        uint256[] memory values
+    ) internal virtual returns (bytes32) {
+        _onSend(from, ids, values);
+
+        (bytes2 chainType, bytes memory chainReference, bytes memory addr) = to.parseV1();
+        bytes memory chain = InteroperableAddress.formatV1(chainType, chainReference, hex"");
+
+        bytes32 sendId = _sendMessageToCounterpart(
+            chain,
+            abi.encode(InteroperableAddress.formatEvmV1(block.chainid, from), addr, ids, values),
+            new bytes[](0)
+        );
+
+        emit CrosschainMultiTokenTransferSent(sendId, from, to, ids, values);
+        return sendId;
+    }
+
+    /// @inheritdoc ERC7786Recipient
+    function _processMessage(
+        address /*gateway*/,
+        bytes32 receiveId,
+        bytes calldata /*sender*/,
+        bytes calldata payload
+    ) internal virtual override {
+        // NOTE: Gateway is validated by {_isAuthorizedGateway} (implemented in {CrosschainLinked}). No need to check here.
+
+        // split payload
+        (bytes memory from, bytes memory toEvm, uint256[] memory ids, uint256[] memory values) = abi.decode(
+            payload,
+            (bytes, bytes, uint256[], uint256[])
+        );
+        address to = address(bytes20(toEvm));
+
+        _onReceive(to, ids, values);
+
+        emit CrosschainMultiTokenTransferReceived(receiveId, from, to, ids, values);
+    }
+
+    /// @dev Virtual function: implementation is required to handle token being burnt or locked on the source chain.
+    function _onSend(address from, uint256[] memory ids, uint256[] memory values) internal virtual;
+
+    /// @dev Virtual function: implementation is required to handle token being minted or unlocked on the destination chain.
+    function _onReceive(address to, uint256[] memory ids, uint256[] memory values) internal virtual;
+}