@layerzerolabs/lz-evm-oapp-v2 2.0.2

package/contracts/oft/OFTPrecrime.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+// import { IOApp } from "../../interfaces/IOApp.sol";
+// import { IOFT } from "./interfaces/IOFT.sol";
+// import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+// import { OFTAdapter } from "./OFTAdapter.sol";
+
+//contract OFTPreCrime is PreCrime {
+//    address public oft;
+//    uint256 public EXPECTED_GLOBAL_SUPPLY;
+//
+//    constructor(address _endpoint, address _oft) PreCrime(_endpoint) {
+//        oft = _oft;
+//    }
+//
+//    struct SimulationResult {
+//        uint256 totalSupplyLD;
+//        bool isAdapter;
+//    }
+//
+//    // @dev only necessary when its exclusive 'OFT', NOT 'OFTAdapter' type
+//    // sum of all tokens in the oft network, it can change, but this will need to be updated for pre-Crime to pass
+//    function setGlobalSupply(uint256 _globalSupply) public onlyPreCrimeAdmin {
+//        EXPECTED_GLOBAL_SUPPLY = _globalSupply;
+//    }
+//
+//    // -------------------------------
+//    // PreCrime
+//    function _receiver() internal view override returns (address) {
+//        return address(oft);
+//    }
+//
+//    function _preCrime(bytes[] memory _simulation) internal view override returns (uint16 code, bytes memory reason) {
+//        uint256 globalSupply;
+//        uint256 expectedGlobalSupply = EXPECTED_GLOBAL_SUPPLY;
+//
+//        // @dev indicates that there is an 'OFTAdapter' on one of the chains, not necessarily this local chain
+//        bool isOFTAdapter;
+//
+//        for (uint256 i = 0; i < _simulation.length; i++) {
+//            SimulationResult memory result = abi.decode(_simulation[i], (SimulationResult));
+//
+//            if (result.isAdapter) {
+//                // @dev does not support multiple' 'OFTAdapter' contracts for a given oft mesh
+//                if (isOFTAdapter) return (CODE_PRECRIME_FAILURE, "OFTPreCrime: multiple OFTAdapters found");
+//                isOFTAdapter = true;
+//
+//                expectedGlobalSupply = result.totalSupplyLD;
+//            } else {
+//                globalSupply += result.totalSupplyLD;
+//            }
+//        }
+//
+//        if (isOFTAdapter && globalSupply > expectedGlobalSupply) {
+//            // @dev expectedGlobal supply for an 'OFTAdapter' can be slightly higher due to users sending tokens direct
+//            // to the OFTAdapter contract, cant check explicitly "=="
+//            return (CODE_PRECRIME_FAILURE, "OFTPreCrime: globalSupply > expectedGlobalSupply");
+//        } else if (globalSupply != expectedGlobalSupply) {
+//            // @dev exclusively 'OFT', NOT 'OFTAdapter' instances, balances should be exactly "=="
+//            return (CODE_PRECRIME_FAILURE, "OFTPreCrime: globalSupply != expectedGlobalSupply");
+//        } else {
+//            return (CODE_SUCCESS, "");
+//        }
+//    }
+//
+//    function simulationCallback() external view override returns (bytes memory result) {
+//        address token = IOFT(oft).token();
+//
+//        // @dev checks if the corresponding _oft on this chain is an adapter version, or returns false if its regular 'OFT'
+//        // eg. 'OFTAdapter' lock/unlock tokens from an external token contract, vs. regular 'OFT' mints/burns
+//        bool isAdapter = token != oft;
+//
+//        // @dev for 'OFTAdapter' the total supply is the total amount locked, otherwise its the totalSupply of oft tokens on the chain
+//        uint256 totalSupply = isAdapter ? IERC20(token).balanceOf(oft) : IERC20(oft).totalSupply();
+//
+//        return abi.encode(SimulationResult(totalSupply, isAdapter));
+//    }
+//
+//    function _simulate(Packet[] calldata _packets) internal override returns (uint16 code, bytes memory simulation) {
+//        (bool success, bytes memory result) = oft.call{value: msg.value}(
+//            abi.encodeWithSelector(IOApp.lzReceiveAndRevert.selector, _packets)
+//        );
+//        require(!success, "OFTPreCrime: simulationCallback should be called via revert");
+//
+//        (, result) = _parseRevertResult(result, LzReceiveRevert.selector);
+//        return (CODE_SUCCESS, result);
+//    }
+//
+//    // @dev need to ensure that all preCrimePeers are present inside of the results passed into _checkResultsCompleteness()
+//    // when checking oft preCrime we always want every simulation/result from the remote peers
+//    function _getPreCrimePeers(
+//        Packet[] calldata /*_packets*/
+//    ) internal view override returns (uint32[] memory eids, bytes32[] memory peers) {
+//        // @dev assumes that the preCrimeEids is the full list of oft eids for this oft mesh
+//        return (preCrimeEids, preCrimePeers);
+//    }
+//}

