@layerzerolabs/lz-evm-oapp-v2 2.0.2

package/contracts/precrime/PreCrime.sol

@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+import { BytesLib } from "solidity-bytes-utils/contracts/BytesLib.sol";
+import { ILayerZeroEndpointV2 } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+
+import { IPreCrime, PreCrimePeer } from "./interfaces/IPreCrime.sol";
+import { IOAppPreCrimeSimulator } from "./interfaces/IOAppPreCrimeSimulator.sol";
+import { InboundPacket, PacketDecoder } from "./libs/Packet.sol";
+
+abstract contract PreCrime is Ownable, IPreCrime {
+    using BytesLib for bytes;
+
+    uint16 internal constant CONFIG_VERSION = 2;
+    address internal constant OFF_CHAIN_CALLER = address(0xDEAD);
+
+    address internal immutable lzEndpoint;
+    address public immutable simulator;
+    address public immutable oApp;
+
+    // preCrime config
+    uint64 public maxBatchSize;
+    PreCrimePeer[] internal preCrimePeers;
+
+    /// @dev getConfig(), simulate() and preCrime() are not view functions because it is more flexible to be able to
+    ///      update state for some complex logic. So onlyOffChain() modifier is to make sure they are only called
+    ///      by the off-chain.
+    modifier onlyOffChain() {
+        if (msg.sender != OFF_CHAIN_CALLER) revert OnlyOffChain();
+        _;
+    }
+
+    constructor(address _endpoint, address _simulator, address _owner) {
+        _transferOwnership(_owner);
+        lzEndpoint = _endpoint;
+        simulator = _simulator;
+        oApp = IOAppPreCrimeSimulator(_simulator).oApp();
+    }
+
+    function setMaxBatchSize(uint64 _maxBatchSize) external onlyOwner {
+        maxBatchSize = _maxBatchSize;
+    }
+
+    function setPreCrimePeers(PreCrimePeer[] calldata _preCrimePeers) external onlyOwner {
+        delete preCrimePeers;
+        for (uint256 i = 0; i < _preCrimePeers.length; ++i) {
+            preCrimePeers.push(_preCrimePeers[i]);
+        }
+    }
+
+    function getPreCrimePeers() external view returns (PreCrimePeer[] memory) {
+        return preCrimePeers;
+    }
+
+    function getConfig(
+        bytes[] calldata _packets,
+        uint256[] calldata _packetMsgValues
+    ) external onlyOffChain returns (bytes memory) {
+        bytes memory config = abi.encodePacked(CONFIG_VERSION, maxBatchSize);
+
+        // if no packets, return config with all peers
+        PreCrimePeer[] memory peers = _packets.length == 0
+            ? preCrimePeers
+            : _getPreCrimePeers(PacketDecoder.decode(_packets, _packetMsgValues));
+
+        if (peers.length > 0) {
+            uint16 size = uint16(peers.length);
+            config = abi.encodePacked(config, size);
+
+            for (uint256 i = 0; i < size; ++i) {
+                config = abi.encodePacked(config, peers[i].eid, peers[i].preCrime, peers[i].oApp);
+            }
+        }
+
+        return config;
+    }
+
+    // @dev _packetMsgValues refers to the 'lzReceive' option passed per packet
+    function simulate(
+        bytes[] calldata _packets,
+        uint256[] calldata _packetMsgValues
+    ) external payable override onlyOffChain returns (bytes memory) {
+        InboundPacket[] memory packets = PacketDecoder.decode(_packets, _packetMsgValues);
+        _checkPacketSizeAndOrder(packets);
+        return _simulate(packets);
+    }
+
+    function preCrime(
+        bytes[] calldata _packets,
+        uint256[] calldata _packetMsgValues,
+        bytes[] calldata _simulations
+    ) external onlyOffChain {
+        InboundPacket[] memory packets = PacketDecoder.decode(_packets, _packetMsgValues);
+        uint32[] memory eids = new uint32[](_simulations.length);
+        bytes[] memory simulations = new bytes[](_simulations.length);
+
+        for (uint256 i = 0; i < _simulations.length; ++i) {
+            bytes calldata simulation = _simulations[i];
+            eids[i] = uint32(bytes4(simulation[0:4]));
+            simulations[i] = simulation[4:];
+        }
+        _checkResultsCompleteness(packets, eids);
+
+        _preCrime(packets, eids, simulations);
+    }
+
+    function version() external pure returns (uint64 major, uint8 minor) {
+        return (2, 0);
+    }
+
+    function _checkResultsCompleteness(InboundPacket[] memory _packets, uint32[] memory _eids) internal {
+        // check if all peers result included
+        if (_packets.length > 0) {
+            PreCrimePeer[] memory peers = _getPreCrimePeers(_packets);
+            for (uint256 i = 0; i < peers.length; i++) {
+                uint32 expectedEid = peers[i].eid;
+                if (!_isContain(_eids, expectedEid)) revert SimulationResultNotFound(expectedEid);
+            }
+        }
+
+        // check if local result included
+        uint32 localEid = _getLocalEid();
+        if (!_isContain(_eids, localEid)) revert SimulationResultNotFound(localEid);
+    }
+
+    function _isContain(uint32[] memory _array, uint32 _item) internal pure returns (bool) {
+        for (uint256 i = 0; i < _array.length; i++) {
+            if (_array[i] == _item) return true;
+        }
+        return false;
+    }
+
+    function _checkPacketSizeAndOrder(InboundPacket[] memory _packets) internal view {
+        if (_packets.length > maxBatchSize) revert PacketOversize(maxBatchSize, _packets.length);
+
+        // check packets nonce, sequence order
+        // packets should group by srcEid and sender, then sort by nonce ascending
+        if (_packets.length > 0) {
+            uint32 srcEid;
+            bytes32 sender;
+            uint64 nonce;
+            for (uint256 i = 0; i < _packets.length; i++) {
+                InboundPacket memory packet = _packets[i];
+
+                // skip if not from trusted peer
+                if (!IOAppPreCrimeSimulator(simulator).isPeer(packet.origin.srcEid, packet.origin.sender)) continue;
+
+                // start from a new chain or a new source oApp
+                if (packet.origin.srcEid != srcEid || packet.origin.sender != sender) {
+                    srcEid = packet.origin.srcEid;
+                    sender = packet.origin.sender;
+                    nonce = _getInboundNonce(srcEid, sender);
+                }
+                // TODO ??
+                // Wont the nonce order not matter and enforced at the OApp level? the simulation will revert?
+
+                // the following packet's nonce add 1 in order
+                if (packet.origin.nonce != ++nonce) revert PacketUnsorted();
+            }
+        }
+    }
+
+    function _simulate(InboundPacket[] memory _packets) internal virtual returns (bytes memory) {
+        (bool success, bytes memory returnData) = simulator.call{ value: msg.value }(
+            abi.encodeWithSelector(IOAppPreCrimeSimulator.lzReceiveAndRevert.selector, _packets)
+        );
+
+        bytes memory result = _parseRevertResult(success, returnData);
+        return abi.encodePacked(_getLocalEid(), result); // add localEid at the first of the result
+    }
+
+    function _parseRevertResult(bool _success, bytes memory _returnData) internal pure returns (bytes memory result) {
+        // should always revert with LzReceiveRevert
+        if (_success) revert SimulationFailed("no revert");
+
+        // if not expected selector, bubble up error
+        if (bytes4(_returnData) != IOAppPreCrimeSimulator.SimulationResult.selector) {
+            revert SimulationFailed(_returnData);
+        }
+
+        // Slice the sighash. Remove the selector which is the first 4 bytes
+        result = _returnData.slice(4, _returnData.length - 4);
+        result = abi.decode(result, (bytes));
+    }
+
+    // to be compatible with EndpointV1
+    function _getLocalEid() internal view virtual returns (uint32) {
+        return ILayerZeroEndpointV2(lzEndpoint).eid();
+    }
+
+    // to be compatible with EndpointV1
+    function _getInboundNonce(uint32 _srcEid, bytes32 _sender) internal view virtual returns (uint64) {
+        return ILayerZeroEndpointV2(lzEndpoint).inboundNonce(oApp, _srcEid, _sender);
+    }
+
+    // ----------------- to be implemented -----------------
+    function buildSimulationResult() external view virtual override returns (bytes memory);
+
+    function _getPreCrimePeers(InboundPacket[] memory _packets) internal virtual returns (PreCrimePeer[] memory peers);
+
+    function _preCrime(
+        InboundPacket[] memory _packets,
+        uint32[] memory _eids,
+        bytes[] memory _simulations
+    ) internal virtual;
+}

