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

package/contracts/uln/dvn/DeadDVN.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { ILayerZeroDVN } from "../interfaces/ILayerZeroDVN.sol";
+
+contract DeadDVN is ILayerZeroDVN {
+    string internal constant ERROR_NOT_ALLOWED = "Please set your OApp's DVNs and/or Executor";
+
+    /// @dev for ULN301, ULN302 and more to assign job
+    function assignJob(AssignJobParam calldata, bytes calldata) external payable returns (uint256) {
+        revert(ERROR_NOT_ALLOWED);
+    }
+
+    /// @dev to support ULNv2
+    function assignJob(uint16, uint16, uint64, address) external pure returns (uint256) {
+        revert(ERROR_NOT_ALLOWED);
+    }
+
+    // ========================= View =========================
+
+    function getFee(uint32, uint64, address, bytes calldata) external pure returns (uint256) {
+        revert(ERROR_NOT_ALLOWED);
+    }
+
+    /// @dev to support ULNv2
+    function getFee(uint16, uint16, uint64, address) public pure returns (uint256) {
+        revert(ERROR_NOT_ALLOWED);
+    }
+}

package/contracts/uln/dvn/MultiSig.sol

@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+abstract contract MultiSig {
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    enum Errors {
+        NoError,
+        SignatureError,
+        DuplicatedSigner,
+        SignerNotInCommittee
+    }
+
+    EnumerableSet.AddressSet internal signerSet;
+    uint64 public quorum;
+
+    error MultiSig_OnlySigner();
+    error MultiSig_QuorumIsZero();
+    error MultiSig_SignersSizeIsLessThanQuorum(uint64 signersSize, uint64 quorum);
+    error MultiSig_UnorderedSigners();
+    error MultiSig_StateAlreadySet(address signer, bool active);
+    error MultiSig_StateNotSet(address signer, bool active);
+    error MultiSig_InvalidSigner();
+
+    event UpdateSigner(address _signer, bool _active);
+    event UpdateQuorum(uint64 _quorum);
+
+    modifier onlySigner() {
+        if (!isSigner(msg.sender)) {
+            revert MultiSig_OnlySigner();
+        }
+        _;
+    }
+
+    constructor(address[] memory _signers, uint64 _quorum) {
+        if (_quorum == 0) {
+            revert MultiSig_QuorumIsZero();
+        }
+        for (uint256 i = 0; i < _signers.length; i++) {
+            address signer = _signers[i];
+            if (signer == address(0)) {
+                revert MultiSig_InvalidSigner();
+            }
+            signerSet.add(signer);
+        }
+
+        uint64 _signerSize = uint64(signerSet.length());
+        if (_signerSize < _quorum) {
+            revert MultiSig_SignersSizeIsLessThanQuorum(_signerSize, _quorum);
+        }
+
+        quorum = _quorum;
+    }
+
+    function _setSigner(address _signer, bool _active) internal {
+        if (_active) {
+            if (_signer == address(0)) {
+                revert MultiSig_InvalidSigner();
+            }
+            if (!signerSet.add(_signer)) {
+                revert MultiSig_StateAlreadySet(_signer, _active);
+            }
+        } else {
+            if (!signerSet.remove(_signer)) {
+                revert MultiSig_StateNotSet(_signer, _active);
+            }
+        }
+
+        uint64 _signerSize = uint64(signerSet.length());
+        uint64 _quorum = quorum;
+        if (_signerSize < _quorum) {
+            revert MultiSig_SignersSizeIsLessThanQuorum(_signerSize, _quorum);
+        }
+        emit UpdateSigner(_signer, _active);
+    }
+
+    function _setQuorum(uint64 _quorum) internal {
+        if (_quorum == 0) {
+            revert MultiSig_QuorumIsZero();
+        }
+        uint64 _signerSize = uint64(signerSet.length());
+        if (_signerSize < _quorum) {
+            revert MultiSig_SignersSizeIsLessThanQuorum(_signerSize, _quorum);
+        }
+        quorum = _quorum;
+        emit UpdateQuorum(_quorum);
+    }
+
+    function verifySignatures(bytes32 _hash, bytes calldata _signatures) public view returns (bool, Errors) {
+        if (_signatures.length != uint256(quorum) * 65) {
+            return (false, Errors.SignatureError);
+        }
+
+        bytes32 messageDigest = _getEthSignedMessageHash(_hash);
+
+        address lastSigner = address(0); // There cannot be a signer with address 0.
+        for (uint256 i = 0; i < quorum; i++) {
+            // the quorum is guaranteed not to be zero in the constructor and setter
+            bytes calldata signature = _signatures[i * 65:(i + 1) * 65];
+            (address currentSigner, ECDSA.RecoverError error) = ECDSA.tryRecover(messageDigest, signature);
+
+            if (error != ECDSA.RecoverError.NoError) return (false, Errors.SignatureError);
+            if (currentSigner <= lastSigner) return (false, Errors.DuplicatedSigner); // prevent duplicate signatures, the signers must be ordered to sign the digest
+            if (!isSigner(currentSigner)) return (false, Errors.SignerNotInCommittee); // signature is not in committee
+            lastSigner = currentSigner;
+        }
+        return (true, Errors.NoError);
+    }
+
+    function _getEthSignedMessageHash(bytes32 _messageHash) internal pure returns (bytes32) {
+        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _messageHash));
+    }
+
+    // ============================================== View ==============================================
+    function getSigners() public view returns (address[] memory) {
+        return signerSet.values();
+    }
+
+    // compatibility with the previous version
+    function signers(address _signer) public view returns (bool) {
+        return isSigner(_signer);
+    }
+
+    function isSigner(address _signer) public view returns (bool) {
+        return signerSet.contains(_signer);
+    }
+
+    function signerSize() public view returns (uint256) {
+        return signerSet.length();
+    }
+}