package/contracts/oft/interfaces/IOFT.sol

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+import { MessagingReceipt, MessagingFee } from "../../oapp/OAppSender.sol";
+
+/**
+ * @dev Struct representing token parameters for the OFT send() operation.
+ */
+struct SendParam {
+    uint32 dstEid; // Destination endpoint ID.
+    bytes32 to; // Recipient address.
+    uint256 amountToSendLD; // Amount to send in local decimals.
+    uint256 minAmountToCreditLD; // Minimum amount to credit in local decimals.
+}
+
+/**
+ * @dev Struct representing OFT limit information.
+ * @dev These amounts can change dynamically and are up the the specific oft implementation.
+ */
+struct OFTLimit {
+    uint256 minAmountLD; // Minimum amount in local decimals that can be sent to the recipient.
+    uint256 maxAmountLD; // Maximum amount in local decimals that can be sent to the recipient.
+}
+
+/**
+ * @dev Struct representing OFT receipt information.
+ */
+struct OFTReceipt {
+    uint256 amountDebitLD; // Amount of tokens ACTUALLY debited in local decimals.
+    // @dev Does not guarantee the recipient will receive the credit amount, as remote implementations can vary depending on the OFT
+    // eg. fees COULD be applied on the remote side, so the recipient may receive less than amountCreditLD
+    uint256 amountCreditLD; // Amount of tokens to be credited on the remote side.
+}
+
+/**
+ * @dev Struct representing OFT fee details.
+ * @dev Future proof mechanism to provide a standardized way to communicate fees to things like a UI.
+ */
+struct OFTFeeDetail {
+    uint256 feeAmountLD; // Amount of the fee in local decimals.
+    string description; // Description of the fee.
+}
+
+/**
+ * @title IOFT
+ * @dev Interface for the OftChain (OFT) token.
+ * @dev Does not inherit ERC20 to accommodate usage by OFTAdapter as well.
+ */
+interface IOFT {
+    // Custom error messages
+    error InvalidLocalDecimals();
+    error SlippageExceeded(uint256 amountToCreditLD, uint256 minAmountToCreditLD);
+
+    // Events
+    event MsgInspectorSet(address inspector);
+    event OFTSent(
+        bytes32 indexed guid, // GUID of the OFT message.
+        address indexed fromAddress, // Address of the sender on the src chain.
+        uint256 amountDebitedLD, // Amount of tokens ACTUALLY debited from the sender in local decimals.
+        uint256 amountToCreditLD, // Amount of tokens to be credited on the remote side in local decimals.
+        bytes composeMsg // Composed message for the send() operation.
+    );
+    event OFTReceived(
+        bytes32 indexed guid, // GUID of the OFT message.
+        address indexed toAddress, // Address of the recipient on the dst chain.
+        uint256 amountToCreditLD, // Amount of tokens to be credited on the remote side in local decimals.
+        uint256 amountReceivedLD // Amount of tokens ACTUALLY received by the recipient in local decimals.
+    );
+
+    /**
+     * @notice Retrieves the major and minor version of the OFT.
+     * @return major The major version.
+     * @return minor The minor version.
+     *
+     * @dev major version: Indicates a cross-chain compatible msg encoding with other OFTs.
+     * @dev minor version: Indicates a version within the local chains context. eg. OFTAdapter vs. OFT
+     * @dev For example, if a new feature is added to the OFT contract, the minor version will be incremented.
+     * @dev If a new feature is added to the OFT cross-chain msg encoding, the major version will be incremented.
+     * ie. localOFT version(1,1) CAN send messages to remoteOFT version(1,2)
+     */
+    function oftVersion() external view returns (uint64 major, uint64 minor);
+
+    /**
+     * @notice Retrieves the address of the token associated with the OFT.
+     * @return token The address of the ERC20 token implementation.
+     */
+    function token() external view returns (address);
+
+    /**
+     * @notice Retrieves the shared decimals of the OFT.
+     * @return sharedDecimals The shared decimals of the OFT.
+     */
+    function sharedDecimals() external view returns (uint8);
+
+    /**
+     * @notice Sets the message inspector address for the OFT.
+     * @param _msgInspector The address of the message inspector.
+     */
+    function setMsgInspector(address _msgInspector) external;
+
+    /**
+     * @notice Retrieves the address of the message inspector.
+     * @return msgInspector The address of the message inspector.
+     */
+    function msgInspector() external view returns (address);
+
+    /**
+     * @notice Provides a quote for OFT-related operations.
+     * @param _sendParam The parameters for the send operation.
+     * @param _oftCmd The OFT command to be executed.
+     * @return limit The OFT limit information.
+     * @return oftFeeDetails The details of OFT fees.
+     * @return receipt The OFT receipt information.
+     */
+    function quoteOFT(
+        SendParam calldata _sendParam,
+        bytes calldata _oftCmd
+    ) external view returns (OFTLimit memory, OFTFeeDetail[] memory oftFeeDetails, OFTReceipt memory);
+
+    /**
+     * @notice Provides a quote for the send() operation.
+     * @param _sendParam The parameters for the send() operation.
+     * @param _extraOptions Additional options supplied by the caller to be used in the LayerZero message.
+     * @param _payInLzToken Flag indicating whether the caller is paying in the LZ token.
+     * @param _composeMsg The composed message for the send() operation.
+     * @param _oftCmd The OFT command to be executed.
+     * @return fee The calculated LayerZero messaging fee from the send() operation.
+     *
+     * @dev MessagingFee: LayerZero msg fee
+     *  - nativeFee: The native fee.
+     *  - lzTokenFee: The lzToken fee.
+     */
+    function quoteSend(
+        SendParam calldata _sendParam,
+        bytes calldata _extraOptions,
+        bool _payInLzToken,
+        bytes calldata _composeMsg,
+        bytes calldata _oftCmd
+    ) external view returns (MessagingFee memory);
+
+    /**
+     * @notice Executes the send() operation.
+     * @param _sendParam The parameters for the send operation.
+     * @param _extraOptions Additional options supplied by the caller to be used in the LayerZero message.
+     * @param _fee The fee information supplied by the caller.
+     *      - nativeFee: The native fee.
+     *      - lzTokenFee: The lzToken fee.
+     * @param _refundAddress The address to receive any excess funds from fees etc. on the src.
+     * @param _composeMsg The composed message for the send() operation.
+     * @param _oftCmd The OFT command to be executed.
+     * @return receipt The LayerZero messaging receipt from the send() operation.
+     * @return oftReceipt The OFT receipt information.
+     *
+     * @dev MessagingReceipt: LayerZero msg receipt
+     *  - guid: The unique identifier for the sent message.
+     *  - nonce: The nonce of the sent message.
+     *  - fee: The LayerZero fee incurred for the message.
+     */
+    function send(
+        SendParam calldata _sendParam,
+        bytes calldata _extraOptions,
+        MessagingFee calldata _fee,
+        address _refundAddress,
+        bytes calldata _composeMsg,
+        bytes calldata _oftCmd
+    ) external payable returns (MessagingReceipt memory, OFTReceipt memory);
+}

