@layerzerolabs/lz-evm-messagelib-v2 2.0.13 → 2.0.15

package/contracts/uln/dvn/adapters/axelar/AxelarDVNAdapterFeeLib.sol

@@ -2,6 +2,125 @@
 
 pragma solidity ^0.8.20;
 
-import { DVNAdapterFeeLibBase } from "../DVNAdapterFeeLibBase.sol";
+import { Proxied } from "hardhat-deploy/solc_0.8/proxy/Proxied.sol";
+import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import { IAxelarGasService } from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGasService.sol";
+import { Transfer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol";
 
-contract AxelarDVNAdapterFeeLib is DVNAdapterFeeLibBase {}
+import { IAxelarDVNAdapter } from "../../../interfaces/adapters/IAxelarDVNAdapter.sol";
+import { IAxelarDVNAdapterFeeLib } from "../../../interfaces/adapters/IAxelarDVNAdapterFeeLib.sol";
+import { ILayerZeroPriceFeed } from "../../../../interfaces/ILayerZeroPriceFeed.sol";
+
+contract AxelarDVNAdapterFeeLib is OwnableUpgradeable, Proxied, IAxelarDVNAdapterFeeLib {
+    uint16 internal constant BPS_DENOMINATOR = 10000;
+
+    /// @dev to be applied to native gas fee before sending to Axelar Gas Service
+    uint16 public nativeGasFeeMultiplierBps;
+
+    IAxelarDVNAdapter public dvn;
+    IAxelarGasService public gasService;
+    ILayerZeroPriceFeed public priceFeed;
+
+    mapping(uint32 dstEid => DstConfig) public dstConfig;
+
+    function initialize(
+        address _gasService,
+        address _dvn,
+        uint16 _nativeGasFeeMultiplierBps
+    ) external proxied initializer {
+        __Ownable_init();
+        gasService = IAxelarGasService(_gasService);
+        dvn = IAxelarDVNAdapter(_dvn);
+        nativeGasFeeMultiplierBps = _nativeGasFeeMultiplierBps;
+    }
+
+    // ================================ OnlyOwner ================================
+    function withdrawToken(address _token, address _to, uint256 _amount) external onlyOwner {
+        // transfers native if _token is address(0x0)
+        Transfer.nativeOrToken(_token, _to, _amount);
+        emit TokenWithdrawn(_token, _to, _amount);
+    }
+
+    function setGasService(address _gasService) external onlyOwner {
+        gasService = IAxelarGasService(_gasService);
+        emit GasServiceSet(_gasService);
+    }
+
+    function setPriceFeed(address _priceFeed) external onlyOwner {
+        priceFeed = ILayerZeroPriceFeed(_priceFeed);
+        emit PriceFeedSet(_priceFeed);
+    }
+
+    function setDstConfig(DstConfigParam[] calldata _param) external onlyOwner {
+        for (uint256 i = 0; i < _param.length; i++) {
+            DstConfigParam calldata param = _param[i];
+            dstConfig[param.dstEid] = DstConfig({ gas: param.gas, floorMarginUSD: param.floorMarginUSD });
+        }
+        emit DstConfigSet(_param);
+    }
+
+    function setNativeGasFeeMultiplierBps(uint16 _multiplierBps) external onlyOwner {
+        nativeGasFeeMultiplierBps = _multiplierBps;
+        emit NativeGasFeeMultiplierBpsSet(_multiplierBps);
+    }
+
+    // ================================ External ================================
+    function getFeeOnSend(
+        Param calldata _param,
+        IAxelarDVNAdapter.DstConfig calldata _dstConfig,
+        bytes memory _payload,
+        bytes calldata _options,
+        address _sendLib
+    ) external payable returns (uint256 totalFee) {
+        if (_options.length > 0) revert AxelarDVNAdapter_OptionsUnsupported();
+
+        uint256 axelarFee = _getAxelarFee(_dstConfig.nativeGasFee);
+        totalFee = _applyPremium(_dstConfig.multiplierBps, _param.defaultMultiplierBps, axelarFee);
+
+        // withdraw from uln to fee lib if not enough balance
+        uint256 balance = address(this).balance;
+        if (balance < axelarFee) {
+            dvn.withdrawToFeeLib(_sendLib);
+
+            // revert if still not enough
+            balance = address(this).balance;
+            if (balance < axelarFee) revert AxelarDVNAdapter_InsufficientBalance(balance, axelarFee);
+        }
+
+        // pay axelar gas service
+        gasService.payNativeGasForContractCall{ value: axelarFee }(
+            address(this), // sender
+            _dstConfig.chainName, // destinationChain
+            _dstConfig.peer, // destinationAddress
+            _payload, // payload
+            address(this) // refundAddress
+        );
+    }
+
+    function getFee(
+        Param calldata _param,
+        IAxelarDVNAdapter.DstConfig calldata _dstConfig,
+        bytes calldata _options
+    ) external view returns (uint256 totalFee) {
+        if (_options.length > 0) revert AxelarDVNAdapter_OptionsUnsupported();
+
+        uint256 axelarFee = _getAxelarFee(_dstConfig.nativeGasFee);
+        totalFee = _applyPremium(_dstConfig.multiplierBps, _param.defaultMultiplierBps, axelarFee);
+    }
+
+    // ================================ Internal ================================
+    function _getAxelarFee(uint256 _nativeGasFee) internal view returns (uint256) {
+        return (_nativeGasFee * nativeGasFeeMultiplierBps) / BPS_DENOMINATOR;
+    }
+
+    function _applyPremium(
+        uint16 multiplierBps,
+        uint16 defaultMultiplierBps,
+        uint256 fee
+    ) internal pure returns (uint256) {
+        uint256 multiplier = multiplierBps == 0 ? defaultMultiplierBps : multiplierBps;
+        return (fee * multiplier) / BPS_DENOMINATOR;
+    }
+
+    receive() external payable {}
+}

package/contracts/uln/dvn/adapters/libs/DVNAdapterMessageCodec.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { AddressCast } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/AddressCast.sol";
+
+library DVNAdapterMessageCodec {
+    using AddressCast for bytes32;
+
+    error DVNAdapter_InvalidMessageSize();
+
+    uint256 private constant RECEIVE_LIB_OFFSET = 0;
+    uint256 private constant PAYLOAD_HASH_OFFSET = 32;
+    uint256 private constant PACKET_HEADER_OFFSET = 64;
+
+    uint256 internal constant PACKET_HEADER_SIZE = 81; // version(uint8) + nonce(uint64) + path(uint32,bytes32,uint32,bytes32)
+    uint256 internal constant MESSAGE_SIZE = 32 + 32 + PACKET_HEADER_SIZE; // receive_lib(bytes32) + payloadHash(bytes32) + packetHeader
+
+    function encode(
+        bytes32 _receiveLib,
+        bytes memory _packetHeader,
+        bytes32 _payloadHash
+    ) internal pure returns (bytes memory payload) {
+        return abi.encodePacked(_receiveLib, _payloadHash, _packetHeader);
+    }
+
+    function decode(
+        bytes calldata _message
+    ) internal pure returns (address receiveLib, bytes memory packetHeader, bytes32 payloadHash) {
+        if (_message.length != MESSAGE_SIZE) revert DVNAdapter_InvalidMessageSize();
+
+        receiveLib = bytes32(_message[RECEIVE_LIB_OFFSET:PAYLOAD_HASH_OFFSET]).toAddress();
+        payloadHash = bytes32(_message[PAYLOAD_HASH_OFFSET:PACKET_HEADER_OFFSET]);
+        packetHeader = _message[PACKET_HEADER_OFFSET:];
+    }
+}

package/contracts/uln/dvn/adapters/optimism/OptimismDVNAdapterL1.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.20;
+
+import { ICrossDomainMessenger } from "@eth-optimism/contracts/libraries/bridge/ICrossDomainMessenger.sol";
+
+import { OptimismDVNAdapterL2 } from "./OptimismDVNAdapterL2.sol";
+import { DVNAdapterMessageCodec } from "../libs/DVNAdapterMessageCodec.sol";
+import { DVNAdapterBase } from "../DVNAdapterBase.sol";
+
+/// @title OptimismDVNAdapterL1
+/// @dev How Optimism DVN adapter works:
+///  1. call `sendMessage` on the L1CrossDomainMessenger contract.
+///     refer to https://docs.optimism.io/builders/dapp-developers/bridging/messaging#basics-of-communication-between-layers
+/// @dev Recovery:
+///  1. If the message is not executed or failed to execute on the destination chain, you can manually retry by calling `relayMessage` on the `CrossDomainMessenger` contract.
+///     refer to https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/universal/CrossDomainMessenger.sol#L211C14-L211C26
+contract OptimismDVNAdapterL1 is DVNAdapterBase {
+    // --- Errors ---
+    error OnlyOptimism();
+    error NoPeer();
+
+    // --- Events ---
+    event PeerSet(address indexed peer);
+    event GasLimitSet(uint32 gasLimit);
+
+    uint32 public immutable optimismEid; // eid % 30000 (v1 eid)
+    address public immutable l1Messenger; // L1CrossDomainMessenger
+
+    uint32 public gasLimit;
+    address public peer;
+
+    constructor(
+        address[] memory _admins,
+        uint32 _optimismEid,
+        address _l1Messenger
+    ) DVNAdapterBase(msg.sender, _admins, 12000) {
+        optimismEid = _optimismEid; // eid % 30000 (v1 eid)
+        l1Messenger = _l1Messenger;
+    }
+
+    // --- Admin ---
+    function setGasLimit(uint32 _gasLimit) external onlyRole(ADMIN_ROLE) {
+        gasLimit = _gasLimit;
+        emit GasLimitSet(_gasLimit);
+    }
+
+    function setPeer(address _peer) external onlyRole(ADMIN_ROLE) {
+        peer = _peer;
+        emit PeerSet(_peer);
+    }
+
+    // --- Send ---
+    function assignJob(
+        AssignJobParam calldata _param,
+        bytes calldata /*_options*/
+    ) external payable override onlyAcl(_param.sender) returns (uint256) {
+        _getAndAssertReceiveLib(msg.sender, _param.dstEid);
+
+        if (_param.dstEid % 30000 != optimismEid) revert OnlyOptimism();
+        if (peer == address(0)) revert NoPeer();
+
+        bytes memory payload = abi.encodeWithSelector(
+            OptimismDVNAdapterL2.verify.selector,
+            DVNAdapterMessageCodec.encode(
+                receiveLibs[msg.sender][_param.dstEid],
+                _param.packetHeader,
+                _param.payloadHash
+            )
+        );
+        ICrossDomainMessenger(l1Messenger).sendMessage(peer, payload, gasLimit);
+
+        return 0;
+    }
+
+    // --- View ---
+    function getFee(
+        uint32 /*_dstEid*/,
+        uint64 /*_confirmations*/,
+        address _sender,
+        bytes calldata /*_options*/
+    ) public view override onlyAcl(_sender) returns (uint256) {
+        // no fee, charged as gas when sending message from L1 to L2
+        return 0;
+    }
+}

package/contracts/uln/dvn/adapters/optimism/OptimismDVNAdapterL2.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.20;
+
+import { ICrossDomainMessenger } from "@eth-optimism/contracts/libraries/bridge/ICrossDomainMessenger.sol";
+
+import { DVNAdapterBase } from "../DVNAdapterBase.sol";
+
+contract OptimismDVNAdapterL2 is DVNAdapterBase {
+    // --- Errors ---
+    error UntrustedPeer(address peer);
+    error Unauthorized();
+
+    // --- Events ---
+    event PeerSet(address indexed peer);
+
+    address public immutable l2Messenger; // L2CrossDomainMessenger
+
+    address public peer;
+
+    constructor(address[] memory _admins, address _l2Messenger) DVNAdapterBase(msg.sender, _admins, 12000) {
+        l2Messenger = _l2Messenger;
+    }
+
+    // --- Admin ---
+    function setPeer(address _peer) external onlyRole(ADMIN_ROLE) {
+        peer = _peer;
+        emit PeerSet(_peer);
+    }
+
+    // --- Send ---
+    function assignJob(
+        AssignJobParam calldata /*_param*/,
+        bytes calldata /*_options*/
+    ) external payable override returns (uint256) {
+        revert DVNAdapter_NotImplemented();
+    }
+
+    function getFee(
+        uint32 /*_dstEid*/,
+        uint64 /*_confirmations*/,
+        address /*_sender*/,
+        bytes calldata /*_options*/
+    ) external pure override returns (uint256) {
+        revert DVNAdapter_NotImplemented();
+    }
+
+    // --- Receive ---
+    function verify(bytes calldata _payload) external {
+        // assert messenger
+        if (msg.sender != l2Messenger) revert Unauthorized();
+        // assert peer
+        address xSender = ICrossDomainMessenger(l2Messenger).xDomainMessageSender();
+        if (xSender != peer) revert UntrustedPeer(xSender);
+
+        _decodeAndVerify(_payload);
+    }
+}

package/contracts/uln/interfaces/IDVNFeeLib.sol

@@ -14,7 +14,7 @@ interface IDVNFeeLib {
         uint16 defaultMultiplierBps;
     }
 
-    error UnsupportedOptionType(uint8 optionType);
+    error DVN_UnsupportedOptionType(uint8 optionType);
 
     function getFeeOnSend(
         FeeParams calldata _params,

package/contracts/uln/interfaces/IReceiveUlnE2.sol

@@ -2,17 +2,12 @@
 
 pragma solidity >=0.8.0;
 
-import { VerificationState } from "../ReceiveUlnBase.sol";
-
 /// @dev should be implemented by the ReceiveUln302 contract and future ReceiveUln contracts on EndpointV2
 interface IReceiveUlnE2 {
     /// @notice for each dvn to verify the payload
     /// @dev this function signature 0x0223536e
     function verify(bytes calldata _packetHeader, bytes32 _payloadHash, uint64 _confirmations) external;
 
-    /// @notice check if commitVerification is ready to be called
-    function verifiable(bytes calldata _packetHeader, bytes32 _payloadHash) external view returns (VerificationState);
-
     /// @notice verify the payload at endpoint, will check if all DVNs verified
     function commitVerification(bytes calldata _packetHeader, bytes32 _payloadHash) external;
 }

package/contracts/uln/interfaces/adapters/IAxelarDVNAdapter.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface IAxelarDVNAdapter {
+    struct MultiplierParam {
+        uint32 dstEid;
+        uint16 multiplierBps;
+    }
+
+    struct FloorMarginUSDParam {
+        uint32 dstEid;
+        uint128 floorMarginUSD;
+    }
+
+    struct NativeGasFeeParam {
+        uint32 dstEid;
+        uint256 nativeGasFee;
+    }
+
+    struct DstConfigParam {
+        uint32 dstEid;
+        string chainName;
+        string peer;
+        uint16 multiplierBps;
+        uint256 nativeGasFee;
+    }
+
+    struct DstConfig {
+        string chainName;
+        string peer;
+        uint16 multiplierBps;
+        uint256 nativeGasFee;
+    }
+
+    event DstConfigSet(DstConfigParam[] params);
+    event NativeGasFeeSet(NativeGasFeeParam[] params);
+    event MultiplierSet(MultiplierParam[] params);
+    event FloorMarginUSDSet(FloorMarginUSDParam[] params);
+
+    error AxelarDVNAdapter_UntrustedPeer(string chainName, string peer);
+    error AxelarDVNAdapter_OnlyWorkerFeeLib();
+
+    function withdrawToFeeLib(address _sendLib) external;
+}

package/contracts/uln/interfaces/adapters/IAxelarDVNAdapterFeeLib.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import { IAxelarDVNAdapter } from "./IAxelarDVNAdapter.sol";
+
+interface IAxelarDVNAdapterFeeLib {
+    struct Param {
+        uint32 dstEid;
+        uint64 confirmations;
+        address sender;
+        uint16 defaultMultiplierBps;
+    }
+
+    struct DstConfig {
+        uint64 gas;
+        uint128 floorMarginUSD; // uses priceFeed PRICE_RATIO_DENOMINATOR
+    }
+
+    struct DstConfigParam {
+        uint32 dstEid;
+        uint64 gas;
+        uint128 floorMarginUSD; // uses priceFeed PRICE_RATIO_DENOMINATOR
+    }
+
+    event DstConfigSet(DstConfigParam[] params);
+    event TokenWithdrawn(address token, address to, uint256 amount);
+    event GasServiceSet(address gasService);
+    event PriceFeedSet(address priceFeed);
+    event NativeGasFeeMultiplierBpsSet(uint16 multiplierBps);
+
+    error AxelarDVNAdapter_OptionsUnsupported();
+    error AxelarDVNAdapter_InsufficientBalance(uint256 actual, uint256 requested);
+
+    function getFeeOnSend(
+        Param calldata _params,
+        IAxelarDVNAdapter.DstConfig calldata _dstConfig,
+        bytes memory _payload,
+        bytes calldata _options,
+        address _sendLib
+    ) external payable returns (uint256 totalFee);
+
+    function getFee(
+        Param calldata _params,
+        IAxelarDVNAdapter.DstConfig calldata _dstConfig,
+        bytes calldata _options
+    ) external view returns (uint256 totalFee);
+}

package/contracts/uln/interfaces/adapters/ICCIPDVNAdapter.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface ICCIPDVNAdapter {
+    struct DstConfigParam {
+        uint32 dstEid;
+        uint16 multiplierBps;
+        uint64 chainSelector;
+        uint256 gas;
+        bytes peer;
+    }
+
+    struct DstConfig {
+        // https://docs.chain.link/ccip/supported-networks/v1_2_0/testnet#ethereum-sepolia
+        // https://docs.chain.link/ccip/supported-networks/v1_0_0/mainnet
+        uint64 chainSelector;
+        uint16 multiplierBps;
+        // https://github.com/smartcontractkit/ccip/blob/ccip-develop/contracts/src/v0.8/ccip/libraries/Client.sol#L22C51-L22C51
+        // for destination is evm chain, need to use `abi.encode(address)` to get the peer
+        bytes peer;
+        uint256 gas;
+    }
+
+    event DstConfigSet(DstConfigParam[] params);
+    event RouterSet(address router);
+
+    error CCIPDVNAdapter_UntrustedPeer(uint64 chainSelector, bytes peer);
+    error CCIPDVNAdapter_InvalidRouter(address router);
+}

package/contracts/uln/interfaces/adapters/ICCIPDVNAdapterFeeLib.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import { Client } from "@chainlink/contracts-ccip/src/v0.8/ccip/libraries/Client.sol";
+import { IRouterClient } from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IRouterClient.sol";
+import { ICCIPDVNAdapter } from "./ICCIPDVNAdapter.sol";
+
+interface ICCIPDVNAdapterFeeLib {
+    struct Param {
+        uint32 dstEid;
+        uint64 confirmations;
+        address sender;
+        uint16 defaultMultiplierBps;
+    }
+
+    struct DstConfig {
+        uint128 floorMarginUSD; // uses priceFeed PRICE_RATIO_DENOMINATOR
+    }
+
+    struct DstConfigParam {
+        uint32 dstEid;
+        uint128 floorMarginUSD; // uses priceFeed PRICE_RATIO_DENOMINATOR
+    }
+
+    event DstConfigSet(DstConfigParam[] params);
+
+    error CCIPDVN_OptionsUnsupported();
+
+    function getFeeOnSend(
+        Param calldata _params,
+        ICCIPDVNAdapter.DstConfig calldata _dstConfig,
+        Client.EVM2AnyMessage calldata _message,
+        bytes calldata _options,
+        IRouterClient _router
+    ) external payable returns (uint256 ccipFee, uint256 totalFee);
+
+    function getFee(
+        Param calldata _params,
+        ICCIPDVNAdapter.DstConfig calldata _dstConfig,
+        Client.EVM2AnyMessage calldata _message,
+        bytes calldata _options,
+        IRouterClient _router
+    ) external view returns (uint256 totalFee);
+}

package/contracts/uln/libs/DVNOptions.sol

@@ -14,8 +14,8 @@ library DVNOptions {
     uint8 internal constant WORKER_ID = 2;
     uint8 internal constant OPTION_TYPE_PRECRIME = 1;
 
-    error InvalidDVNIdx();
-    error InvalidDVNOptions(uint256 cursor);
+    error DVN_InvalidDVNIdx();
+    error DVN_InvalidDVNOptions(uint256 cursor);
 
     /// @dev group dvn options by its idx
     /// @param _options [dvn_id][dvn_option][dvn_id][dvn_option]...
@@ -98,7 +98,7 @@ library DVNOptions {
     ) internal pure {
         // dvnIdx starts from 0 but default value of dvnIndices is 0,
         // so we tell if the slot is empty by adding 1 to dvnIdx
-        if (_dvnIdx == 255) revert InvalidDVNIdx();
+        if (_dvnIdx == 255) revert DVN_InvalidDVNIdx();
         uint8 dvnIdxAdj = _dvnIdx + 1;
 
         for (uint256 j = 0; j < _dvnIndices.length; ++j) {
@@ -128,7 +128,7 @@ library DVNOptions {
 
                 uint16 optionLength = _options.toUint16(cursor);
                 cursor += 2;
-                if (optionLength < 2) revert InvalidDVNOptions(cursor); // at least 1 byte for dvn_idx and 1 byte for option_type
+                if (optionLength < 2) revert DVN_InvalidDVNOptions(cursor); // at least 1 byte for dvn_idx and 1 byte for option_type
 
                 uint8 dvnIdx = _options.toUint8(cursor);
 
@@ -138,7 +138,7 @@ library DVNOptions {
                 // the composability of the options. e.g. if we refrain from enforcing the order, an OApp that has
                 // already enforced certain options can append additional options to the end of the enforced
                 // ones without restrictions.
-                if (dvnIdx == 255) revert InvalidDVNIdx();
+                if (dvnIdx == 255) revert DVN_InvalidDVNIdx();
                 if (!bitmap.get(dvnIdx)) {
                     ++numDVNs;
                     bitmap = bitmap.set(dvnIdx);
@@ -147,7 +147,7 @@ library DVNOptions {
                 cursor += optionLength;
             }
         }
-        if (cursor != _options.length) revert InvalidDVNOptions(cursor);
+        if (cursor != _options.length) revert DVN_InvalidDVNOptions(cursor);
     }
 
     /// @dev decode the next dvn option from _options starting from the specified cursor

package/contracts/uln/libs/UlnOptions.sol

@@ -15,11 +15,11 @@ library UlnOptions {
     uint16 internal constant TYPE_2 = 2; // legacy options type 2
     uint16 internal constant TYPE_3 = 3;
 
-    error InvalidWorkerOptions(uint256 cursor);
-    error InvalidWorkerId(uint8 workerId);
-    error InvalidLegacyType1Option();
-    error InvalidLegacyType2Option();
-    error UnsupportedOptionType(uint16 optionType);
+    error LZ_ULN_InvalidWorkerOptions(uint256 cursor);
+    error LZ_ULN_InvalidWorkerId(uint8 workerId);
+    error LZ_ULN_InvalidLegacyType1Option();
+    error LZ_ULN_InvalidLegacyType2Option();
+    error LZ_ULN_UnsupportedOptionType(uint16 optionType);
 
     /// @dev decode the options into executorOptions and dvnOptions
     /// @param _options the options can be either legacy options (type 1 or 2) or type 3 options
@@ -29,7 +29,7 @@ library UlnOptions {
         bytes calldata _options
     ) internal pure returns (bytes memory executorOptions, bytes memory dvnOptions) {
         // at least 2 bytes for the option type, but can have no options
-        if (_options.length < 2) revert InvalidWorkerOptions(0);
+        if (_options.length < 2) revert LZ_ULN_InvalidWorkerOptions(0);
 
         uint16 optionsType = uint16(bytes2(_options[0:2]));
         uint256 cursor = 2;
@@ -46,7 +46,7 @@ library UlnOptions {
                 // checking the workerID can reduce gas usage for most cases
                 while (cursor < _options.length) {
                     uint8 workerId = uint8(bytes1(_options[cursor:cursor + 1]));
-                    if (workerId == 0) revert InvalidWorkerId(0);
+                    if (workerId == 0) revert LZ_ULN_InvalidWorkerId(0);
 
                     // workerId must equal to the lastWorkerId for the first option
                     // so it is always skipped in the first option
@@ -70,12 +70,12 @@ library UlnOptions {
                     ++cursor; // for workerId
 
                     uint16 size = uint16(bytes2(_options[cursor:cursor + 2]));
-                    if (size == 0) revert InvalidWorkerOptions(cursor);
+                    if (size == 0) revert LZ_ULN_InvalidWorkerOptions(cursor);
                     cursor += size + 2;
                 }
 
                 // the options length must be the same as the cursor at the end
-                if (cursor != _options.length) revert InvalidWorkerOptions(cursor);
+                if (cursor != _options.length) revert LZ_ULN_InvalidWorkerOptions(cursor);
 
                 // if we have reached the end of the options and the options are not empty
                 // we need to process the last worker's options
@@ -102,7 +102,7 @@ library UlnOptions {
         } else if (_workerId == DVNOptions.WORKER_ID) {
             _dvnOptions = _dvnOptions.length == 0 ? _newOptions : abi.encodePacked(_dvnOptions, _newOptions);
         } else {
-            revert InvalidWorkerId(_workerId);
+            revert LZ_ULN_InvalidWorkerId(_workerId);
         }
         return (_executorOptions, _dvnOptions);
     }
@@ -120,7 +120,7 @@ library UlnOptions {
         bytes calldata _options
     ) internal pure returns (bytes memory executorOptions) {
         if (_optionType == TYPE_1) {
-            if (_options.length != 34) revert InvalidLegacyType1Option();
+            if (_options.length != 34) revert LZ_ULN_InvalidLegacyType1Option();
 
             // execution gas
             uint128 executionGas = uint256(bytes32(_options[2:2 + 32])).toUint128();
@@ -137,7 +137,7 @@ library UlnOptions {
             );
         } else if (_optionType == TYPE_2) {
             // receiver size <= 32
-            if (_options.length <= 66 || _options.length > 98) revert InvalidLegacyType2Option();
+            if (_options.length <= 66 || _options.length > 98) revert LZ_ULN_InvalidLegacyType2Option();
 
             // execution gas
             uint128 executionGas = uint256(bytes32(_options[2:2 + 32])).toUint128();
@@ -170,7 +170,7 @@ library UlnOptions {
                 receiver
             );
         } else {
-            revert UnsupportedOptionType(_optionType);
+            revert LZ_ULN_UnsupportedOptionType(_optionType);
         }
     }
 }

package/contracts/uln/uln301/AddressSizeConfig.sol

@@ -10,12 +10,12 @@ abstract contract AddressSizeConfig is Ownable {
 
     event AddressSizeSet(uint16 eid, uint256 size);
 
-    error InvalidAddressSize();
-    error AddressSizeAlreadySet();
+    error AddressSizeConfig_InvalidAddressSize();
+    error AddressSizeConfig_AddressSizeAlreadySet();
 
     function setAddressSize(uint16 _eid, uint256 _size) external onlyOwner {
-        if (_size > 32) revert InvalidAddressSize();
-        if (addressSizes[_eid] != 0) revert AddressSizeAlreadySet();
+        if (_size > 32) revert AddressSizeConfig_InvalidAddressSize();
+        if (addressSizes[_eid] != 0) revert AddressSizeConfig_AddressSizeAlreadySet();
         addressSizes[_eid] = _size;
         emit AddressSizeSet(_eid, _size);
     }