package/contracts/uln/dvn/SimpleReadDVN.sol

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { BitMap256 } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/BitMaps.sol";
+
+import { ILayerZeroReadDVN } from "../interfaces/ILayerZeroReadDVN.sol";
+import { ReadCmdCodecV1 } from "../libs/ReadCmdCodecV1.sol";
+import { ReadLib1002 } from "../readlib/ReadLib1002.sol";
+import { SupportedCmdTypes } from "../libs/SupportedCmdTypes.sol";
+
+contract SimpleReadDVN is ILayerZeroReadDVN {
+    struct SetSupportedCmdTypesParam {
+        uint32 targetEid;
+        BitMap256 types;
+    }
+
+    uint128 internal constant DENOMINATOR = 10 ** 18;
+    uint128 internal constant NATIVE_DECIMALS = 10 ** 18;
+
+    uint16 internal constant BPS_BASE = 10000;
+
+    address payable public immutable readLib;
+
+    // the usd fee should be usd * DENOMINATOR
+    uint128 internal evmCallRequestV1FeeUSD;
+    uint128 internal evmCallComputeV1MapFeeUSD;
+    uint128 internal evmCallComputeV1ReduceFeeUSD;
+
+    uint128 internal nativePriceUSD; // usd * DENOMINATOR
+
+    SupportedCmdTypes internal supportedCmdTypes;
+
+    constructor(address payable _readLib) {
+        readLib = _readLib;
+    }
+
+    function setSupportedCmdTypes(SetSupportedCmdTypesParam[] calldata _params) external {
+        for (uint256 i = 0; i < _params.length; i++) {
+            supportedCmdTypes.cmdTypes[_params[i].targetEid] = _params[i].types;
+        }
+    }
+
+    function assignJob(
+        address /*_sender*/,
+        bytes calldata /*_packetHeader*/,
+        bytes calldata _cmd,
+        bytes calldata /*_options*/
+    ) external payable returns (uint256) {
+        uint256 cmdFeeUSD = _estimateCmdFee(_cmd);
+        uint256 cmdFee = (cmdFeeUSD * NATIVE_DECIMALS) / nativePriceUSD;
+
+        return cmdFee;
+    }
+
+    function verify(bytes calldata _packetHeader, bytes32 _cmdHash, bytes32 _payloadHash) external {
+        ReadLib1002(readLib).verify(_packetHeader, _cmdHash, _payloadHash);
+    }
+
+    // ========================= View =========================
+
+    function getFee(
+        address /*_sender*/,
+        bytes calldata /*_packetHeader*/,
+        bytes calldata _cmd,
+        bytes calldata /*_options*/
+    ) external view returns (uint256) {
+        // cmdFeeUSD -> cmdFee native
+        uint256 cmdFeeUSD = _estimateCmdFee(_cmd);
+        uint256 cmdFee = (cmdFeeUSD * NATIVE_DECIMALS) / nativePriceUSD;
+
+        return cmdFee;
+    }
+
+    function setCmdFees(
+        uint128 _evmCallReqV1FeeUSD,
+        uint128 _evmCallComputeV1MapFeeUSD,
+        uint128 _evmCallComputeV1ReduceFeeUSD,
+        uint128 _nativePriceUSD
+    ) external {
+        evmCallRequestV1FeeUSD = _evmCallReqV1FeeUSD;
+        evmCallComputeV1MapFeeUSD = _evmCallComputeV1MapFeeUSD;
+        evmCallComputeV1ReduceFeeUSD = _evmCallComputeV1ReduceFeeUSD;
+        nativePriceUSD = _nativePriceUSD;
+    }
+
+    function getCmdFees() external view returns (uint128, uint128, uint128, uint128) {
+        return (evmCallRequestV1FeeUSD, evmCallComputeV1MapFeeUSD, evmCallComputeV1ReduceFeeUSD, nativePriceUSD);
+    }
+
+    function _estimateCmdFee(bytes calldata _cmd) internal view returns (uint256 fee) {
+        ReadCmdCodecV1.Cmd memory cmd = ReadCmdCodecV1.decode(_cmd, _assertCmdTypeSupported);
+        fee = cmd.numEvmCallRequestV1 * evmCallRequestV1FeeUSD;
+        if (cmd.evmCallComputeV1Map) {
+            fee += evmCallComputeV1MapFeeUSD * cmd.numEvmCallRequestV1;
+        }
+        if (cmd.evmCallComputeV1Reduce) {
+            fee += evmCallComputeV1ReduceFeeUSD;
+        }
+    }
+
+    function _assertCmdTypeSupported(
+        uint32 _targetEid,
+        bool /*_isBlockNum*/,
+        uint64 /*_blockNumOrTimestamp*/,
+        uint8 _cmdType
+    ) internal view {
+        supportedCmdTypes.assertSupported(_targetEid, _cmdType);
+    }
+
+    receive() external payable virtual {}
+}