package/contracts/oft/libs/OFTComposeMsgCodec.sol

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+library OFTComposeMsgCodec {
+    // Offset constants for decoding composed messages
+    uint8 private constant NONCE_OFFSET = 8;
+    uint8 private constant SRC_EID_OFFSET = 12;
+    uint8 private constant AMOUNT_LD_OFFSET = 44;
+    uint8 private constant COMPOSE_FROM_OFFSET = 76;
+
+    /**
+     * @dev Encodes a OFT composed message.
+     * @param _nonce The nonce value.
+     * @param _srcEid The source endpoint ID.
+     * @param _amountLD The amount in local decimals.
+     * @param _composeMsg The composed message.
+     * @return _msg The encoded Composed message.
+     */
+    function encode(
+        uint64 _nonce,
+        uint32 _srcEid,
+        uint256 _amountLD,
+        bytes memory _composeMsg // 0x[composeFrom][composeMsg]
+    ) internal pure returns (bytes memory _msg) {
+        _msg = abi.encodePacked(_nonce, _srcEid, _amountLD, _composeMsg);
+    }
+
+    /**
+     * @dev Retrieves the nonce from the composed message.
+     * @param _msg The message.
+     * @return The nonce value.
+     */
+    function nonce(bytes calldata _msg) internal pure returns (uint64) {
+        return uint64(bytes8(_msg[:NONCE_OFFSET]));
+    }
+
+    /**
+     * @dev Retrieves the source endpoint ID from the composed message.
+     * @param _msg The message.
+     * @return The source endpoint ID.
+     */
+    function srcEid(bytes calldata _msg) internal pure returns (uint32) {
+        return uint32(bytes4(_msg[NONCE_OFFSET:SRC_EID_OFFSET]));
+    }
+
+    /**
+     * @dev Retrieves the amount in local decimals from the composed message.
+     * @param _msg The message.
+     * @return The amount in local decimals.
+     */
+    function amountLD(bytes calldata _msg) internal pure returns (uint256) {
+        return uint256(bytes32(_msg[SRC_EID_OFFSET:AMOUNT_LD_OFFSET]));
+    }
+
+    /**
+     * @dev Retrieves the composeFrom value from the composed message.
+     * @param _msg The message.
+     * @return The composeFrom value.
+     */
+    function composeFrom(bytes calldata _msg) internal pure returns (bytes32) {
+        return bytes32(_msg[AMOUNT_LD_OFFSET:COMPOSE_FROM_OFFSET]);
+    }
+
+    /**
+     * @dev Retrieves the composed message.
+     * @param _msg The message.
+     * @return The composed message.
+     */
+    function composeMsg(bytes calldata _msg) internal pure returns (bytes memory) {
+        return _msg[COMPOSE_FROM_OFFSET:];
+    }
+
+    /**
+     * @dev Converts an address to bytes32.
+     * @param _addr The address to convert.
+     * @return The bytes32 representation of the address.
+     */
+    function addressToBytes32(address _addr) internal pure returns (bytes32) {
+        return bytes32(uint256(uint160(_addr)));
+    }
+
+    /**
+     * @dev Converts bytes32 to an address.
+     * @param _b The bytes32 value to convert.
+     * @return The address representation of bytes32.
+     */
+    function bytes32ToAddress(bytes32 _b) internal pure returns (address) {
+        return address(uint160(uint256(_b)));
+    }
+}

