@layerzerolabs/protocol-v2-evm-contracts 1.2.95

package/contracts/messagelib/SimpleMessageLib.sol

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import { ERC165 } from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+
+import { IMessageLib, MessageLibType } from "../interfaces/IMessageLib.sol";
+import { Packet } from "../interfaces/ISendLib.sol";
+import { ILayerZeroEndpointV2, MessagingFee, Origin } from "../interfaces/ILayerZeroEndpointV2.sol";
+import { Errors } from "../libs/Errors.sol";
+import { PacketV1Codec } from "./libs/PacketV1Codec.sol";
+import { Transfer } from "../libs/Transfer.sol";
+
+contract SimpleMessageLib is Ownable, ERC165 {
+    using SafeERC20 for IERC20;
+    using PacketV1Codec for bytes;
+
+    address public immutable endpoint;
+    address public immutable treasury;
+    uint32 public immutable localEid;
+    uint8 public constant PACKET_VERSION = 1;
+
+    address public whitelistCaller;
+
+    uint256 public lzTokenFee;
+    uint256 public nativeFee;
+
+    bytes public defaultOption;
+
+    error OnlyEndpoint();
+    error OnlyWhitelistCaller();
+    error InvalidEndpoint(address expected, address actual);
+    error ToIsAddressZero();
+    error LzTokenIsAddressZero();
+    error TransferFailed();
+
+    // only the endpoint can call SEND() and setConfig()
+    modifier onlyEndpoint() {
+        if (endpoint != msg.sender) {
+            revert OnlyEndpoint();
+        }
+        _;
+    }
+
+    constructor(address _endpoint, address _treasury) {
+        endpoint = _endpoint;
+        treasury = _treasury;
+        localEid = ILayerZeroEndpointV2(_endpoint).eid();
+        lzTokenFee = 99;
+        nativeFee = 100;
+        //        defaultOption = Options.encodeLegacyOptionsType1(200000);
+    }
+
+    function supportsInterface(bytes4 interfaceId) public view override returns (bool) {
+        return interfaceId == type(IMessageLib).interfaceId || super.supportsInterface(interfaceId);
+    }
+
+    // no validation logic at all
+    function validatePacket(bytes calldata packetBytes) external {
+        if (whitelistCaller != address(0x0) && msg.sender != whitelistCaller) {
+            revert OnlyWhitelistCaller();
+        }
+        Origin memory origin = Origin(packetBytes.srcEid(), packetBytes.sender(), packetBytes.nonce());
+        ILayerZeroEndpointV2(endpoint).verify(origin, packetBytes.receiverB20(), keccak256(packetBytes.payload()));
+    }
+
+    // ------------------ onlyEndpoint ------------------
+    function send(
+        Packet calldata _packet,
+        bytes memory _options,
+        bool _payInLzToken
+    ) external onlyEndpoint returns (MessagingFee memory fee, bytes memory encodedPacket, bytes memory options) {
+        encodedPacket = PacketV1Codec.encode(_packet);
+
+        options = _options.length == 0 ? defaultOption : _options;
+        _handleMessagingParamsHook(encodedPacket, options);
+
+        fee = MessagingFee(nativeFee, _payInLzToken ? lzTokenFee : 0);
+    }
+
+    // ------------------ onlyOwner ------------------
+    function setDefaultOption(bytes memory _defaultOption) external onlyOwner {
+        defaultOption = _defaultOption;
+    }
+
+    function setMessagingFee(uint256 _nativeFee, uint256 _lzTokenFee) external onlyOwner {
+        nativeFee = _nativeFee;
+        lzTokenFee = _lzTokenFee;
+    }
+
+    function setWhitelistCaller(address _whitelistCaller) external onlyOwner {
+        whitelistCaller = _whitelistCaller;
+    }
+
+    function withdrawFee(address _to, uint256 _amount) external onlyOwner {
+        if (_to == address(0x0)) {
+            revert ToIsAddressZero();
+        }
+
+        address altTokenAddr = ILayerZeroEndpointV2(endpoint).nativeToken();
+
+        // transfers native if altTokenAddr == address(0x0)
+        Transfer.nativeOrToken(altTokenAddr, _to, _amount);
+    }
+
+    function withdrawLzTokenFee(address _to, uint256 _amount) external onlyOwner {
+        if (_to == address(0x0)) {
+            revert ToIsAddressZero();
+        }
+        address lzToken = ILayerZeroEndpointV2(endpoint).lzToken();
+        if (lzToken == address(0x0)) {
+            revert LzTokenIsAddressZero();
+        }
+        IERC20(lzToken).safeTransfer(_to, _amount);
+    }
+
+    // ------------------ View ------------------
+    function quote(
+        Packet calldata /*_packet*/,
+        bytes calldata /*_options*/,
+        bool _payInLzToken
+    ) external view returns (MessagingFee memory) {
+        return MessagingFee(nativeFee, _payInLzToken ? lzTokenFee : 0);
+    }
+
+    function isSupportedEid(uint32) external pure returns (bool) {
+        return true;
+    }
+
+    function version() external pure returns (uint64 major, uint8 minor, uint8 endpointVersion) {
+        return (0, 0, 2);
+    }
+
+    function messageLibType() external pure returns (MessageLibType) {
+        return MessageLibType.SendAndReceive;
+    }
+
+    // ------------------ Internal ------------------
+    function _handleMessagingParamsHook(bytes memory _encodedPacket, bytes memory _options) internal virtual {}
+
+    fallback() external payable {
+        revert Errors.LZ_NotImplemented();
+    }
+
+    receive() external payable {}
+}