package/contracts/precrime/extensions/PreCrimeE1.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+
+import { ILayerZeroEndpoint } from "@layerzerolabs/lz-evm-v1-0.7/contracts/interfaces/ILayerZeroEndpoint.sol";
+
+import { PreCrime } from "../PreCrime.sol";
+
+abstract contract PreCrimeE1 is PreCrime {
+    using SafeCast for uint32;
+
+    uint32 internal immutable localEid;
+
+    constructor(uint32 _localEid, address _endpoint, address _simulator) PreCrime(_endpoint, _simulator, msg.sender) {
+        localEid = _localEid;
+    }
+
+    function _getLocalEid() internal view override returns (uint32) {
+        return localEid;
+    }
+
+    function _getInboundNonce(uint32 _srcEid, bytes32 _sender) internal view override returns (uint64) {
+        bytes memory path = _getPath(_srcEid, _sender);
+        return ILayerZeroEndpoint(lzEndpoint).getInboundNonce(_srcEid.toUint16(), path);
+    }
+
+    function _getPath(uint32 _srcEid, bytes32 _sender) internal view virtual returns (bytes memory);
+}

package/contracts/precrime/interfaces/IOAppPreCrimeSimulator.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+// @dev Import the Origin so it's exposed to OAppPreCrimeSimulator implementers.
+// solhint-disable-next-line no-unused-import
+import { InboundPacket, Origin } from "../libs/Packet.sol";
+
+/**
+ * @title IOAppPreCrimeSimulator Interface
+ * @dev Interface for the preCrime simulation functionality in an OApp.
+ */
+interface IOAppPreCrimeSimulator {
+    // @dev simulation result used in PreCrime implementation
+    error SimulationResult(bytes result);
+    error OnlySelf();
+
+    /**
+     * @dev Emitted when the preCrime contract address is set.
+     * @param preCrimeAddress The address of the preCrime contract.
+     */
+    event PreCrimeSet(address preCrimeAddress);
+
+    /**
+     * @dev Retrieves the address of the preCrime contract implementation.
+     * @return The address of the preCrime contract.
+     */
+    function preCrime() external view returns (address);
+
+    /**
+     * @dev Retrieves the address of the OApp contract.
+     * @return The address of the OApp contract.
+     */
+    function oApp() external view returns (address);
+
+    /**
+     * @dev Sets the preCrime contract address.
+     * @param _preCrime The address of the preCrime contract.
+     */
+    function setPreCrime(address _preCrime) external;
+
+    /**
+     * @dev Mocks receiving a packet, then reverts with a series of data to infer the state/result.
+     * @param _packets An array of LayerZero InboundPacket objects representing received packets.
+     */
+    function lzReceiveAndRevert(InboundPacket[] calldata _packets) external payable;
+
+    /**
+     * @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) external view returns (bool);
+}

package/contracts/precrime/interfaces/IPreCrime.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+struct PreCrimePeer {
+    uint32 eid;
+    bytes32 preCrime;
+    bytes32 oApp;
+}
+
+// TODO not done yet
+interface IPreCrime {
+    error OnlyOffChain();
+
+    // for simulate()
+    error PacketOversize(uint256 max, uint256 actual);
+    error PacketUnsorted();
+    error SimulationFailed(bytes reason);
+
+    // for preCrime()
+    error SimulationResultNotFound(uint32 eid);
+    error InvalidSimulationResult(uint32 eid, bytes reason);
+    error CrimeFound(bytes crime);
+
+    function getConfig(bytes[] calldata _packets, uint256[] calldata _packetMsgValues) external returns (bytes memory);
+
+    function simulate(
+        bytes[] calldata _packets,
+        uint256[] calldata _packetMsgValues
+    ) external payable returns (bytes memory);
+
+    function buildSimulationResult() external view returns (bytes memory);
+
+    function preCrime(
+        bytes[] calldata _packets,
+        uint256[] calldata _packetMsgValues,
+        bytes[] calldata _simulations
+    ) external;
+
+    function version() external view returns (uint64 major, uint8 minor);
+}

package/contracts/precrime/libs/Packet.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+import { Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import { PacketV1Codec } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/PacketV1Codec.sol";
+
+/**
+ * @title InboundPacket
+ * @dev Structure representing an inbound packet received by the contract.
+ */
+struct InboundPacket {
+    Origin origin; // Origin information of the packet.
+    uint32 dstEid; // Destination endpointId of the packet.
+    address receiver; // Receiver address for the packet.
+    bytes32 guid; // Unique identifier of the packet.
+    uint256 value; // msg.value of the packet.
+    address executor; // Executor address for the packet.
+    bytes message; // Message payload of the packet.
+    bytes extraData; // Additional arbitrary data for the packet.
+}
+
+/**
+ * @title PacketDecoder
+ * @dev Library for decoding LayerZero packets.
+ */
+library PacketDecoder {
+    using PacketV1Codec for bytes;
+
+    /**
+     * @dev Decode an inbound packet from the given packet data.
+     * @param _packet The packet data to decode.
+     * @return packet An InboundPacket struct representing the decoded packet.
+     */
+    function decode(bytes calldata _packet) internal pure returns (InboundPacket memory packet) {
+        packet.origin = Origin(_packet.srcEid(), _packet.sender(), _packet.nonce());
+        packet.dstEid = _packet.dstEid();
+        packet.receiver = _packet.receiverB20();
+        packet.guid = _packet.guid();
+        packet.message = _packet.message();
+    }
+
+    /**
+     * @dev Decode multiple inbound packets from the given packet data and associated message values.
+     * @param _packets An array of packet data to decode.
+     * @param _packetMsgValues An array of associated message values for each packet.
+     * @return packets An array of InboundPacket structs representing the decoded packets.
+     */
+    function decode(
+        bytes[] calldata _packets,
+        uint256[] memory _packetMsgValues
+    ) internal pure returns (InboundPacket[] memory packets) {
+        packets = new InboundPacket[](_packets.length);
+        for (uint256 i = 0; i < _packets.length; i++) {
+            bytes calldata packet = _packets[i];
+            packets[i] = PacketDecoder.decode(packet);
+            // @dev Allows the verifier to specify the msg.value that gets passed in lzReceive.
+            packets[i].value = _packetMsgValues[i];
+        }
+    }
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@layerzerolabs/lz-evm-oapp-v2",
+  "version": "2.0.2",
+  "license": "LZBL-1.2",
+  "files": [
+    "artifacts/contracts/**/!(*.dbg).json",
+    "contracts/**/*"
+  ],
+  "scripts": {
+    "postpack": "node ./scripts/pack.mjs --postpack"
+  },
+  "dependencies": {
+    "@layerzerolabs/lz-evm-messagelib-v2": "^2.0.2",
+    "@layerzerolabs/lz-evm-protocol-v2": "^2.0.2",
+    "@layerzerolabs/lz-evm-v1-0.7": "^2.0.2"
+  },
+  "devDependencies": {
+    "@openzeppelin/contracts": "^4.8.1",
+    "@openzeppelin/contracts-upgradeable": "^4.8.1",
+    "hardhat-deploy": "^0.11.44",
+    "hardhat-deploy-ethers": "^0.3.0-beta.13",
+    "solidity-bytes-utils": "^0.8.0"
+  },
+  "peerDependencies": {
+    "solidity-bytes-utils": "^0.8.0"
+  },
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "lzVersions": {
+    "default": [
+      "v2"
+    ]
+  }
+}