package/contracts/uln/dvn/adapters/CCIP/CCIPDVNAdapter.sol

@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { IRouterClient } from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IRouterClient.sol";
+import { IAny2EVMMessageReceiver } from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IAny2EVMMessageReceiver.sol";
+import { Client } from "@chainlink/contracts-ccip/src/v0.8/ccip/libraries/Client.sol";
+
+import { DVNAdapterBase } from "../DVNAdapterBase.sol";
+import { ICCIPDVNAdapter } from "../../../interfaces/adapters/ICCIPDVNAdapter.sol";
+import { ICCIPDVNAdapterFeeLib } from "../../../interfaces/adapters/ICCIPDVNAdapterFeeLib.sol";
+
+/// @title CCIPDVNAdapter
+/// @dev How CCIP DVN Adapter works:
+/// 1. Estimate gas cost for the message on-chain by calling `getFee` on the Router contract.
+///     refer to https://docs.chain.link/ccip/api-reference/i-router-client#getfee
+/// 2. Call `ccipSend` on the Router contract to send the message.
+///     refer to https://docs.chain.link/ccip/api-reference/i-router-client#ccipsend
+/// @dev Recovery:
+/// 1. If not enough gas paid, the message will be failed to execute on the destination chain, you can manually retry by calling `manuallyExecute` on the `OffRamp` contract.
+///     refer to https://github.com/smartcontractkit/ccip/blob/ccip-develop/contracts/src/v0.8/ccip/offRamp/EVM2EVMOffRamp.sol#L222
+contract CCIPDVNAdapter is DVNAdapterBase, IAny2EVMMessageReceiver, ICCIPDVNAdapter {
+    address private constant NATIVE_GAS_TOKEN_ADDRESS = address(0);
+
+    IRouterClient public immutable router;
+
+    mapping(uint32 dstEid => DstConfig) public dstConfig;
+    mapping(uint64 srcChainSelector => SrcConfig) public srcConfig;
+
+    constructor(address[] memory _admins, address _router) DVNAdapterBase(msg.sender, _admins, 12000) {
+        router = IRouterClient(_router);
+    }
+
+    // ========================= OnlyAdmin =========================
+    /// @notice sets configuration for destination chains
+    /// @param _params array of chain configurations
+    function setDstConfig(DstConfigParam[] calldata _params) external onlyRole(ADMIN_ROLE) {
+        for (uint256 i = 0; i < _params.length; i++) {
+            DstConfigParam calldata param = _params[i];
+
+            uint32 eid = param.eid % 30000;
+
+            // set once per chainSelector
+            // only one adapter per dvn that services both endpoint v1 and v2
+            // we standardize the eid stored here with mod 30000
+            if (dstConfig[eid].chainSelector == 0) {
+                dstConfig[eid].chainSelector = param.chainSelector;
+                dstConfig[eid].peer = param.peer;
+                srcConfig[param.chainSelector].eid = eid;
+                srcConfig[param.chainSelector].peer = param.peer;
+            }
+
+            dstConfig[eid].multiplierBps = param.multiplierBps;
+            dstConfig[eid].gas = param.gas;
+        }
+
+        emit DstConfigSet(_params);
+    }
+
+    // ========================= OnlyMessageLib =========================
+    function assignJob(
+        AssignJobParam calldata _param,
+        bytes calldata _options
+    ) external payable override onlyAcl(_param.sender) returns (uint256 totalFee) {
+        bytes32 receiveLib = _getAndAssertReceiveLib(msg.sender, _param.dstEid);
+
+        ICCIPDVNAdapterFeeLib.Param memory feeLibParam = ICCIPDVNAdapterFeeLib.Param(
+            _param.dstEid,
+            _param.confirmations,
+            _param.sender,
+            defaultMultiplierBps
+        );
+
+        DstConfig memory config = dstConfig[_param.dstEid % 30000];
+
+        bytes memory data = _encode(receiveLib, _param.packetHeader, _param.payloadHash);
+        Client.EVM2AnyMessage memory message = _createCCIPMessage(data, config.peer, config.gas);
+
+        IRouterClient ccipRouter = router;
+        uint256 ccipFee;
+        (ccipFee, totalFee) = ICCIPDVNAdapterFeeLib(workerFeeLib).getFeeOnSend(
+            feeLibParam,
+            config,
+            message,
+            _options,
+            ccipRouter
+        );
+
+        _assertBalanceAndWithdrawFee(msg.sender, ccipFee);
+
+        ccipRouter.ccipSend{ value: ccipFee }(config.chainSelector, message);
+    }
+
+    // ========================= OnlyRouter =========================
+    function ccipReceive(Client.Any2EVMMessage calldata _message) external {
+        if (msg.sender != address(router)) revert CCIPDVNAdapter_InvalidRouter(msg.sender);
+
+        SrcConfig memory config = srcConfig[_message.sourceChainSelector];
+
+        _assertPeer(_message.sourceChainSelector, _message.sender, config.peer);
+
+        _decodeAndVerify(config.eid, _message.data);
+    }
+
+    // ========================= View =========================
+    function getFee(
+        uint32 _dstEid,
+        uint64 _confirmations,
+        address _sender,
+        bytes calldata _options
+    ) external view override onlyAcl(_sender) returns (uint256 totalFee) {
+        ICCIPDVNAdapterFeeLib.Param memory feeLibParam = ICCIPDVNAdapterFeeLib.Param(
+            _dstEid,
+            _confirmations,
+            _sender,
+            defaultMultiplierBps
+        );
+
+        DstConfig memory config = dstConfig[_dstEid % 30000];
+
+        bytes memory data = _encodeEmpty();
+        Client.EVM2AnyMessage memory message = _createCCIPMessage(data, config.peer, config.gas);
+
+        totalFee = ICCIPDVNAdapterFeeLib(workerFeeLib).getFee(feeLibParam, config, message, _options, router);
+    }
+
+    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+        return interfaceId == type(IAny2EVMMessageReceiver).interfaceId || super.supportsInterface(interfaceId);
+    }
+
+    // ========================= Internal =========================
+    function _createCCIPMessage(
+        bytes memory _data,
+        bytes memory _receiver,
+        uint256 _gas
+    ) private pure returns (Client.EVM2AnyMessage memory message) {
+        message = Client.EVM2AnyMessage({
+            receiver: _receiver,
+            data: _data,
+            tokenAmounts: new Client.EVMTokenAmount[](0), // Empty array indicating no tokens are being sent
+            extraArgs: Client._argsToBytes(Client.EVMExtraArgsV1({ gasLimit: _gas, strict: false })),
+            feeToken: NATIVE_GAS_TOKEN_ADDRESS
+        });
+    }
+
+    function _assertPeer(uint64 _sourceChainSelector, bytes memory _sourceAddress, bytes memory peer) private pure {
+        if (keccak256(_sourceAddress) != keccak256(peer)) {
+            revert CCIPDVNAdapter_UntrustedPeer(_sourceChainSelector, _sourceAddress);
+        }
+    }
+}