package/contracts/oft/libs/OFTMsgCodec.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+library OFTMsgCodec {
+    // Offset constants for encoding and decoding OFT messages
+    uint8 private constant SEND_TO_OFFSET = 32;
+    uint8 private constant SEND_AMOUNT_SD_OFFSET = 40;
+
+    /**
+     * @dev Encodes an OFT LayerZero message.
+     * @param _sendTo The recipient address.
+     * @param _amountShared The amount in shared decimals.
+     * @param _composeMsg The composed message.
+     * @return _msg The encoded message.
+     * @return hasCompose A boolean indicating whether the message has a composed payload.
+     */
+    function encode(
+        bytes32 _sendTo,
+        uint64 _amountShared,
+        bytes memory _composeMsg
+    ) internal view returns (bytes memory _msg, bool hasCompose) {
+        hasCompose = _composeMsg.length > 0;
+        // @dev Remote chains will want to know the composed function caller ie. msg.sender on the src.
+        _msg = hasCompose
+            ? abi.encodePacked(_sendTo, _amountShared, addressToBytes32(msg.sender), _composeMsg)
+            : abi.encodePacked(_sendTo, _amountShared);
+    }
+
+    /**
+     * @dev Checks if the OFT message is composed.
+     * @param _msg The OFT message.
+     * @return A boolean indicating whether the message is composed.
+     */
+    function isComposed(bytes calldata _msg) internal pure returns (bool) {
+        return _msg.length > SEND_AMOUNT_SD_OFFSET;
+    }
+
+    /**
+     * @dev Retrieves the recipient address from the OFT message.
+     * @param _msg The OFT message.
+     * @return The recipient address.
+     */
+    function sendTo(bytes calldata _msg) internal pure returns (bytes32) {
+        return bytes32(_msg[:SEND_TO_OFFSET]);
+    }
+
+    /**
+     * @dev Retrieves the amount in shared decimals from the OFT message.
+     * @param _msg The OFT message.
+     * @return The amount in shared decimals.
+     */
+    function amountSD(bytes calldata _msg) internal pure returns (uint64) {
+        return uint64(bytes8(_msg[SEND_TO_OFFSET:SEND_AMOUNT_SD_OFFSET]));
+    }
+
+    /**
+     * @dev Retrieves the composed message from the OFT message.
+     * @param _msg The OFT message.
+     * @return The composed message.
+     */
+    function composeMsg(bytes calldata _msg) internal pure returns (bytes memory) {
+        return _msg[SEND_AMOUNT_SD_OFFSET:];
+    }
+
+    /**
+     * @dev Converts an address to bytes32.
+     * @param _addr The address to convert.
+     * @return The bytes32 representation of the address.
+     */
+    function addressToBytes32(address _addr) internal pure returns (bytes32) {
+        return bytes32(uint256(uint160(_addr)));
+    }
+
+    /**
+     * @dev Converts bytes32 to an address.
+     * @param _b The bytes32 value to convert.
+     * @return The address representation of bytes32.
+     */
+    function bytes32ToAddress(bytes32 _b) internal pure returns (address) {
+        return address(uint160(uint256(_b)));
+    }
+}

