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

package/contracts/upgradeable/WorkerUpgradeable.sol

@@ -0,0 +1,186 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { PausableUpgradeable } from "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
+import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+import { ISendLib } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ISendLib.sol";
+import { Transfer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol";
+
+import { IWorker } from "../interfaces/IWorker.sol";
+
+abstract contract WorkerUpgradeable is Initializable, AccessControlUpgradeable, PausableUpgradeable, IWorker {
+    bytes32 internal constant MESSAGE_LIB_ROLE = keccak256("MESSAGE_LIB_ROLE");
+    bytes32 internal constant ALLOWLIST = keccak256("ALLOWLIST");
+    bytes32 internal constant DENYLIST = keccak256("DENYLIST");
+    bytes32 internal constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
+
+    address public workerFeeLib;
+
+    uint64 public allowlistSize;
+    uint16 public defaultMultiplierBps;
+    address public priceFeed;
+
+    mapping(uint32 eid => uint8[] optionTypes) internal supportedOptionTypes;
+
+    /// @param _messageLibs array of message lib addresses that are granted the MESSAGE_LIB_ROLE
+    /// @param _priceFeed price feed address
+    /// @param _defaultMultiplierBps default multiplier for worker fee
+    /// @param _roleAdmin address that is granted the DEFAULT_ADMIN_ROLE (can grant and revoke all roles)
+    /// @param _admins array of admin addresses that are granted the ADMIN_ROLE
+    function __Worker_init(
+        address[] memory _messageLibs,
+        address _priceFeed,
+        uint16 _defaultMultiplierBps,
+        address _roleAdmin,
+        address[] memory _admins
+    ) internal onlyInitializing {
+        __Context_init_unchained();
+        __AccessControl_init_unchained();
+        __Pausable_init_unchained();
+        __Worker_init_unchained(_messageLibs, _priceFeed, _defaultMultiplierBps, _roleAdmin, _admins);
+    }
+
+    function __Worker_init_unchained(
+        address[] memory _messageLibs,
+        address _priceFeed,
+        uint16 _defaultMultiplierBps,
+        address _roleAdmin,
+        address[] memory _admins
+    ) internal onlyInitializing {
+        defaultMultiplierBps = _defaultMultiplierBps;
+        priceFeed = _priceFeed;
+
+        if (_roleAdmin != address(0x0)) {
+            _grantRole(DEFAULT_ADMIN_ROLE, _roleAdmin); // _roleAdmin can grant and revoke all roles
+        }
+
+        for (uint256 i = 0; i < _messageLibs.length; ++i) {
+            _grantRole(MESSAGE_LIB_ROLE, _messageLibs[i]);
+        }
+
+        for (uint256 i = 0; i < _admins.length; ++i) {
+            _grantRole(ADMIN_ROLE, _admins[i]);
+        }
+    }
+
+    // ========================= Modifier =========================
+
+    modifier onlyAcl(address _sender) {
+        if (!hasAcl(_sender)) {
+            revert Worker_NotAllowed();
+        }
+        _;
+    }
+
+    /// @dev Access control list using allowlist and denylist
+    /// @dev 1) if one address is in the denylist -> deny
+    /// @dev 2) else if address in the allowlist OR allowlist is empty (allows everyone)-> allow
+    /// @dev 3) else deny
+    /// @param _sender address to check
+    function hasAcl(address _sender) public view returns (bool) {
+        if (hasRole(DENYLIST, _sender)) {
+            return false;
+        } else if (allowlistSize == 0 || hasRole(ALLOWLIST, _sender)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    // ========================= OnyDefaultAdmin =========================
+
+    /// @dev flag to pause execution of workers (if used with whenNotPaused modifier)
+    /// @param _paused true to pause, false to unpause
+    function setPaused(bool _paused) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        if (_paused) {
+            _pause();
+        } else {
+            _unpause();
+        }
+    }
+
+    // ========================= OnlyAdmin =========================
+
+    /// @param _priceFeed price feed address
+    function setPriceFeed(address _priceFeed) external onlyRole(ADMIN_ROLE) {
+        priceFeed = _priceFeed;
+        emit SetPriceFeed(_priceFeed);
+    }
+
+    /// @param _workerFeeLib worker fee lib address
+    function setWorkerFeeLib(address _workerFeeLib) external onlyRole(ADMIN_ROLE) {
+        workerFeeLib = _workerFeeLib;
+        emit SetWorkerLib(_workerFeeLib);
+    }
+
+    /// @param _multiplierBps default multiplier for worker fee
+    function setDefaultMultiplierBps(uint16 _multiplierBps) external onlyRole(ADMIN_ROLE) {
+        defaultMultiplierBps = _multiplierBps;
+        emit SetDefaultMultiplierBps(_multiplierBps);
+    }
+
+    /// @dev supports withdrawing fee from ULN301, ULN302 and more
+    /// @param _lib message lib address
+    /// @param _to address to withdraw fee to
+    /// @param _amount amount to withdraw
+    function withdrawFee(address _lib, address _to, uint256 _amount) external onlyRole(ADMIN_ROLE) {
+        if (!hasRole(MESSAGE_LIB_ROLE, _lib)) revert Worker_OnlyMessageLib();
+        ISendLib(_lib).withdrawFee(_to, _amount);
+        emit Withdraw(_lib, _to, _amount);
+    }
+
+    /// @dev supports withdrawing token from the contract
+    /// @param _token token address
+    /// @param _to address to withdraw token to
+    /// @param _amount amount to withdraw
+    function withdrawToken(address _token, address _to, uint256 _amount) external onlyRole(ADMIN_ROLE) {
+        // transfers native if _token is address(0x0)
+        Transfer.nativeOrToken(_token, _to, _amount);
+    }
+
+    function setSupportedOptionTypes(uint32 _eid, uint8[] calldata _optionTypes) external onlyRole(ADMIN_ROLE) {
+        supportedOptionTypes[_eid] = _optionTypes;
+    }
+
+    // ========================= View Functions =========================
+    function getSupportedOptionTypes(uint32 _eid) external view returns (uint8[] memory) {
+        return supportedOptionTypes[_eid];
+    }
+
+    // ========================= Internal Functions =========================
+
+    /// @dev overrides AccessControl to allow for counting of allowlistSize
+    /// @param _role role to grant
+    /// @param _account address to grant role to
+    function _grantRole(bytes32 _role, address _account) internal override {
+        if (_role == ALLOWLIST && !hasRole(_role, _account)) {
+            ++allowlistSize;
+        }
+        super._grantRole(_role, _account);
+    }
+
+    /// @dev overrides AccessControl to allow for counting of allowlistSize
+    /// @param _role role to revoke
+    /// @param _account address to revoke role from
+    function _revokeRole(bytes32 _role, address _account) internal override {
+        if (_role == ALLOWLIST && hasRole(_role, _account)) {
+            --allowlistSize;
+        }
+        super._revokeRole(_role, _account);
+    }
+
+    /// @dev overrides AccessControl to disable renouncing of roles
+    function renounceRole(bytes32 /*role*/, address /*account*/) public pure override {
+        revert Worker_RoleRenouncingDisabled();
+    }
+
+    /**
+     * @dev This empty reserved space is put in place to allow future versions to add new
+     * variables without shifting down storage in the inheritance chain.
+     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
+     */
+    uint256[47] private __gap;
+}

package/contracts/upgradeable/proxy/ProxyAdmin.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: MIT
+
+// OpenZeppelin Contracts v4.4.1 (proxy/transparent/ProxyAdmin.sol)
+
+pragma solidity ^0.8.0;
+
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+
+import { TransparentUpgradeableProxy } from "./TransparentUpgradeableProxy.sol";
+
+/**
+ * @author OpenZeppelin. Modified from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v4.4/contracts/proxy/transparent/ProxyAdmin.sol
+ * to support custom errors and `initialOwner` constructor parameter.
+ * @dev This is an auxiliary contract meant to be assigned as the admin of a {TransparentUpgradeableProxy}. For an
+ * explanation of why you would want to use this see the documentation for {TransparentUpgradeableProxy}.
+ */
+contract ProxyAdmin is Ownable {
+    error ImplementationCallFailed();
+    error AdminCallFailed();
+
+    constructor(address initialOwner) {
+        _transferOwnership(initialOwner);
+    }
+
+    /**
+     * @dev Returns the current implementation of `proxy`.
+     *
+     * Requirements:
+     *
+     * - This contract must be the admin of `proxy`.
+     */
+    function getProxyImplementation(TransparentUpgradeableProxy proxy) public view virtual returns (address) {
+        // We need to manually run the static call since the getter cannot be flagged as view
+        // bytes4(keccak256("implementation()")) == 0x5c60da1b
+        (bool success, bytes memory returndata) = address(proxy).staticcall(hex"5c60da1b");
+        if (!success) {
+            revert ImplementationCallFailed();
+        }
+        return abi.decode(returndata, (address));
+    }
+
+    /**
+     * @dev Returns the current admin of `proxy`.
+     *
+     * Requirements:
+     *
+     * - This contract must be the admin of `proxy`.
+     */
+    function getProxyAdmin(TransparentUpgradeableProxy proxy) public view virtual returns (address) {
+        // We need to manually run the static call since the getter cannot be flagged as view
+        // bytes4(keccak256("admin()")) == 0xf851a440
+        (bool success, bytes memory returndata) = address(proxy).staticcall(hex"f851a440");
+        if (!success) {
+            revert AdminCallFailed();
+        }
+        return abi.decode(returndata, (address));
+    }
+
+    /**
+     * @dev Changes the admin of `proxy` to `newAdmin`.
+     *
+     * Requirements:
+     *
+     * - This contract must be the current admin of `proxy`.
+     */
+    function changeProxyAdmin(TransparentUpgradeableProxy proxy, address newAdmin) public virtual onlyOwner {
+        proxy.changeAdmin(newAdmin);
+    }
+
+    /**
+     * @dev Upgrades `proxy` to `implementation`. See {TransparentUpgradeableProxy-upgradeTo}.
+     *
+     * Requirements:
+     *
+     * - This contract must be the admin of `proxy`.
+     */
+    function upgrade(TransparentUpgradeableProxy proxy, address implementation) public virtual onlyOwner {
+        proxy.upgradeTo(implementation);
+    }
+
+    /**
+     * @dev Upgrades `proxy` to `implementation` and calls a function on the new implementation. See
+     * {TransparentUpgradeableProxy-upgradeToAndCall}.
+     *
+     * Requirements:
+     *
+     * - This contract must be the admin of `proxy`.
+     */
+    function upgradeAndCall(
+        TransparentUpgradeableProxy proxy,
+        address implementation,
+        bytes memory data
+    ) public payable virtual onlyOwner {
+        proxy.upgradeToAndCall{ value: msg.value }(implementation, data);
+    }
+}

package/contracts/upgradeable/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-messagelib-evm-contracts/artifacts/contracts/<Source>.sol/<Contract>.json`
+ * (`artifacts-zk/` for zkSync, `artifacts-tron/` for Tron).
+ */
+export declare const PACKAGE_NAME = "@layerzerolabs/protocol-v2-messagelib-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,wDAAwD,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+// src/index.ts
+var PACKAGE_NAME = "@layerzerolabs/protocol-v2-messagelib-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-messagelib-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-messagelib-evm-contracts';\n"]}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@layerzerolabs/protocol-v2-messagelib-evm-contracts",
+  "version": "1.2.95",
+  "private": false,
+  "description": "Copied from @layerzerolabs/lz-evm-messagelib-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": {
+    "@arbitrum/nitro-contracts": "1.1.0",
+    "@axelar-network/axelar-gmp-sdk-solidity": "5.6.4",
+    "@chainlink/contracts-ccip": "0.7.6",
+    "@eth-optimism/contracts": "0.6.0",
+    "@layerzerolabs/hardhat-tron": "3.0.168",
+    "@layerzerolabs/lz-evm-protocol-v2": "npm:@layerzerolabs/protocol-v2-evm-contracts@1.2.95",
+    "@layerzerolabs/lz-evm-v1-0.7": "npm:@layerzerolabs/protocol-v1-0.7-evm-contracts@1.2.95",
+    "@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",
+    "solidity-bytes-utils": "npm:@layerzerolabs/solidity-bytes-utils@0.8.0",
+    "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"
+  }
+}