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

package/artifacts/contracts/upgradeable/WorkerUpgradeable.sol/WorkerUpgradeable.json

@@ -4,39 +4,39 @@
   "sourceName": "contracts/upgradeable/WorkerUpgradeable.sol",
   "abi": [
     {
-      "inputs": [],
-      "name": "NotAllowed",
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "_to",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "_value",
+          "type": "uint256"
+        }
+      ],
+      "name": "Transfer_NativeFailed",
       "type": "error"
     },
     {
       "inputs": [],
-      "name": "OnlyMessageLib",
+      "name": "Transfer_ToAddressIsZero",
       "type": "error"
     },
     {
       "inputs": [],
-      "name": "RoleRenouncingDisabled",
+      "name": "Worker_NotAllowed",
       "type": "error"
     },
     {
       "inputs": [],
-      "name": "ToAddressIsZero",
+      "name": "Worker_OnlyMessageLib",
       "type": "error"
     },
     {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "_to",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "_value",
-          "type": "uint256"
-        }
-      ],
-      "name": "TransferNativeFailed",
+      "inputs": [],
+      "name": "Worker_RoleRenouncingDisabled",
       "type": "error"
     },
     {

package/contracts/ExecutorFeeLib.sol

@@ -106,7 +106,7 @@ contract ExecutorFeeLib is Ownable, IExecutorFeeLib {
         bytes calldata _options
     ) internal pure returns (uint256 dstAmount, uint256 totalGas) {
         if (_options.length == 0) {
-            revert NoOptions();
+            revert Executor_NoOptions();
         }
 
         uint256 cursor = 0;
@@ -121,7 +121,7 @@ contract ExecutorFeeLib is Ownable, IExecutorFeeLib {
                 (uint128 gas, uint128 value) = ExecutorOptions.decodeLzReceiveOption(option);
 
                 // endpoint v1 does not support lzReceive with value
-                if (_v1Eid && value > 0) revert UnsupportedOptionType(optionType);
+                if (_v1Eid && value > 0) revert Executor_UnsupportedOptionType(optionType);
 
                 dstAmount += value;
                 totalGas += gas;
@@ -130,7 +130,7 @@ contract ExecutorFeeLib is Ownable, IExecutorFeeLib {
                 dstAmount += nativeDropAmount;
             } else if (optionType == ExecutorOptions.OPTION_TYPE_LZCOMPOSE) {
                 // endpoint v1 does not support lzCompose
-                if (_v1Eid) revert UnsupportedOptionType(optionType);
+                if (_v1Eid) revert Executor_UnsupportedOptionType(optionType);
 
                 (, uint128 gas, uint128 value) = ExecutorOptions.decodeLzComposeOption(option);
                 dstAmount += value;
@@ -138,11 +138,11 @@ contract ExecutorFeeLib is Ownable, IExecutorFeeLib {
             } else if (optionType == ExecutorOptions.OPTION_TYPE_ORDERED_EXECUTION) {
                 ordered = true;
             } else {
-                revert UnsupportedOptionType(optionType);
+                revert Executor_UnsupportedOptionType(optionType);
             }
         }
-        if (cursor != _options.length) revert InvalidExecutorOptions(cursor);
-        if (dstAmount > _nativeCap) revert NativeAmountExceedsCap(dstAmount, _nativeCap);
+        if (cursor != _options.length) revert Executor_InvalidExecutorOptions(cursor);
+        if (dstAmount > _nativeCap) revert Executor_NativeAmountExceedsCap(dstAmount, _nativeCap);
 
         if (ordered) {
             // todo: finalize the premium for ordered

package/contracts/MessageLibBase.sol

@@ -7,10 +7,10 @@ abstract contract MessageLibBase {
     address internal immutable endpoint;
     uint32 internal immutable localEid;
 
-    error OnlyEndpoint();
+    error LZ_MessageLib_OnlyEndpoint();
 
     modifier onlyEndpoint() {
-        if (endpoint != msg.sender) revert OnlyEndpoint();
+        if (endpoint != msg.sender) revert LZ_MessageLib_OnlyEndpoint();
         _;
     }
 

package/contracts/PriceFeed.sol

@@ -43,7 +43,7 @@ contract PriceFeed is ILayerZeroPriceFeed, OwnableUpgradeable, Proxied {
     modifier onlyPriceUpdater() {
         if (owner() != msg.sender) {
             if (!priceUpdater[msg.sender]) {
-                revert OnlyPriceUpdater();
+                revert LZ_PriceFeed_OnlyPriceUpdater();
             }
         }
         _;
@@ -102,7 +102,7 @@ contract PriceFeed is ILayerZeroPriceFeed, OwnableUpgradeable, Proxied {
         uint256 _gas
     ) external payable returns (uint256, uint128, uint128, uint128) {
         uint256 fee = getFee(_dstEid, _callDataSize, _gas);
-        if (msg.value < fee) revert InsufficientFee(msg.value, fee);
+        if (msg.value < fee) revert LZ_PriceFeed_InsufficientFee(msg.value, fee);
         return _estimateFeeByEid(_dstEid, _callDataSize, _gas);
     }
 
@@ -181,7 +181,7 @@ contract PriceFeed is ILayerZeroPriceFeed, OwnableUpgradeable, Proxied {
         } else if (l2Eid == 20132) {
             return 20121; // ethereum-goerli
         }
-        revert UnknownL2Eid(l2Eid);
+        revert LZ_PriceFeed_UnknownL2Eid(l2Eid);
     }
 
     function _estimateFeeWithDefaultModel(

package/contracts/ReceiveLibBaseE2.sol

@@ -25,30 +25,4 @@ abstract contract ReceiveLibBaseE2 is MessageLibBase, ERC165, IMessageLib {
     function messageLibType() external pure virtual override returns (MessageLibType) {
         return MessageLibType.Receive;
     }
-
-    // ========================= VIEW FUNCTIONS FOR OFFCHAIN ONLY =========================
-    // Not involved in any state transition function.
-    // ====================================================================================
-
-    /// @dev checks for endpoint verifiable and endpoint has payload hash
-    function _verifiable(
-        uint32 _srcEid,
-        address _receiver,
-        bytes calldata _packetHeader,
-        bytes32 _payloadHash
-    ) internal view returns (bool) {
-        Origin memory origin = Origin(_srcEid, _packetHeader.sender(), _packetHeader.nonce());
-
-        // check endpoint verifiable
-        if (!ILayerZeroEndpointV2(endpoint).verifiable(origin, _receiver, address(this), _payloadHash)) return false;
-
-        // if endpoint.verifiable, also check if the payload hash matches
-        // endpoint allows re-verify, check if this payload has already been verified
-        if (
-            ILayerZeroEndpointV2(endpoint).inboundPayloadHash(_receiver, origin.srcEid, origin.sender, origin.nonce) ==
-            _payloadHash
-        ) return false;
-
-        return true;
-    }
 }

package/contracts/SendLibBase.sol

@@ -48,11 +48,11 @@ abstract contract SendLibBase is MessageLibBase, Ownable {
     event ExecutorConfigSet(address oapp, uint32 eid, ExecutorConfig config);
     event TreasuryNativeFeeCapSet(uint256 newTreasuryNativeFeeCap);
 
-    error InvalidMessageSize(uint256 actual, uint256 max);
-    error InvalidAmount(uint256 requested, uint256 available);
-    error TransferFailed();
-    error InvalidExecutor();
-    error ZeroMessageSize();
+    error LZ_MessageLib_InvalidMessageSize(uint256 actual, uint256 max);
+    error LZ_MessageLib_InvalidAmount(uint256 requested, uint256 available);
+    error LZ_MessageLib_TransferFailed();
+    error LZ_MessageLib_InvalidExecutor();
+    error LZ_MessageLib_ZeroMessageSize();
 
     constructor(
         address _endpoint,
@@ -68,8 +68,8 @@ abstract contract SendLibBase is MessageLibBase, Ownable {
         for (uint256 i = 0; i < _params.length; ++i) {
             SetDefaultExecutorConfigParam calldata param = _params[i];
 
-            if (param.config.executor == address(0x0)) revert InvalidExecutor();
-            if (param.config.maxMessageSize == 0) revert ZeroMessageSize();
+            if (param.config.executor == address(0x0)) revert LZ_MessageLib_InvalidExecutor();
+            if (param.config.maxMessageSize == 0) revert LZ_MessageLib_ZeroMessageSize();
 
             executorConfigs[DEFAULT_CONFIG][param.eid] = param.config;
         }
@@ -80,7 +80,7 @@ abstract contract SendLibBase is MessageLibBase, Ownable {
     function setTreasuryNativeFeeCap(uint256 _newTreasuryNativeFeeCap) external onlyOwner {
         // assert the new value is no greater than the old value
         if (_newTreasuryNativeFeeCap > treasuryNativeFeeCap)
-            revert InvalidAmount(_newTreasuryNativeFeeCap, treasuryNativeFeeCap);
+            revert LZ_MessageLib_InvalidAmount(_newTreasuryNativeFeeCap, treasuryNativeFeeCap);
         treasuryNativeFeeCap = _newTreasuryNativeFeeCap;
         emit TreasuryNativeFeeCapSet(_newTreasuryNativeFeeCap);
     }
@@ -100,7 +100,7 @@ abstract contract SendLibBase is MessageLibBase, Ownable {
 
     // ======================= Internal =======================
     function _assertMessageSize(uint256 _actual, uint256 _max) internal pure {
-        if (_actual > _max) revert InvalidMessageSize(_actual, _max);
+        if (_actual > _max) revert LZ_MessageLib_InvalidMessageSize(_actual, _max);
     }
 
     function _payExecutor(
@@ -227,7 +227,7 @@ abstract contract SendLibBase is MessageLibBase, Ownable {
     /// @dev authenticated by msg.sender only
     function _debitFee(uint256 _amount) internal {
         uint256 fee = fees[msg.sender];
-        if (_amount > fee) revert InvalidAmount(_amount, fee);
+        if (_amount > fee) revert LZ_MessageLib_InvalidAmount(_amount, fee);
         unchecked {
             fees[msg.sender] = fee - _amount;
         }

package/contracts/SendLibBaseE2.sol

@@ -20,8 +20,8 @@ abstract contract SendLibBaseE2 is SendLibBase, ERC165, ISendLib {
     event NativeFeeWithdrawn(address worker, address receiver, uint256 amount);
     event LzTokenFeeWithdrawn(address lzToken, address receiver, uint256 amount);
 
-    error NotTreasury();
-    error CannotWithdrawAltToken();
+    error LZ_MessageLib_NotTreasury();
+    error LZ_MessageLib_CannotWithdrawAltToken();
 
     constructor(
         address _endpoint,
@@ -75,10 +75,10 @@ abstract contract SendLibBaseE2 is SendLibBase, ERC165, ISendLib {
     /// @dev E2 only
     /// @dev treasury only function
     function withdrawLzTokenFee(address _lzToken, address _to, uint256 _amount) external {
-        if (msg.sender != treasury) revert NotTreasury();
+        if (msg.sender != treasury) revert LZ_MessageLib_NotTreasury();
 
         // lz token cannot be the same as the native token
-        if (ILayerZeroEndpointV2(endpoint).nativeToken() == _lzToken) revert CannotWithdrawAltToken();
+        if (ILayerZeroEndpointV2(endpoint).nativeToken() == _lzToken) revert LZ_MessageLib_CannotWithdrawAltToken();
 
         Transfer.token(_lzToken, _to, _amount);
 

package/contracts/Treasury.sol

@@ -14,7 +14,7 @@ contract Treasury is Ownable, ILayerZeroTreasury {
     uint256 public lzTokenFee;
     bool public lzTokenEnabled;
 
-    error LzTokenNotEnabled();
+    error LZ_Treasury_LzTokenNotEnabled();
 
     function getFee(
         address /*_sender*/,
@@ -65,7 +65,7 @@ contract Treasury is Ownable, ILayerZeroTreasury {
 
     function _getFee(uint256 _totalFee, bool _payInLzToken) internal view returns (uint256) {
         if (_payInLzToken) {
-            if (!lzTokenEnabled) revert LzTokenNotEnabled();
+            if (!lzTokenEnabled) revert LZ_Treasury_LzTokenNotEnabled();
             return lzTokenFee;
         } else {
             return (_totalFee * nativeBP) / 10000;

package/contracts/Worker.sol

@@ -58,7 +58,7 @@ abstract contract Worker is AccessControl, Pausable, IWorker {
 
     modifier onlyAcl(address _sender) {
         if (!hasAcl(_sender)) {
-            revert NotAllowed();
+            revert Worker_NotAllowed();
         }
         _;
     }
@@ -115,7 +115,7 @@ abstract contract Worker is AccessControl, Pausable, IWorker {
     /// @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 OnlyMessageLib();
+        if (!hasRole(MESSAGE_LIB_ROLE, _lib)) revert Worker_OnlyMessageLib();
         ISendLib(_lib).withdrawFee(_to, _amount);
         emit Withdraw(_lib, _to, _amount);
     }
@@ -162,6 +162,6 @@ abstract contract Worker is AccessControl, Pausable, IWorker {
 
     /// @dev overrides AccessControl to disable renouncing of roles
     function renounceRole(bytes32 /*role*/, address /*account*/) public pure override {
-        revert RoleRenouncingDisabled();
+        revert Worker_RoleRenouncingDisabled();
     }
 }

package/contracts/interfaces/IExecutorFeeLib.sol

@@ -13,10 +13,10 @@ interface IExecutorFeeLib {
         uint16 defaultMultiplierBps;
     }
 
-    error NoOptions();
-    error NativeAmountExceedsCap(uint256 amount, uint256 cap);
-    error UnsupportedOptionType(uint8 optionType);
-    error InvalidExecutorOptions(uint256 cursor);
+    error Executor_NoOptions();
+    error Executor_NativeAmountExceedsCap(uint256 amount, uint256 cap);
+    error Executor_UnsupportedOptionType(uint8 optionType);
+    error Executor_InvalidExecutorOptions(uint256 cursor);
 
     function getFeeOnSend(
         FeeParams calldata _params,

package/contracts/interfaces/ILayerZeroPriceFeed.sol

@@ -35,9 +35,9 @@ interface ILayerZeroPriceFeed {
         ArbitrumPriceExt extend;
     }
 
-    error OnlyPriceUpdater();
-    error InsufficientFee(uint256 provided, uint256 required);
-    error UnknownL2Eid(uint32 l2Eid);
+    error LZ_PriceFeed_OnlyPriceUpdater();
+    error LZ_PriceFeed_InsufficientFee(uint256 provided, uint256 required);
+    error LZ_PriceFeed_UnknownL2Eid(uint32 l2Eid);
 
     function nativeTokenPriceUSD() external view returns (uint128);
 

package/contracts/interfaces/IWorker.sol

@@ -9,9 +9,9 @@ interface IWorker {
     event SetSupportedOptionTypes(uint32 dstEid, uint8[] optionTypes);
     event Withdraw(address lib, address to, uint256 amount);
 
-    error NotAllowed();
-    error OnlyMessageLib();
-    error RoleRenouncingDisabled();
+    error Worker_NotAllowed();
+    error Worker_OnlyMessageLib();
+    error Worker_RoleRenouncingDisabled();
 
     function setPriceFeed(address _priceFeed) external;
 

package/contracts/uln/LzExecutor.sol

@@ -2,13 +2,16 @@
 
 pragma solidity ^0.8.20;
 
-import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import { Proxied } from "hardhat-deploy/solc_0.8/proxy/Proxied.sol";
 
 import { IReceiveUlnE2 } from "./interfaces/IReceiveUlnE2.sol";
-import { ILayerZeroEndpointV2, ExecutionState, Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import { ILayerZeroEndpointV2, Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
 import { Transfer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol";
 
-import { VerificationState } from "./ReceiveUlnBase.sol";
+import { ExecutionState, EndpointV2ViewUpgradeable } from "@layerzerolabs/lz-evm-protocol-v2/contracts/EndpointV2ViewUpgradeable.sol";
+
+import { VerificationState } from "./uln302/ReceiveUln302View.sol";
 
 struct LzReceiveParam {
     Origin origin;
@@ -25,20 +28,50 @@ struct NativeDropParam {
     uint256 _amount;
 }
 
-contract LzExecutor is Ownable {
-    address public immutable receiveUln302;
-    ILayerZeroEndpointV2 public immutable endpoint;
-    uint32 public immutable localEid;
+interface IReceiveUlnView {
+    function verifiable(bytes calldata _packetHeader, bytes32 _payloadHash) external view returns (VerificationState);
+}
+
+contract LzExecutor is OwnableUpgradeable, EndpointV2ViewUpgradeable, Proxied {
+    error LzExecutor_Executed();
+    error LzExecutor_Verifying();
+    error LzExecutor_ReceiveLibViewNotSet();
+
+    event NativeWithdrawn(address _to, uint256 _amount);
+    event ReceiveLibViewSet(address _receiveLib, address _receiveLibView);
+
+    address public receiveUln302;
+    uint32 public localEid;
 
-    error Executed();
-    error Verifying();
+    mapping(address receiveLib => address receiveLibView) public receiveLibToView;
+
+    function initialize(
+        address _receiveUln302,
+        address _receiveUln302View,
+        address _endpoint
+    ) external proxied initializer {
+        __Ownable_init();
+        __EndpointV2View_init(_endpoint);
 
-    constructor(address _receiveUln302, address _endpoint) {
         receiveUln302 = _receiveUln302;
-        endpoint = ILayerZeroEndpointV2(_endpoint);
         localEid = endpoint.eid();
+        receiveLibToView[_receiveUln302] = _receiveUln302View;
     }
 
+    // ============================ OnlyOwner ===================================
+
+    function withdrawNative(address _to, uint256 _amount) external onlyOwner {
+        Transfer.native(_to, _amount);
+        emit NativeWithdrawn(_to, _amount);
+    }
+
+    function setReceiveLibView(address _receiveLib, address _receiveLibView) external onlyOwner {
+        receiveLibToView[_receiveLib] = _receiveLibView;
+        emit ReceiveLibViewSet(_receiveLib, _receiveLibView);
+    }
+
+    // ============================ External ===================================
+
     /// @notice process for commit and execute
     /// 1. check if executable, revert if executed, execute if executable
     /// 2. check if verifiable, revert if verifying, commit if verifiable
@@ -50,8 +83,8 @@ contract LzExecutor is Ownable {
         NativeDropParam[] calldata _nativeDropParams
     ) external payable {
         /// 1. check if executable, revert if executed
-        ExecutionState executionState = endpoint.executable(_lzReceiveParam.origin, _lzReceiveParam.receiver);
-        if (executionState == ExecutionState.Executed) revert Executed();
+        ExecutionState executionState = executable(_lzReceiveParam.origin, _lzReceiveParam.receiver);
+        if (executionState == ExecutionState.Executed) revert LzExecutor_Executed();
 
         /// 2. if not executable, check if verifiable, revert if verifying, commit if verifiable
         if (executionState != ExecutionState.Executable) {
@@ -66,12 +99,15 @@ contract LzExecutor is Ownable {
             );
             bytes32 payloadHash = keccak256(abi.encodePacked(_lzReceiveParam.guid, _lzReceiveParam.message));
 
-            VerificationState verificationState = IReceiveUlnE2(receiveLib).verifiable(packetHeader, payloadHash);
+            address receiveLibView = receiveLibToView[receiveLib];
+            if (receiveLibView == address(0x0)) revert LzExecutor_ReceiveLibViewNotSet();
+
+            VerificationState verificationState = IReceiveUlnView(receiveLibView).verifiable(packetHeader, payloadHash);
             if (verificationState == VerificationState.Verifiable) {
                 // verification required
                 IReceiveUlnE2(receiveLib).commitVerification(packetHeader, payloadHash);
             } else if (verificationState == VerificationState.Verifying) {
-                revert Verifying();
+                revert LzExecutor_Verifying();
             }
         }
 
@@ -90,8 +126,4 @@ contract LzExecutor is Ownable {
             _lzReceiveParam.extraData
         );
     }
-
-    function withdrawNative(address _to, uint256 _amount) external onlyOwner {
-        Transfer.native(_to, _amount);
-    }
 }

package/contracts/uln/ReceiveUlnBase.sol

@@ -6,12 +6,6 @@ import { PacketV1Codec } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messa
 
 import { UlnBase, UlnConfig } from "./UlnBase.sol";
 
-enum VerificationState {
-    Verifying,
-    Verifiable,
-    Verified
-}
-
 struct Verification {
     bool submitted;
     uint64 confirmations;
@@ -26,10 +20,23 @@ abstract contract ReceiveUlnBase is UlnBase {
 
     event PayloadVerified(address dvn, bytes header, uint256 confirmations, bytes32 proofHash);
 
-    error InvalidPacketHeader();
-    error InvalidPacketVersion();
-    error InvalidEid();
-    error Verifying();
+    error LZ_ULN_InvalidPacketHeader();
+    error LZ_ULN_InvalidPacketVersion();
+    error LZ_ULN_InvalidEid();
+    error LZ_ULN_Verifying();
+
+    // ============================ External ===================================
+    function verifiable(
+        UlnConfig memory _config,
+        bytes32 _headerHash,
+        bytes32 _payloadHash
+    ) external view returns (bool) {
+        return _checkVerifiable(_config, _headerHash, _payloadHash);
+    }
+
+    function assertHeader(bytes calldata _packetHeader, uint32 _localEid) external pure {
+        _assertHeader(_packetHeader, _localEid);
+    }
 
     // ============================ Internal ===================================
     /// @dev per DVN signing function
@@ -51,7 +58,7 @@ abstract contract ReceiveUlnBase is UlnBase {
 
     function _verifyAndReclaimStorage(UlnConfig memory _config, bytes32 _headerHash, bytes32 _payloadHash) internal {
         if (!_checkVerifiable(_config, _headerHash, _payloadHash)) {
-            revert Verifying();
+            revert LZ_ULN_Verifying();
         }
 
         // iterate the required DVNs
@@ -71,11 +78,11 @@ abstract contract ReceiveUlnBase is UlnBase {
 
     function _assertHeader(bytes calldata _packetHeader, uint32 _localEid) internal pure {
         // assert packet header is of right size 81
-        if (_packetHeader.length != 81) revert InvalidPacketHeader();
+        if (_packetHeader.length != 81) revert LZ_ULN_InvalidPacketHeader();
         // assert packet header version is the same as ULN
-        if (_packetHeader.version() != PacketV1Codec.PACKET_VERSION) revert InvalidPacketVersion();
+        if (_packetHeader.version() != PacketV1Codec.PACKET_VERSION) revert LZ_ULN_InvalidPacketVersion();
         // assert the packet is for this endpoint
-        if (_packetHeader.dstEid() != _localEid) revert InvalidEid();
+        if (_packetHeader.dstEid() != _localEid) revert LZ_ULN_InvalidEid();
     }
 
     /// @dev for verifiable view function

package/contracts/uln/UlnBase.sol

@@ -33,13 +33,13 @@ abstract contract UlnBase is Ownable {
 
     mapping(address oapp => mapping(uint32 eid => UlnConfig)) internal ulnConfigs;
 
-    error Unsorted();
-    error InvalidRequiredDVNCount();
-    error InvalidOptionalDVNCount();
-    error AtLeastOneDVN();
-    error InvalidOptionalDVNThreshold();
-    error InvalidConfirmations();
-    error UnsupportedEid(uint32 eid);
+    error LZ_ULN_Unsorted();
+    error LZ_ULN_InvalidRequiredDVNCount();
+    error LZ_ULN_InvalidOptionalDVNCount();
+    error LZ_ULN_AtLeastOneDVN();
+    error LZ_ULN_InvalidOptionalDVNThreshold();
+    error LZ_ULN_InvalidConfirmations();
+    error LZ_ULN_UnsupportedEid(uint32 eid);
 
     event DefaultUlnConfigsSet(SetDefaultUlnConfigParam[] params);
     event UlnConfigSet(address oapp, uint32 eid, UlnConfig config);
@@ -57,9 +57,9 @@ abstract contract UlnBase is Ownable {
             SetDefaultUlnConfigParam calldata param = _params[i];
 
             // 2.a must not use NIL
-            if (param.config.requiredDVNCount == NIL_DVN_COUNT) revert InvalidRequiredDVNCount();
-            if (param.config.optionalDVNCount == NIL_DVN_COUNT) revert InvalidOptionalDVNCount();
-            if (param.config.confirmations == NIL_CONFIRMATIONS) revert InvalidConfirmations();
+            if (param.config.requiredDVNCount == NIL_DVN_COUNT) revert LZ_ULN_InvalidRequiredDVNCount();
+            if (param.config.optionalDVNCount == NIL_DVN_COUNT) revert LZ_ULN_InvalidOptionalDVNCount();
+            if (param.config.confirmations == NIL_CONFIRMATIONS) revert LZ_ULN_InvalidConfirmations();
 
             // 2.b must have at least one dvn
             _assertAtLeastOneDVN(param.config);
@@ -138,13 +138,13 @@ abstract contract UlnBase is Ownable {
     }
 
     function _assertSupportedEid(uint32 _remoteEid) internal view {
-        if (!_isSupportedEid(_remoteEid)) revert UnsupportedEid(_remoteEid);
+        if (!_isSupportedEid(_remoteEid)) revert LZ_ULN_UnsupportedEid(_remoteEid);
     }
 
     // ============================ Private ===================================
 
     function _assertAtLeastOneDVN(UlnConfig memory _config) private pure {
-        if (_config.requiredDVNCount == 0 && _config.optionalDVNThreshold == 0) revert AtLeastOneDVN();
+        if (_config.requiredDVNCount == 0 && _config.optionalDVNThreshold == 0) revert LZ_ULN_AtLeastOneDVN();
     }
 
     /// @dev this private function is used in both setDefaultUlnConfigs and setUlnConfig
@@ -154,10 +154,10 @@ abstract contract UlnBase is Ownable {
         // if dvnCount == DEFAULT, dvn list must be empty
         // otherwise, dvnList.length == dvnCount and assert the list is valid
         if (_param.requiredDVNCount == NIL_DVN_COUNT || _param.requiredDVNCount == DEFAULT) {
-            if (_param.requiredDVNs.length != 0) revert InvalidRequiredDVNCount();
+            if (_param.requiredDVNs.length != 0) revert LZ_ULN_InvalidRequiredDVNCount();
         } else {
             if (_param.requiredDVNs.length != _param.requiredDVNCount || _param.requiredDVNCount > MAX_COUNT)
-                revert InvalidRequiredDVNCount();
+                revert LZ_ULN_InvalidRequiredDVNCount();
             _assertNoDuplicates(_param.requiredDVNs);
         }
 
@@ -170,13 +170,13 @@ abstract contract UlnBase is Ownable {
         //     a) use a custom 1/1 dvn (practically a required dvn), or
         //     b) use a custom 2/3 dvn
         if (_param.optionalDVNCount == NIL_DVN_COUNT || _param.optionalDVNCount == DEFAULT) {
-            if (_param.optionalDVNs.length != 0) revert InvalidOptionalDVNCount();
-            if (_param.optionalDVNThreshold != 0) revert InvalidOptionalDVNThreshold();
+            if (_param.optionalDVNs.length != 0) revert LZ_ULN_InvalidOptionalDVNCount();
+            if (_param.optionalDVNThreshold != 0) revert LZ_ULN_InvalidOptionalDVNThreshold();
         } else {
             if (_param.optionalDVNs.length != _param.optionalDVNCount || _param.optionalDVNCount > MAX_COUNT)
-                revert InvalidOptionalDVNCount();
+                revert LZ_ULN_InvalidOptionalDVNCount();
             if (_param.optionalDVNThreshold == 0 || _param.optionalDVNThreshold > _param.optionalDVNCount)
-                revert InvalidOptionalDVNThreshold();
+                revert LZ_ULN_InvalidOptionalDVNThreshold();
             _assertNoDuplicates(_param.optionalDVNs);
         }
         // don't assert valid count here, as it needs to be validated along side default config
@@ -188,7 +188,7 @@ abstract contract UlnBase is Ownable {
         address lastDVN = address(0);
         for (uint256 i = 0; i < _dvns.length; i++) {
             address dvn = _dvns[i];
-            if (dvn <= lastDVN) revert Unsorted(); // to ensure no duplicates
+            if (dvn <= lastDVN) revert LZ_ULN_Unsorted(); // to ensure no duplicates
             lastDVN = dvn;
         }
     }