package/contracts/messagelib/libs/BitMaps.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+
+// modified from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/structs/BitMaps.sol
+pragma solidity ^0.8.20;
+
+type BitMap256 is uint256;
+
+using BitMaps for BitMap256 global;
+
+library BitMaps {
+    /**
+     * @dev Returns whether the bit at `index` is set.
+     */
+    function get(BitMap256 bitmap, uint8 index) internal pure returns (bool) {
+        uint256 mask = 1 << index;
+        return BitMap256.unwrap(bitmap) & mask != 0;
+    }
+
+    /**
+     * @dev Sets the bit at `index`.
+     */
+    function set(BitMap256 bitmap, uint8 index) internal pure returns (BitMap256) {
+        uint256 mask = 1 << index;
+        return BitMap256.wrap(BitMap256.unwrap(bitmap) | mask);
+    }
+}

package/contracts/messagelib/libs/ExecutorOptions.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { CalldataBytesLib } from "../../libs/CalldataBytesLib.sol";
+
+library ExecutorOptions {
+    using CalldataBytesLib for bytes;
+
+    uint8 internal constant WORKER_ID = 1;
+
+    uint8 internal constant OPTION_TYPE_LZRECEIVE = 1;
+    uint8 internal constant OPTION_TYPE_NATIVE_DROP = 2;
+    uint8 internal constant OPTION_TYPE_LZCOMPOSE = 3;
+    uint8 internal constant OPTION_TYPE_ORDERED_EXECUTION = 4;
+
+    error Executor_InvalidLzReceiveOption();
+    error Executor_InvalidNativeDropOption();
+    error Executor_InvalidLzComposeOption();
+
+    /// @dev decode the next executor option from the options starting from the specified cursor
+    /// @param _options [executor_id][executor_option][executor_id][executor_option]...
+    ///        executor_option = [option_size][option_type][option]
+    ///        option_size = len(option_type) + len(option)
+    ///        executor_id: uint8, option_size: uint16, option_type: uint8, option: bytes
+    /// @param _cursor the cursor to start decoding from
+    /// @return optionType the type of the option
+    /// @return option the option of the executor
+    /// @return cursor the cursor to start decoding the next executor option
+    function nextExecutorOption(
+        bytes calldata _options,
+        uint256 _cursor
+    ) internal pure returns (uint8 optionType, bytes calldata option, uint256 cursor) {
+        unchecked {
+            // skip worker id
+            cursor = _cursor + 1;
+
+            // read option size
+            uint16 size = _options.toU16(cursor);
+            cursor += 2;
+
+            // read option type
+            optionType = _options.toU8(cursor);
+
+            // startCursor and endCursor are used to slice the option from _options
+            uint256 startCursor = cursor + 1; // skip option type
+            uint256 endCursor = cursor + size;
+            option = _options[startCursor:endCursor];
+            cursor += size;
+        }
+    }
+
+    function decodeLzReceiveOption(bytes calldata _option) internal pure returns (uint128 gas, uint128 value) {
+        if (_option.length != 16 && _option.length != 32) revert Executor_InvalidLzReceiveOption();
+        gas = _option.toU128(0);
+        value = _option.length == 32 ? _option.toU128(16) : 0;
+    }
+
+    function decodeNativeDropOption(bytes calldata _option) internal pure returns (uint128 amount, bytes32 receiver) {
+        if (_option.length != 48) revert Executor_InvalidNativeDropOption();
+        amount = _option.toU128(0);
+        receiver = _option.toB32(16);
+    }
+
+    function decodeLzComposeOption(
+        bytes calldata _option
+    ) internal pure returns (uint16 index, uint128 gas, uint128 value) {
+        if (_option.length != 18 && _option.length != 34) revert Executor_InvalidLzComposeOption();
+        index = _option.toU16(0);
+        gas = _option.toU128(2);
+        value = _option.length == 34 ? _option.toU128(18) : 0;
+    }
+
+    function encodeLzReceiveOption(uint128 _gas, uint128 _value) internal pure returns (bytes memory) {
+        return _value == 0 ? abi.encodePacked(_gas) : abi.encodePacked(_gas, _value);
+    }
+
+    function encodeNativeDropOption(uint128 _amount, bytes32 _receiver) internal pure returns (bytes memory) {
+        return abi.encodePacked(_amount, _receiver);
+    }
+
+    function encodeLzComposeOption(uint16 _index, uint128 _gas, uint128 _value) internal pure returns (bytes memory) {
+        return _value == 0 ? abi.encodePacked(_index, _gas) : abi.encodePacked(_index, _gas, _value);
+    }
+}