package/contracts/uln/dvn/adapters/CCIP/CCIPDVNAdapterFeeLib.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { Proxied } from "hardhat-deploy/solc_0.8/proxy/Proxied.sol";
+import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+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 "../../../interfaces/adapters/ICCIPDVNAdapter.sol";
+import { ICCIPDVNAdapterFeeLib } from "../../../interfaces/adapters/ICCIPDVNAdapterFeeLib.sol";
+
+contract CCIPDVNAdapterFeeLib is OwnableUpgradeable, Proxied, ICCIPDVNAdapterFeeLib {
+    uint16 internal constant BPS_DENOMINATOR = 10000;
+
+    mapping(uint32 dstEid => DstConfig) public dstConfig;
+
+    function initialize() external proxied initializer {
+        __Ownable_init();
+    }
+
+    // ================================ OnlyOwner ===============================
+    function setDstConfig(DstConfigParam[] calldata _param) external onlyOwner {
+        for (uint256 i = 0; i < _param.length; i++) {
+            DstConfigParam calldata param = _param[i];
+
+            dstConfig[param.dstEid] = DstConfig({ floorMarginUSD: param.floorMarginUSD });
+        }
+
+        emit DstConfigSet(_param);
+    }
+
+    // ================================ External ================================
+    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) {
+        if (_dstConfig.gas == 0) revert CCIPDVNAdapter_EidNotSupported(_params.dstEid);
+        if (_options.length > 0) revert CCIPDVNAdapter_OptionsUnsupported();
+
+        ccipFee = _router.getFee(_dstConfig.chainSelector, _message);
+        totalFee = _applyPremium(_dstConfig.multiplierBps, _params.defaultMultiplierBps, ccipFee);
+    }
+
+    function getFee(
+        Param calldata _params,
+        ICCIPDVNAdapter.DstConfig calldata _dstConfig,
+        Client.EVM2AnyMessage calldata _message,
+        bytes calldata _options,
+        IRouterClient _router
+    ) external view returns (uint256 totalFee) {
+        if (_dstConfig.gas == 0) revert CCIPDVNAdapter_EidNotSupported(_params.dstEid);
+        if (_options.length > 0) revert CCIPDVNAdapter_OptionsUnsupported();
+
+        totalFee = _router.getFee(_dstConfig.chainSelector, _message);
+        totalFee = _applyPremium(_dstConfig.multiplierBps, _params.defaultMultiplierBps, totalFee);
+    }
+
+    // ================================ Internal ================================
+    function _applyPremium(
+        uint16 _multiplierBps,
+        uint16 _defaultMultiplierBps,
+        uint256 _fee
+    ) internal pure returns (uint256 fee) {
+        uint256 multiplier = _multiplierBps == 0 ? _defaultMultiplierBps : _multiplierBps;
+        fee = (_fee * multiplier) / BPS_DENOMINATOR;
+    }
+}