package/contracts/precrime/OAppPreCrimeSimulator.sol

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+import { IPreCrime } from "./interfaces/IPreCrime.sol";
+import { IOAppPreCrimeSimulator, InboundPacket, Origin } from "./interfaces/IOAppPreCrimeSimulator.sol";
+
+/**
+ * @title OAppPreCrimeSimulator
+ * @dev Abstract contract serving as the base for preCrime simulation functionality in an OApp.
+ */
+abstract contract OAppPreCrimeSimulator is IOAppPreCrimeSimulator, Ownable {
+    // The address of the preCrime implementation.
+    address public preCrime;
+
+    /**
+     * @dev Retrieves the address of the OApp contract.
+     * @return The address of the OApp contract.
+     *
+     * @dev The simulator contract is the base contract for the OApp by default.
+     * @dev If the simulator is a separate contract, override this function.
+     */
+    function oApp() external view virtual returns (address) {
+        return address(this);
+    }
+
+    /**
+     * @dev Sets the preCrime contract address.
+     * @param _preCrime The address of the preCrime contract.
+     */
+    function setPreCrime(address _preCrime) public virtual onlyOwner {
+        preCrime = _preCrime;
+        emit PreCrimeSet(_preCrime);
+    }
+
+    /**
+     * @dev Interface for pre-crime simulations. Always reverts at the end with the simulation results.
+     * @param _packets An array of InboundPacket objects representing received packets to be delivered.
+     *
+     * @dev WARNING: MUST revert at the end with the simulation results.
+     * @dev Gives the preCrime implementation the ability to mock sending packets to the lzReceive function,
+     * WITHOUT actually executing them.
+     */
+    function lzReceiveAndRevert(InboundPacket[] calldata _packets) public payable virtual {
+        for (uint256 i = 0; i < _packets.length; i++) {
+            InboundPacket calldata packet = _packets[i];
+
+            // Ignore packets that are not from trusted peers.
+            if (!isPeer(packet.origin.srcEid, packet.origin.sender)) continue;
+
+            // @dev Because a verifier is calling this function, it doesnt have access to executor params:
+            //  - address _executor
+            //  - bytes calldata _extraData
+            // preCrime will NOT work for OApps that rely on these two parameters inside of their _lzReceive().
+            // They are instead stubbed to default values, address(0) and bytes("")
+            // @dev Calling this.lzReceiveSimulate removes ability for assembly return 0 callstack exit,
+            // which would cause the revert to be ignored.
+            this.lzReceiveSimulate{ value: packet.value }(
+                packet.origin,
+                packet.guid,
+                packet.message,
+                packet.executor,
+                packet.extraData
+            );
+        }
+
+        // @dev Revert with the simulation results. msg.sender must implement IPreCrime.buildSimulationResult().
+        revert SimulationResult(IPreCrime(msg.sender).buildSimulationResult());
+    }
+
+    /**
+     * @dev Is effectively an internal function because msg.sender must be address(this).
+     * Allows resetting the call stack for 'internal' calls.
+     * @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 _guid The unique identifier of the packet.
+     * @param _message The message payload of the packet.
+     * @param _executor The executor address for the packet.
+     * @param _extraData Additional data for the packet.
+     */
+    function lzReceiveSimulate(
+        Origin calldata _origin,
+        bytes32 _guid,
+        bytes calldata _message,
+        address _executor,
+        bytes calldata _extraData
+    ) external payable virtual {
+        // @dev Ensure ONLY can be called 'internally'.
+        if (msg.sender != address(this)) revert OnlySelf();
+        _lzReceiveSimulate(_origin, _guid, _message, _executor, _extraData);
+    }
+
+    /**
+     * @dev Internal function to handle the OAppPreCrimeSimulator simulated receive.
+     * @param _origin The origin information.
+     *  - srcEid: The source chain endpoint ID.
+     *  - sender: The sender address from the src chain.
+     *  - nonce: The nonce of the LayerZero message.
+     * @param _guid The GUID of the LayerZero message.
+     * @param _message The LayerZero message.
+     * @param _executor The address of the off-chain executor.
+     * @param _extraData Arbitrary data passed by the msg executor.
+     *
+     * @dev Enables the preCrime simulator to mock sending lzReceive() messages,
+     * routes the msg down from the OAppPreCrimeSimulator, and back up to the OAppReceiver.
+     */
+    function _lzReceiveSimulate(
+        Origin calldata _origin,
+        bytes32 _guid,
+        bytes calldata _message,
+        address _executor,
+        bytes calldata _extraData
+    ) internal virtual;
+
+    /**
+     * @dev checks if the specified peer is considered 'trusted' by the OApp.
+     * @param _eid The endpoint Id to check.
+     * @param _peer The peer to check.
+     * @return Whether the peer passed is considered 'trusted' by the OApp.
+     */
+    function isPeer(uint32 _eid, bytes32 _peer) public view virtual returns (bool);
+}