package/contracts/messagelib/libs/PacketV1Codec.sol

@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { Packet } from "../../interfaces/ISendLib.sol";
+import { AddressCast } from "../../libs/AddressCast.sol";
+
+library PacketV1Codec {
+    using AddressCast for address;
+    using AddressCast for bytes32;
+
+    uint8 internal constant PACKET_VERSION = 1;
+
+    // header (version + nonce + path)
+    // version
+    uint256 private constant PACKET_VERSION_OFFSET = 0;
+    //    nonce
+    uint256 private constant NONCE_OFFSET = 1;
+    //    path
+    uint256 private constant SRC_EID_OFFSET = 9;
+    uint256 private constant SENDER_OFFSET = 13;
+    uint256 private constant DST_EID_OFFSET = 45;
+    uint256 private constant RECEIVER_OFFSET = 49;
+    // payload (guid + message)
+    uint256 private constant GUID_OFFSET = 81; // keccak256(nonce + path)
+    uint256 private constant MESSAGE_OFFSET = 113;
+
+    function encode(Packet memory _packet) internal pure returns (bytes memory encodedPacket) {
+        encodedPacket = abi.encodePacked(
+            PACKET_VERSION,
+            _packet.nonce,
+            _packet.srcEid,
+            _packet.sender.toBytes32(),
+            _packet.dstEid,
+            _packet.receiver,
+            _packet.guid,
+            _packet.message
+        );
+    }
+
+    function encodePacketHeader(Packet memory _packet) internal pure returns (bytes memory) {
+        return
+            abi.encodePacked(
+                PACKET_VERSION,
+                _packet.nonce,
+                _packet.srcEid,
+                _packet.sender.toBytes32(),
+                _packet.dstEid,
+                _packet.receiver
+            );
+    }
+
+    function encodePayload(Packet memory _packet) internal pure returns (bytes memory) {
+        return abi.encodePacked(_packet.guid, _packet.message);
+    }
+
+    function header(bytes calldata _packet) internal pure returns (bytes calldata) {
+        return _packet[0:GUID_OFFSET];
+    }
+
+    function version(bytes calldata _packet) internal pure returns (uint8) {
+        return uint8(bytes1(_packet[PACKET_VERSION_OFFSET:NONCE_OFFSET]));
+    }
+
+    function nonce(bytes calldata _packet) internal pure returns (uint64) {
+        return uint64(bytes8(_packet[NONCE_OFFSET:SRC_EID_OFFSET]));
+    }
+
+    function srcEid(bytes calldata _packet) internal pure returns (uint32) {
+        return uint32(bytes4(_packet[SRC_EID_OFFSET:SENDER_OFFSET]));
+    }
+
+    function sender(bytes calldata _packet) internal pure returns (bytes32) {
+        return bytes32(_packet[SENDER_OFFSET:DST_EID_OFFSET]);
+    }
+
+    function senderAddressB20(bytes calldata _packet) internal pure returns (address) {
+        return sender(_packet).toAddress();
+    }
+
+    function dstEid(bytes calldata _packet) internal pure returns (uint32) {
+        return uint32(bytes4(_packet[DST_EID_OFFSET:RECEIVER_OFFSET]));
+    }
+
+    function receiver(bytes calldata _packet) internal pure returns (bytes32) {
+        return bytes32(_packet[RECEIVER_OFFSET:GUID_OFFSET]);
+    }
+
+    function receiverB20(bytes calldata _packet) internal pure returns (address) {
+        return receiver(_packet).toAddress();
+    }
+
+    function guid(bytes calldata _packet) internal pure returns (bytes32) {
+        return bytes32(_packet[GUID_OFFSET:MESSAGE_OFFSET]);
+    }
+
+    function message(bytes calldata _packet) internal pure returns (bytes calldata) {
+        return bytes(_packet[MESSAGE_OFFSET:]);
+    }
+
+    function payload(bytes calldata _packet) internal pure returns (bytes calldata) {
+        return bytes(_packet[GUID_OFFSET:]);
+    }
+
+    function payloadHash(bytes calldata _packet) internal pure returns (bytes32) {
+        return keccak256(payload(_packet));
+    }
+}

