@layerzerolabs/protocol-v2-oapp-evm-contracts 1.2.95

package/contracts/oapp/examples/OmniCounterAbstract.sol

@@ -0,0 +1,285 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import { ILayerZeroEndpointV2, MessagingFee, MessagingReceipt, Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import { ILayerZeroComposer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroComposer.sol";
+
+import { OApp } from "../OApp.sol";
+import { OptionsBuilder } from "../libs/OptionsBuilder.sol";
+import { OAppPreCrimeSimulator } from "../../precrime/OAppPreCrimeSimulator.sol";
+
+library MsgCodec {
+    uint8 internal constant VANILLA_TYPE = 1;
+    uint8 internal constant COMPOSED_TYPE = 2;
+    uint8 internal constant ABA_TYPE = 3;
+    uint8 internal constant COMPOSED_ABA_TYPE = 4;
+
+    uint8 internal constant MSG_TYPE_OFFSET = 0;
+    uint8 internal constant SRC_EID_OFFSET = 1;
+    uint8 internal constant VALUE_OFFSET = 5;
+
+    function encode(uint8 _type, uint32 _srcEid) internal pure returns (bytes memory) {
+        return abi.encodePacked(_type, _srcEid);
+    }
+
+    function encode(uint8 _type, uint32 _srcEid, uint256 _value) internal pure returns (bytes memory) {
+        return abi.encodePacked(_type, _srcEid, _value);
+    }
+
+    function msgType(bytes calldata _message) internal pure returns (uint8) {
+        return uint8(bytes1(_message[MSG_TYPE_OFFSET:SRC_EID_OFFSET]));
+    }
+
+    function srcEid(bytes calldata _message) internal pure returns (uint32) {
+        return uint32(bytes4(_message[SRC_EID_OFFSET:VALUE_OFFSET]));
+    }
+
+    function value(bytes calldata _message) internal pure returns (uint256) {
+        return uint256(bytes32(_message[VALUE_OFFSET:]));
+    }
+}
+
+// @dev declared as abstract to provide backwards compatibility with Oz5/Oz4
+abstract contract OmniCounterAbstract is ILayerZeroComposer, OApp, OAppPreCrimeSimulator {
+    using MsgCodec for bytes;
+    using OptionsBuilder for bytes;
+
+    uint256 public count;
+    uint256 public composedCount;
+
+    address public admin;
+    uint32 public eid;
+
+    mapping(uint32 srcEid => mapping(bytes32 sender => uint64 nonce)) private maxReceivedNonce;
+    bool private orderedNonce;
+
+    // for global assertions
+    mapping(uint32 srcEid => uint256 count) public inboundCount;
+    mapping(uint32 dstEid => uint256 count) public outboundCount;
+
+    constructor(address _endpoint, address _delegate) OApp(_endpoint, _delegate) {
+        admin = msg.sender;
+        eid = ILayerZeroEndpointV2(_endpoint).eid();
+    }
+
+    modifier onlyAdmin() {
+        require(msg.sender == admin, "only admin");
+        _;
+    }
+
+    // -------------------------------
+    // Only Admin
+    function setAdmin(address _admin) external onlyAdmin {
+        admin = _admin;
+    }
+
+    function withdraw(address payable _to, uint256 _amount) external virtual onlyAdmin {
+        (bool success, ) = _to.call{ value: _amount }("");
+        require(success, "OmniCounter: withdraw failed");
+    }
+
+    // -------------------------------
+    // Send
+    function increment(uint32 _eid, uint8 _type, bytes calldata _options) external payable {
+        //        bytes memory options = combineOptions(_eid, _type, _options);
+        _lzSend(_eid, MsgCodec.encode(_type, eid), _options, MessagingFee(msg.value, 0), payable(msg.sender));
+        _incrementOutbound(_eid);
+    }
+
+    // this is a broken function to skip incrementing outbound count
+    // so that preCrime will fail
+    function brokenIncrement(uint32 _eid, uint8 _type, bytes calldata _options) external payable onlyAdmin {
+        //        bytes memory options = combineOptions(_eid, _type, _options);
+        _lzSend(_eid, MsgCodec.encode(_type, eid), _options, MessagingFee(msg.value, 0), payable(msg.sender));
+        // _incrementOutbound(_eid); // mock method which intentionally does not increment outboundCount to cause a PreCrime Crime
+    }
+
+    function batchIncrement(
+        uint32[] calldata _eids,
+        uint8[] calldata _types,
+        bytes[] calldata _options
+    ) external payable virtual {
+        require(_eids.length == _options.length && _eids.length == _types.length, "OmniCounter: length mismatch");
+
+        MessagingReceipt memory receipt;
+        uint256 providedFee = msg.value;
+        for (uint256 i = 0; i < _eids.length; i++) {
+            address refundAddress = i == _eids.length - 1 ? msg.sender : address(this);
+            uint32 dstEid = _eids[i];
+            uint8 msgType = _types[i];
+            //            bytes memory options = combineOptions(dstEid, msgType, _options[i]);
+            receipt = _lzSend(
+                dstEid,
+                MsgCodec.encode(msgType, eid),
+                _options[i],
+                MessagingFee(providedFee, 0),
+                payable(refundAddress)
+            );
+            _incrementOutbound(dstEid);
+            providedFee -= receipt.fee.nativeFee;
+        }
+    }
+
+    // -------------------------------
+    // View
+    function quote(
+        uint32 _eid,
+        uint8 _type,
+        bytes calldata _options
+    ) public view returns (uint256 nativeFee, uint256 lzTokenFee) {
+        //        bytes memory options = combineOptions(_eid, _type, _options);
+        MessagingFee memory fee = _quote(_eid, MsgCodec.encode(_type, eid), _options, false);
+        return (fee.nativeFee, fee.lzTokenFee);
+    }
+
+    // @dev enables preCrime simulator
+    // @dev routes the call down from the OAppPreCrimeSimulator, and up to the OApp
+    function _lzReceiveSimulate(
+        Origin calldata _origin,
+        bytes32 _guid,
+        bytes calldata _message,
+        address _executor,
+        bytes calldata _extraData
+    ) internal virtual override {
+        _lzReceive(_origin, _guid, _message, _executor, _extraData);
+    }
+
+    // -------------------------------
+    function _lzReceive(
+        Origin calldata _origin,
+        bytes32 _guid,
+        bytes calldata _message,
+        address /*_executor*/,
+        bytes calldata /*_extraData*/
+    ) internal override {
+        _acceptNonce(_origin.srcEid, _origin.sender, _origin.nonce);
+        uint8 messageType = _message.msgType();
+
+        if (messageType == MsgCodec.VANILLA_TYPE) {
+            count++;
+
+            //////////////////////////////// IMPORTANT //////////////////////////////////
+            /// if you request for msg.value in the options, you should also encode it
+            /// into your message and check the value received at destination (example below).
+            /// if not, the executor could potentially provide less msg.value than you requested
+            /// leading to unintended behavior. Another option is to assert the executor to be
+            /// one that you trust.
+            /////////////////////////////////////////////////////////////////////////////
+            require(msg.value >= _message.value(), "OmniCounter: insufficient value");
+
+            _incrementInbound(_origin.srcEid);
+        } else if (messageType == MsgCodec.COMPOSED_TYPE || messageType == MsgCodec.COMPOSED_ABA_TYPE) {
+            count++;
+            _incrementInbound(_origin.srcEid);
+            endpoint.sendCompose(address(this), _guid, 0, _message);
+        } else if (messageType == MsgCodec.ABA_TYPE) {
+            count++;
+            _incrementInbound(_origin.srcEid);
+
+            // send back to the sender
+            _incrementOutbound(_origin.srcEid);
+            bytes memory options = OptionsBuilder.newOptions().addExecutorLzReceiveOption(200000, 10);
+            _lzSend(
+                _origin.srcEid,
+                MsgCodec.encode(MsgCodec.VANILLA_TYPE, eid, 10),
+                options,
+                MessagingFee(msg.value, 0),
+                payable(address(this))
+            );
+        } else {
+            revert("invalid message type");
+        }
+    }
+
+    function _incrementInbound(uint32 _srcEid) internal {
+        inboundCount[_srcEid]++;
+    }
+
+    function _incrementOutbound(uint32 _dstEid) internal {
+        outboundCount[_dstEid]++;
+    }
+
+    function lzCompose(
+        address _oApp,
+        bytes32 /*_guid*/,
+        bytes calldata _message,
+        address,
+        bytes calldata
+    ) external payable override {
+        require(_oApp == address(this), "!oApp");
+        require(msg.sender == address(endpoint), "!endpoint");
+
+        uint8 msgType = _message.msgType();
+        if (msgType == MsgCodec.COMPOSED_TYPE) {
+            composedCount += 1;
+        } else if (msgType == MsgCodec.COMPOSED_ABA_TYPE) {
+            composedCount += 1;
+
+            uint32 srcEid = _message.srcEid();
+            _incrementOutbound(srcEid);
+            bytes memory options = OptionsBuilder.newOptions().addExecutorLzReceiveOption(200000, 0);
+            _lzSend(
+                srcEid,
+                MsgCodec.encode(MsgCodec.VANILLA_TYPE, eid),
+                options,
+                MessagingFee(msg.value, 0),
+                payable(address(this))
+            );
+        } else {
+            revert("invalid message type");
+        }
+    }
+
+    // -------------------------------
+    // Ordered OApp
+    // this demonstrates how to build an app that requires execution nonce ordering
+    // normally an app should decide ordered or not on contract construction
+    // this is just a demo
+    function setOrderedNonce(bool _orderedNonce) external onlyOwner {
+        orderedNonce = _orderedNonce;
+    }
+
+    function _acceptNonce(uint32 _srcEid, bytes32 _sender, uint64 _nonce) internal virtual {
+        uint64 currentNonce = maxReceivedNonce[_srcEid][_sender];
+        if (orderedNonce) {
+            require(_nonce == currentNonce + 1, "OApp: invalid nonce");
+        }
+        // update the max nonce anyway. once the ordered mode is turned on, missing early nonces will be rejected
+        if (_nonce > currentNonce) {
+            maxReceivedNonce[_srcEid][_sender] = _nonce;
+        }
+    }
+
+    function nextNonce(uint32 _srcEid, bytes32 _sender) public view virtual override returns (uint64) {
+        if (orderedNonce) {
+            return maxReceivedNonce[_srcEid][_sender] + 1;
+        } else {
+            return 0; // path nonce starts from 1. if 0 it means that there is no specific nonce enforcement
+        }
+    }
+
+    // TODO should override oApp version with added ordered nonce increment
+    // a governance function to skip nonce
+    function skipInboundNonce(uint32 _srcEid, bytes32 _sender, uint64 _nonce) public virtual onlyOwner {
+        endpoint.skip(address(this), _srcEid, _sender, _nonce);
+        if (orderedNonce) {
+            maxReceivedNonce[_srcEid][_sender]++;
+        }
+    }
+
+    function isPeer(uint32 _eid, bytes32 _peer) public view override returns (bool) {
+        return peers[_eid] == _peer;
+    }
+
+    // @dev Batch send requires overriding this function from OAppSender because the msg.value contains multiple fees
+    function _payNative(uint256 _nativeFee) internal virtual override returns (uint256 nativeFee) {
+        if (msg.value < _nativeFee) revert NotEnoughNative(msg.value);
+        return _nativeFee;
+    }
+
+    // be able to receive ether
+    receive() external payable virtual {}
+
+    fallback() external payable virtual {}
+}

package/contracts/oapp/examples/OmniCounterAlt.sol

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import { SafeERC20, IERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import { ILayerZeroEndpointV2, MessagingFee, MessagingReceipt } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import { OAppSender } from "../OAppSender.sol";
+
+import { OmniCounterAbstract, MsgCodec } from "./OmniCounterAbstract.sol";
+
+/**
+ * @title OmniCounterAlt
+ * @dev OmniCounter variant for EndpointV2Alt where the native fee is paid in ERC20 token.
+ * @dev Unaudited contract. Use at your own risk.
+ */
+contract OmniCounterAlt is OmniCounterAbstract {
+    using MsgCodec for bytes;
+    using SafeERC20 for IERC20;
+
+    /// @notice ERC20 token used by EndpointV2Alt as the native fee token.
+    address public immutable feeToken;
+
+    error OmniCounterAlt_NotAnAltEndpoint();
+    error OmniCounterAlt_OnlyAltToken();
+
+    constructor(address _endpoint, address _delegate) OmniCounterAbstract(_endpoint, _delegate) {
+        feeToken = ILayerZeroEndpointV2(_endpoint).nativeToken();
+        if (feeToken == address(0)) revert OmniCounterAlt_NotAnAltEndpoint();
+    }
+
+    /// @dev Override to withdraw ERC20 fee instead of native ETH.
+    function withdraw(address payable _to, uint256 _amount) external virtual override onlyAdmin {
+        IERC20(feeToken).safeTransfer(_to, _amount);
+    }
+
+    /// @dev Override to quote actual fee instead of relying on msg.value.
+    function batchIncrement(
+        uint32[] calldata _eids,
+        uint8[] calldata _types,
+        bytes[] calldata _options
+    ) external payable virtual override {
+        require(_eids.length == _options.length && _eids.length == _types.length, "OmniCounter: length mismatch");
+
+        for (uint256 i = 0; i < _eids.length; i++) {
+            uint32 dstEid = _eids[i];
+
+            bytes memory message = MsgCodec.encode(_types[i], eid);
+            MessagingFee memory fee = _quote(dstEid, message, _options[i], false);
+
+            OAppSender._lzSend(dstEid, message, _options[i], fee, msg.sender);
+            _incrementOutbound(dstEid);
+        }
+    }
+
+    /// @dev Override to quote actual fee since parent passes msg.value (which is 0 for Alt).
+    function _lzSend(
+        uint32 _dstEid,
+        bytes memory _message,
+        bytes memory _options,
+        MessagingFee memory _fee,
+        address _refundAddress
+    ) internal virtual override returns (MessagingReceipt memory receipt) {
+        MessagingFee memory actualFee = _quote(_dstEid, _message, _options, _fee.lzTokenFee > 0);
+        return super._lzSend(_dstEid, _message, _options, actualFee, _refundAddress);
+    }
+
+    /// @dev Transfer ERC20 fee to endpoint instead of native ETH.
+    function _payNative(uint256 _nativeFee) internal override returns (uint256) {
+        if (msg.value != 0) revert OmniCounterAlt_OnlyAltToken();
+        if (_nativeFee > 0) {
+            if (msg.sender == address(endpoint)) {
+                // ABA reply or compose callback - contract pays from its balance
+                IERC20(feeToken).safeTransfer(address(endpoint), _nativeFee);
+            } else {
+                // User-initiated - user pays (must have approved this contract)
+                IERC20(feeToken).safeTransferFrom(msg.sender, address(endpoint), _nativeFee);
+            }
+        }
+        return 0;
+    }
+
+    /// @dev Override to avoid receiving native ETH.
+    receive() external payable virtual override {
+        revert OmniCounterAlt_OnlyAltToken();
+    }
+
+    /// @dev Override to avoid receiving native ETH.
+    fallback() external payable virtual override {
+        revert OmniCounterAlt_OnlyAltToken();
+    }
+}

package/contracts/oapp/examples/OmniCounterPreCrime.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import { PreCrime, PreCrimePeer } from "../../precrime/PreCrime.sol";
+import { InboundPacket } from "../../precrime/libs/Packet.sol";
+import { OmniCounter } from "./OmniCounter.sol";
+
+contract OmniCounterPreCrime is PreCrime {
+    struct ChainCount {
+        uint32 remoteEid;
+        uint256 inboundCount;
+        uint256 outboundCount;
+    }
+
+    constructor(address _endpoint, address _counter) PreCrime(_endpoint, _counter) {}
+
+    function buildSimulationResult() external view override returns (bytes memory) {
+        address payable payableSimulator = payable(simulator);
+        OmniCounter counter = OmniCounter(payableSimulator);
+        ChainCount[] memory chainCounts = new ChainCount[](preCrimePeers.length);
+        for (uint256 i = 0; i < preCrimePeers.length; i++) {
+            uint32 remoteEid = preCrimePeers[i].eid;
+            chainCounts[i] = ChainCount(remoteEid, counter.inboundCount(remoteEid), counter.outboundCount(remoteEid));
+        }
+        return abi.encode(chainCounts);
+    }
+
+    function _preCrime(
+        InboundPacket[] memory /** _packets */,
+        uint32[] memory _eids,
+        bytes[] memory _simulations
+    ) internal view override {
+        uint32 localEid = _getLocalEid();
+        ChainCount[] memory localChainCounts;
+
+        // find local chain counts
+        for (uint256 i = 0; i < _eids.length; i++) {
+            if (_eids[i] == localEid) {
+                localChainCounts = abi.decode(_simulations[i], (ChainCount[]));
+                break;
+            }
+        }
+
+        // local against remote
+        for (uint256 i = 0; i < _eids.length; i++) {
+            uint32 remoteEid = _eids[i];
+            ChainCount[] memory remoteChainCounts = abi.decode(_simulations[i], (ChainCount[]));
+            (uint256 _inboundCount, ) = _findChainCounts(localChainCounts, remoteEid);
+            (, uint256 _outboundCount) = _findChainCounts(remoteChainCounts, localEid);
+            if (_inboundCount > _outboundCount) {
+                revert CrimeFound("inboundCount > outboundCount");
+            }
+        }
+    }
+
+    function _findChainCounts(
+        ChainCount[] memory _chainCounts,
+        uint32 _remoteEid
+    ) internal pure returns (uint256, uint256) {
+        for (uint256 i = 0; i < _chainCounts.length; i++) {
+            if (_chainCounts[i].remoteEid == _remoteEid) {
+                return (_chainCounts[i].inboundCount, _chainCounts[i].outboundCount);
+            }
+        }
+        return (0, 0);
+    }
+
+    function _getPreCrimePeers(
+        InboundPacket[] memory _packets
+    ) internal view override returns (PreCrimePeer[] memory peers) {
+        PreCrimePeer[] memory allPeers = preCrimePeers;
+        PreCrimePeer[] memory peersTmp = new PreCrimePeer[](_packets.length);
+
+        int256 cursor = -1;
+        for (uint256 i = 0; i < _packets.length; i++) {
+            uint32 srcEid = _packets[i].origin.srcEid;
+
+            // push src eid & peer
+            int256 index = _indexOf(allPeers, srcEid);
+            if (index >= 0 && _indexOf(peersTmp, srcEid) < 0) {
+                cursor++;
+                peersTmp[uint256(cursor)] = allPeers[uint256(index)];
+            }
+        }
+        // copy to return
+        if (cursor >= 0) {
+            uint256 len = uint256(cursor) + 1;
+            peers = new PreCrimePeer[](len);
+            for (uint256 i = 0; i < len; i++) {
+                peers[i] = peersTmp[i];
+            }
+        }
+    }
+
+    function _indexOf(PreCrimePeer[] memory _peers, uint32 _eid) internal pure returns (int256) {
+        for (uint256 i = 0; i < _peers.length; i++) {
+            if (_peers[i].eid == _eid) return int256(i);
+        }
+        return -1;
+    }
+}

package/contracts/oapp/interfaces/IOAppComposer.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import { ILayerZeroComposer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroComposer.sol";
+
+/**
+ * @title IOAppComposer
+ * @dev This interface defines the OApp Composer, allowing developers to inherit only the OApp package without the protocol.
+ */
+// solhint-disable-next-line no-empty-blocks
+interface IOAppComposer is ILayerZeroComposer {}

package/contracts/oapp/interfaces/IOAppComputer.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import { IOAppComputerReduce } from "./IOAppComputerReduce.sol";
+import { IOAppComputerMap } from "./IOAppComputerMap.sol";
+
+interface IOAppComputer is IOAppComputerMap, IOAppComputerReduce {}

package/contracts/oapp/interfaces/IOAppComputerMap.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+interface IOAppComputerMap {
+    function lzMap(bytes calldata _request, bytes calldata _response) external view returns (bytes memory);
+}

package/contracts/oapp/interfaces/IOAppComputerReduce.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+interface IOAppComputerReduce {
+    function lzReduce(bytes calldata _cmd, bytes[] calldata _responses) external view returns (bytes memory);
+}

package/contracts/oapp/interfaces/IOAppCore.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import { ILayerZeroEndpointV2 } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+
+/**
+ * @title IOAppCore
+ */
+interface IOAppCore {
+    // Custom error messages
+    error OnlyPeer(uint32 eid, bytes32 sender);
+    error NoPeer(uint32 eid);
+    error InvalidEndpointCall();
+    error InvalidDelegate();
+
+    // Event emitted when a peer (OApp) is set for a corresponding endpoint
+    event PeerSet(uint32 eid, bytes32 peer);
+
+    /**
+     * @notice Retrieves the OApp version information.
+     * @return senderVersion The version of the OAppSender.sol contract.
+     * @return receiverVersion The version of the OAppReceiver.sol contract.
+     */
+    function oAppVersion() external view returns (uint64 senderVersion, uint64 receiverVersion);
+
+    /**
+     * @notice Retrieves the LayerZero endpoint associated with the OApp.
+     * @return iEndpoint The LayerZero endpoint as an interface.
+     */
+    function endpoint() external view returns (ILayerZeroEndpointV2 iEndpoint);
+
+    /**
+     * @notice Retrieves the peer (OApp) associated with a corresponding endpoint.
+     * @param _eid The endpoint ID.
+     * @return peer The peer address (OApp instance) associated with the corresponding endpoint.
+     */
+    function peers(uint32 _eid) external view returns (bytes32 peer);
+
+    /**
+     * @notice Sets the peer address (OApp instance) for a corresponding endpoint.
+     * @param _eid The endpoint ID.
+     * @param _peer The address of the peer to be associated with the corresponding endpoint.
+     */
+    function setPeer(uint32 _eid, bytes32 _peer) external;
+
+    /**
+     * @notice Sets the delegate address for the OApp Core.
+     * @param _delegate The address of the delegate to be set.
+     */
+    function setDelegate(address _delegate) external;
+}

package/contracts/oapp/interfaces/IOAppMsgInspector.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+/**
+ * @title IOAppMsgInspector
+ * @dev Interface for the OApp Message Inspector, allowing examination of message and options contents.
+ */
+interface IOAppMsgInspector {
+    // Custom error message for inspection failure
+    error InspectionFailed(bytes message, bytes options);
+
+    /**
+     * @notice Allows the inspector to examine LayerZero message contents and optionally throw a revert if invalid.
+     * @param _message The message payload to be inspected.
+     * @param _options Additional options or parameters for inspection.
+     * @return valid A boolean indicating whether the inspection passed (true) or failed (false).
+     *
+     * @dev Optionally done as a revert, OR use the boolean provided to handle the failure.
+     */
+    function inspect(bytes calldata _message, bytes calldata _options) external view returns (bool valid);
+}

package/contracts/oapp/interfaces/IOAppOptionsType3.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+/**
+ * @dev Struct representing enforced option parameters.
+ */
+struct EnforcedOptionParam {
+    uint32 eid; // Endpoint ID
+    uint16 msgType; // Message Type
+    bytes options; // Additional options
+}
+
+/**
+ * @title IOAppOptionsType3
+ * @dev Interface for the OApp with Type 3 Options, allowing the setting and combining of enforced options.
+ */
+interface IOAppOptionsType3 {
+    // Custom error message for invalid options
+    error InvalidOptions(bytes options);
+
+    // Event emitted when enforced options are set
+    event EnforcedOptionSet(EnforcedOptionParam[] _enforcedOptions);
+
+    /**
+     * @notice Sets enforced options for specific endpoint and message type combinations.
+     * @param _enforcedOptions An array of EnforcedOptionParam structures specifying enforced options.
+     */
+    function setEnforcedOptions(EnforcedOptionParam[] calldata _enforcedOptions) external;
+
+    /**
+     * @notice Combines options for a given endpoint and message type.
+     * @param _eid The endpoint ID.
+     * @param _msgType The OApp message type.
+     * @param _extraOptions Additional options passed by the caller.
+     * @return options The combination of caller specified options AND enforced options.
+     */
+    function combineOptions(
+        uint32 _eid,
+        uint16 _msgType,
+        bytes calldata _extraOptions
+    ) external view returns (bytes memory options);
+}

package/contracts/oapp/interfaces/IOAppReceiver.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import { ILayerZeroReceiver, Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroReceiver.sol";
+
+interface IOAppReceiver is ILayerZeroReceiver {
+    /**
+     * @notice Indicates whether an address is an approved composeMsg sender to the Endpoint.
+     * @param _origin The origin information containing the source endpoint and sender address.
+     *  - srcEid: The source chain endpoint ID.
+     *  - sender: The sender address on the src chain.
+     *  - nonce: The nonce of the message.
+     * @param _message The lzReceive payload.
+     * @param _sender The sender address.
+     * @return isSender Is a valid sender.
+     *
+     * @dev Applications can optionally choose to implement a separate composeMsg sender that is NOT the bridging layer.
+     * @dev The default sender IS the OAppReceiver implementer.
+     */
+    function isComposeMsgSender(
+        Origin calldata _origin,
+        bytes calldata _message,
+        address _sender
+    ) external view returns (bool isSender);
+}