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

package/contracts/oft/libs/OFTComposeMsgCodec.sol

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+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.20;
+
+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.20;
+
+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);
+}

package/contracts/precrime/PreCrime.sol

@@ -0,0 +1,211 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+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) {
+        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 ordered in ascending order by srcEid, sender, nonce
+        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;
+
+                if (
+                    packet.origin.srcEid < srcEid || (packet.origin.srcEid == srcEid && packet.origin.sender < sender)
+                ) {
+                    revert PacketUnsorted();
+                } else if (packet.origin.srcEid != srcEid || packet.origin.sender != sender) {
+                    // start from a new chain or a new source oApp
+                    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.20;
+
+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) {
+        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.20;
+
+// @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.20;
+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);
+}