package/contracts/uln/dvn/adapters/DVNAdapterBase.sol

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { Transfer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol";
+import { ISendLib } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ISendLib.sol";
+
+import { ILayerZeroDVN } from "../../interfaces/ILayerZeroDVN.sol";
+import { Worker } from "../../../Worker.sol";
+import { DVNAdapterMessageCodec } from "./libs/DVNAdapterMessageCodec.sol";
+
+interface ISendLibBase {
+    function fees(address _worker) external view returns (uint256);
+}
+
+interface IReceiveUln {
+    function verify(bytes calldata _packetHeader, bytes32 _payloadHash, uint64 _confirmations) external;
+}
+
+struct ReceiveLibParam {
+    address sendLib;
+    uint32 dstEid;
+    bytes32 receiveLib;
+}
+
+/// @title SendDVNAdapterBase
+/// @notice base contract for DVN adapters
+/// @dev limitations:
+///  - doesn't accept alt token
+///  - doesn't respect block confirmations
+abstract contract DVNAdapterBase is Worker, ILayerZeroDVN {
+    // --- Errors ---
+    error DVNAdapter_InsufficientBalance(uint256 actual, uint256 requested);
+    error DVNAdapter_NotImplemented();
+    error DVNAdapter_MissingRecieveLib(address sendLib, uint32 dstEid);
+
+    event ReceiveLibsSet(ReceiveLibParam[] params);
+
+    /// @dev on change of application config, dvn adapters will not perform any additional verification
+    /// @dev to avoid messages from being stuck, all verifications from adapters will be done with the maximum possible confirmations
+    uint64 internal constant MAX_CONFIRMATIONS = type(uint64).max;
+
+    /// @dev receive lib to call verify() on at destination
+    mapping(address sendLib => mapping(uint32 dstEid => bytes32 receiveLib)) public receiveLibs;
+
+    constructor(
+        address _roleAdmin,
+        address[] memory _admins,
+        uint16 _defaultMultiplierBps
+    ) Worker(new address[](0), address(0x0), _defaultMultiplierBps, _roleAdmin, _admins) {}
+
+    // ========================= OnlyAdmin =========================
+    /// @notice sets receive lib for destination chains
+    /// @dev DEFAULT_ADMIN_ROLE can set MESSAGE_LIB_ROLE for sendLibs and use below function to set receiveLibs
+    function setReceiveLibs(ReceiveLibParam[] calldata _params) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        for (uint256 i = 0; i < _params.length; i++) {
+            ReceiveLibParam calldata param = _params[i];
+            receiveLibs[param.sendLib][param.dstEid] = param.receiveLib;
+        }
+
+        emit ReceiveLibsSet(_params);
+    }
+
+    // ========================= Internal =========================
+    function _getAndAssertReceiveLib(address _sendLib, uint32 _dstEid) internal view returns (bytes32 lib) {
+        lib = receiveLibs[_sendLib][_dstEid];
+        if (lib == bytes32(0)) revert DVNAdapter_MissingRecieveLib(_sendLib, _dstEid);
+    }
+
+    function _encode(
+        bytes32 _receiveLib,
+        bytes memory _packetHeader,
+        bytes32 _payloadHash
+    ) internal pure returns (bytes memory) {
+        return DVNAdapterMessageCodec.encode(_receiveLib, _packetHeader, _payloadHash);
+    }
+
+    function _encodeEmpty() internal pure returns (bytes memory) {
+        return
+            DVNAdapterMessageCodec.encode(bytes32(0), new bytes(DVNAdapterMessageCodec.PACKET_HEADER_SIZE), bytes32(0));
+    }
+
+    function _decodeAndVerify(uint32 _srcEid, bytes calldata _payload) internal {
+        require((DVNAdapterMessageCodec.srcEid(_payload) % 30000) == _srcEid, "DVNAdapterBase: invalid srcEid");
+
+        (address receiveLib, bytes memory packetHeader, bytes32 payloadHash) = DVNAdapterMessageCodec.decode(_payload);
+
+        IReceiveUln(receiveLib).verify(packetHeader, payloadHash, MAX_CONFIRMATIONS);
+    }
+
+    function _withdrawFeeFromSendLib(address _sendLib, address _to) internal {
+        uint256 fee = ISendLibBase(_sendLib).fees(address(this));
+        if (fee > 0) {
+            ISendLib(_sendLib).withdrawFee(_to, fee);
+            emit Withdraw(_sendLib, _to, fee);
+        }
+    }
+
+    function _assertBalanceAndWithdrawFee(address _sendLib, uint256 _messageFee) internal {
+        uint256 balance = address(this).balance;
+        if (balance < _messageFee) {
+            // withdraw all fees from the sendLib if balance is insufficient
+            _withdrawFeeFromSendLib(_sendLib, address(this));
+
+            // check balance again
+            balance = address(this).balance;
+            // revert if balance is still insufficient, need to transfer more funds manually to the adapter
+            if (balance < _messageFee) revert DVNAdapter_InsufficientBalance(balance, _messageFee);
+        }
+    }
+
+    /// @dev to receive refund
+    receive() external payable {}
+}