package/contracts/proxy/TransparentUpgradeableProxy.sol

@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: MIT
+
+// OpenZeppelin Contracts v4.4.1 (proxy/transparent/TransparentUpgradeableProxy.sol)
+
+pragma solidity ^0.8.0;
+
+import { ERC1967Proxy } from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+
+/**
+ * @author OpenZeppelin. Modified from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v4.4/contracts/proxy/transparent/TransparentUpgradeableProxy.sol
+ * to support custom errors.
+ * @dev This contract implements a proxy that is upgradeable by an admin.
+ *
+ * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector
+ * clashing], which can potentially be used in an attack, this contract uses the
+ * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two
+ * things that go hand in hand:
+ *
+ * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if
+ * that call matches one of the admin functions exposed by the proxy itself.
+ * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the
+ * implementation. If the admin tries to call a function on the implementation it will fail with an error indicating
+ * the proxy admin cannot fallback to the target implementation.
+ *
+ * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing
+ * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due
+ * to sudden errors when trying to call a function from the proxy implementation.
+ *
+ * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,
+ * you should think of the `ProxyAdmin` instance as the real administrative interface of your proxy.
+ */
+contract TransparentUpgradeableProxy is ERC1967Proxy {
+    /**
+     * @dev The proxy caller is the current admin, and can't fallback to the proxy target.
+     */
+    error AdminAccessDenied();
+
+    /**
+     * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and
+     * optionally initialized with `_data` as explained in {ERC1967Proxy-constructor}.
+     */
+    constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) {
+        assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
+        _changeAdmin(admin_);
+    }
+
+    /**
+     * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.
+     */
+    modifier ifAdmin() {
+        if (msg.sender == _getAdmin()) {
+            _;
+        } else {
+            _fallback();
+        }
+    }
+
+    /**
+     * @dev Returns the current admin.
+     *
+     * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.
+     *
+     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
+     * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
+     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
+     */
+    function admin() external ifAdmin returns (address admin_) {
+        admin_ = _getAdmin();
+    }
+
+    /**
+     * @dev Returns the current implementation.
+     *
+     * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.
+     *
+     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
+     * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
+     * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
+     */
+    function implementation() external ifAdmin returns (address implementation_) {
+        implementation_ = _implementation();
+    }
+
+    /**
+     * @dev Changes the admin of the proxy.
+     *
+     * Emits an {AdminChanged} event.
+     *
+     * NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.
+     */
+    function changeAdmin(address newAdmin) external virtual ifAdmin {
+        _changeAdmin(newAdmin);
+    }
+
+    /**
+     * @dev Upgrade the implementation of the proxy.
+     *
+     * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.
+     */
+    function upgradeTo(address newImplementation) external ifAdmin {
+        _upgradeToAndCall(newImplementation, bytes(""), false);
+    }
+
+    /**
+     * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified
+     * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the
+     * proxied contract.
+     *
+     * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.
+     */
+    function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
+        _upgradeToAndCall(newImplementation, data, true);
+    }
+
+    /**
+     * @dev Returns the current admin.
+     */
+    function _admin() internal view virtual returns (address) {
+        return _getAdmin();
+    }
+
+    /**
+     * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.
+     */
+    function _beforeFallback() internal virtual override {
+        if (msg.sender == _getAdmin()) {
+            revert AdminAccessDenied();
+        }
+        super._beforeFallback();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The contract artifacts are the product of this package: read them by path, e.g.
+ * `@layerzerolabs/protocol-v2-evm-contracts/artifacts/contracts/<Source>.sol/<Contract>.json`
+ * (`artifacts-zk/` for zkSync, `artifacts-tron/` for Tron).
+ */
+export declare const PACKAGE_NAME = "@layerzerolabs/protocol-v2-evm-contracts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,YAAY,6CAA6C,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+// src/index.ts
+var PACKAGE_NAME = "@layerzerolabs/protocol-v2-evm-contracts";
+
+export { PACKAGE_NAME };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":["PACKAGE_NAME"],"mappings":";AAKO,IAAMA,YAAAA,GAAe","file":"index.js","sourcesContent":["/**\n * The contract artifacts are the product of this package: read them by path, e.g.\n * `@layerzerolabs/protocol-v2-evm-contracts/artifacts/contracts/<Source>.sol/<Contract>.json`\n * (`artifacts-zk/` for zkSync, `artifacts-tron/` for Tron).\n */\nexport const PACKAGE_NAME = '@layerzerolabs/protocol-v2-evm-contracts';\n"]}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@layerzerolabs/protocol-v2-evm-contracts",
+  "version": "1.2.95",
+  "private": false,
+  "description": "Copied from @layerzerolabs/lz-evm-protocol-v2 in the old LayerZero-Labs/monorepo",
+  "license": "LZBL-1.2",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./artifacts/*": "./artifacts/*",
+    "./artifacts-zk/*": "./artifacts-zk/*",
+    "./artifacts-tron/*": "./artifacts-tron/*",
+    "./contracts/*": "./contracts/*",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "artifacts/contracts/**/!(*.dbg).json",
+    "artifacts-zk/contracts/**/!(*.dbg).json",
+    "artifacts-tron/contracts/**/!(*.dbg).json",
+    "contracts/**/*",
+    "dist/**/*"
+  ],
+  "devDependencies": {
+    "@layerzerolabs/hardhat-tron": "3.0.168",
+    "@layerzerolabs/toolbox-foundry": "^0.1.13",
+    "@layerzerolabs/tsup-configuration": "1.2.95",
+    "@layerzerolabs/typescript-configuration": "1.2.95",
+    "@layerzerolabs/vm-tooling-evm": "1.2.95",
+    "@matterlabs/hardhat-zksync-solc": "1.3.2",
+    "@openzeppelin/contracts": "4.9.5",
+    "@openzeppelin/contracts-upgradeable": "4.9.5",
+    "hardhat-deploy": "0.12.4",
+    "tsup": "^8.4.0"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "externalRepoConfig": {
+    "targets": [
+      "everdawn-externalization"
+    ]
+  },
+  "scripts": {
+    "build": "pnpm compile:evm && pnpm compile:zksync && pnpm compile:tron && tsup",
+    "clean": "rm -rf ./node_modules .turbo ./dist && pnpm generated:clean",
+    "compile:evm": "pnpm lz-tool hardhat compile --config ./hardhat.config.cjs",
+    "compile:tron": "pnpm lz-tool hardhat compile --config ./hardhat.config.cjs --network tron-mainnet",
+    "compile:zksync": "pnpm lz-tool hardhat compile --config ./hardhat.config.cjs --network zksync-mainnet",
+    "generated:clean": "rm -rf ./artifacts* ./hh-cache* ./out ./cache",
+    "lint": "eslint . --max-warnings 0 || (eslint . --fix --max-warnings 0 && false)",
+    "test": "pnpm lz-tool forge test",
+    "test:snapshot:check": "pnpm exec turbo-snapshot check",
+    "test:snapshot:update": "pnpm exec turbo-snapshot update"
+  }
+}