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

package/contracts/uln/dvn/DVN.sol

@@ -26,13 +26,13 @@ contract DVN is Worker, MultiSig, IDVN {
     mapping(uint32 dstEid => DstConfig) public dstConfig;
     mapping(bytes32 executableHash => bool used) public usedHashes;
 
-    error OnlySelf();
-    error InvalidRole(bytes32 role);
-    error InstructionExpired();
-    error InvalidTarget(address target);
-    error InvalidVid(uint32 vid);
-    error InvalidSignatures();
-    error DuplicatedHash(bytes32 executableHash);
+    error DVN_OnlySelf();
+    error DVN_InvalidRole(bytes32 role);
+    error DVN_InstructionExpired();
+    error DVN_InvalidTarget(address target);
+    error DVN_InvalidVid(uint32 vid);
+    error DVN_InvalidSignatures();
+    error DVN_DuplicatedHash(bytes32 executableHash);
 
     event VerifySignaturesFailed(uint256 idx);
     event ExecuteFailed(uint256 _index, bytes _data);
@@ -72,20 +72,20 @@ contract DVN is Worker, MultiSig, IDVN {
         if (_role == ALLOWLIST || _role == DENYLIST || _role == MESSAGE_LIB_ROLE) {
             // self required
             if (address(this) != msg.sender) {
-                revert OnlySelf();
+                revert DVN_OnlySelf();
             }
         } else if (_role == ADMIN_ROLE) {
             // admin required
             _checkRole(ADMIN_ROLE);
         } else {
-            revert InvalidRole(_role);
+            revert DVN_InvalidRole(_role);
         }
         _;
     }
 
     modifier onlySelf() {
         if (address(this) != msg.sender) {
-            revert OnlySelf();
+            revert DVN_OnlySelf();
         }
         _;
     }
@@ -131,23 +131,23 @@ contract DVN is Worker, MultiSig, IDVN {
     /// @dev calldata in the case is abi.encode new admin address
     function quorumChangeAdmin(ExecuteParam calldata _param) external {
         if (_param.expiration <= block.timestamp) {
-            revert InstructionExpired();
+            revert DVN_InstructionExpired();
         }
         if (_param.target != address(this)) {
-            revert InvalidTarget(_param.target);
+            revert DVN_InvalidTarget(_param.target);
         }
         if (_param.vid != vid) {
-            revert InvalidVid(_param.vid);
+            revert DVN_InvalidVid(_param.vid);
         }
 
         // generate and validate hash
         bytes32 hash = hashCallData(_param.vid, _param.target, _param.callData, _param.expiration);
         (bool sigsValid, ) = verifySignatures(hash, _param.signatures);
         if (!sigsValid) {
-            revert InvalidSignatures();
+            revert DVN_InvalidSignatures();
         }
         if (usedHashes[hash]) {
-            revert DuplicatedHash(hash);
+            revert DVN_DuplicatedHash(hash);
         }
 
         usedHashes[hash] = true;
@@ -221,7 +221,7 @@ contract DVN is Worker, MultiSig, IDVN {
     /// @param _amount amount to withdraw
     function withdrawFeeFromUlnV2(address _lib, address payable _to, uint256 _amount) external onlyRole(ADMIN_ROLE) {
         if (!hasRole(MESSAGE_LIB_ROLE, _lib)) {
-            revert OnlyMessageLib();
+            revert Worker_OnlyMessageLib();
         }
         ILayerZeroUltraLightNodeV2(_lib).withdrawNative(_to, _amount);
     }

package/contracts/uln/dvn/DVNFeeLib.sol

@@ -129,9 +129,9 @@ contract DVNFeeLib is Ownable, IDVNFeeLib {
         while (cursor < _options.length) {
             (uint8 optionType, , uint256 newCursor) = _options.nextDVNOption(cursor);
             cursor = newCursor;
-            revert UnsupportedOptionType(optionType);
+            revert DVN_UnsupportedOptionType(optionType);
         }
-        if (cursor != _options.length) revert DVNOptions.InvalidDVNOptions(cursor);
+        if (cursor != _options.length) revert DVNOptions.DVN_InvalidDVNOptions(cursor);
 
         return 0; // todo: precrime fee model
     }

package/contracts/uln/dvn/MultiSig.sol

@@ -16,34 +16,34 @@ abstract contract MultiSig {
     uint64 public signerSize;
     uint64 public quorum;
 
-    error OnlySigner();
-    error QuorumIsZero();
-    error SignersSizeIsLessThanQuorum(uint64 signersSize, uint64 quorum);
-    error UnorderedSigners();
-    error StateAlreadySet(address signer, bool active);
+    error MultiSig_OnlySigner();
+    error MultiSig_QuorumIsZero();
+    error MultiSig_SignersSizeIsLessThanQuorum(uint64 signersSize, uint64 quorum);
+    error MultiSig_UnorderedSigners();
+    error MultiSig_StateAlreadySet(address signer, bool active);
 
     event UpdateSigner(address _signer, bool _active);
     event UpdateQuorum(uint64 _quorum);
 
     modifier onlySigner() {
         if (!signers[msg.sender]) {
-            revert OnlySigner();
+            revert MultiSig_OnlySigner();
         }
         _;
     }
 
     constructor(address[] memory _signers, uint64 _quorum) {
         if (_quorum == 0) {
-            revert QuorumIsZero();
+            revert MultiSig_QuorumIsZero();
         }
         if (_signers.length < _quorum) {
-            revert SignersSizeIsLessThanQuorum(uint64(_signers.length), _quorum);
+            revert MultiSig_SignersSizeIsLessThanQuorum(uint64(_signers.length), _quorum);
         }
         address lastSigner = address(0);
         for (uint256 i = 0; i < _signers.length; i++) {
             address signer = _signers[i];
             if (signer <= lastSigner) {
-                revert UnorderedSigners();
+                revert MultiSig_UnorderedSigners();
             }
             signers[signer] = true;
             lastSigner = signer;
@@ -54,13 +54,13 @@ abstract contract MultiSig {
 
     function _setSigner(address _signer, bool _active) internal {
         if (signers[_signer] == _active) {
-            revert StateAlreadySet(_signer, _active);
+            revert MultiSig_StateAlreadySet(_signer, _active);
         }
         signers[_signer] = _active;
         uint64 _signerSize = _active ? signerSize + 1 : signerSize - 1;
         uint64 _quorum = quorum;
         if (_signerSize < _quorum) {
-            revert SignersSizeIsLessThanQuorum(_signerSize, _quorum);
+            revert MultiSig_SignersSizeIsLessThanQuorum(_signerSize, _quorum);
         }
         signerSize = _signerSize;
         emit UpdateSigner(_signer, _active);
@@ -68,11 +68,11 @@ abstract contract MultiSig {
 
     function _setQuorum(uint64 _quorum) internal {
         if (_quorum == 0) {
-            revert QuorumIsZero();
+            revert MultiSig_QuorumIsZero();
         }
         uint64 _signerSize = signerSize;
         if (_signerSize < _quorum) {
-            revert SignersSizeIsLessThanQuorum(_signerSize, _quorum);
+            revert MultiSig_SignersSizeIsLessThanQuorum(_signerSize, _quorum);
         }
         quorum = _quorum;
         emit UpdateQuorum(_quorum);

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

@@ -3,57 +3,48 @@
 pragma solidity ^0.8.20;
 
 import { IRouterClient } from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IRouterClient.sol";
-import { CCIPReceiver } from "@chainlink/contracts-ccip/src/v0.8/ccip/applications/CCIPReceiver.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";
-
-contract CCIPDVNAdapter is CCIPReceiver, DVNAdapterBase {
-    struct DstConfigParam {
-        uint32 dstEid;
-        // 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;
-        uint256 gasLimit;
-        bytes peer;
-    }
-
-    struct DstConfig {
-        uint64 chainSelector;
-        uint16 multiplierBps;
-        uint256 gasLimit;
-        bytes peer;
-    }
-
+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);
 
-    event DstConfigSet(DstConfigParam[] params);
+    IRouterClient public router;
 
     mapping(uint32 dstEid => DstConfig config) public dstConfig;
-    mapping(uint64 chainSelector => uint32 eid) public CCIPChainToEid;
+    mapping(uint64 chainSelector => bytes peer) public peers;
 
-    constructor(
-        address _sendLib,
-        address _receiveLib,
-        address[] memory _admins,
-        address router
-    ) CCIPReceiver(router) DVNAdapterBase(_sendLib, _receiveLib, _admins) {}
+    constructor(address[] memory _admins, address _router) DVNAdapterBase(msg.sender, _admins, 12000) {
+        router = IRouterClient(_router);
+    }
 
-    /// @notice sets configuration (`chainSelector`, `multiplierBps`, `gasLimit` and `peer`) for destination chains
-    /// @dev The `multiplierBps` can be updated separately using `setDstMultiplierBps` function
+    // ========================= OnlyAdmin =========================
+    /// @notice sets configuration for destination chains
     /// @param _params array of chain configurations
-    function setDstConfig(DstConfigParam[] calldata _params) external onlyAdmin {
+    function setDstConfig(DstConfigParam[] calldata _params) external onlyRole(ADMIN_ROLE) {
         for (uint256 i = 0; i < _params.length; i++) {
             DstConfigParam calldata param = _params[i];
 
-            delete CCIPChainToEid[dstConfig[param.dstEid].chainSelector];
+            delete peers[dstConfig[param.dstEid].chainSelector]; // delete old peer in case chain by dstEid is updated
+            peers[param.chainSelector] = param.peer;
 
-            CCIPChainToEid[param.chainSelector] = param.dstEid;
             dstConfig[param.dstEid] = DstConfig({
                 chainSelector: param.chainSelector,
                 multiplierBps: param.multiplierBps,
-                gasLimit: param.gasLimit,
+                gas: param.gas,
                 peer: param.peer
             });
         }
@@ -61,92 +52,99 @@ contract CCIPDVNAdapter is CCIPReceiver, DVNAdapterBase {
         emit DstConfigSet(_params);
     }
 
-    /// @notice sets fee multiplier in basis points for destination chains
-    /// @param _params array of multipliers for destination chains
-    function setDstMultiplier(DstMultiplierParam[] calldata _params) external onlyAdmin {
-        for (uint256 i = 0; i < _params.length; i++) {
-            DstMultiplierParam calldata param = _params[i];
-            dstConfig[param.dstEid].multiplierBps = param.multiplierBps;
-        }
-
-        emit DstMultiplierSet(_params);
+    function setRouter(address _router) external onlyRole(ADMIN_ROLE) {
+        router = IRouterClient(_router);
+        emit RouterSet(_router);
     }
 
-    function getFee(
-        uint32 _dstEid,
-        uint64 /*_confirmations*/,
-        address _sender,
-        bytes calldata /*_options*/
-    ) external view override returns (uint256 fee) {
-        DstConfig storage config = dstConfig[_dstEid];
-
-        Client.EVM2AnyMessage memory message = _createCCIPMessage(
-            new bytes(PACKET_HEADER_SIZE),
-            bytes32(0),
-            config.peer,
-            config.gasLimit
+    // ========================= 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
         );
 
-        fee = _getCCIPFee(config.chainSelector, message);
-        if (address(feeLib) != address(0)) {
-            fee = feeLib.getFee(_dstEid, _sender, defaultMultiplierBps, config.multiplierBps, fee);
-        }
+        DstConfig memory config = dstConfig[_param.dstEid];
+
+        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);
     }
 
-    function assignJob(
-        AssignJobParam calldata _param,
-        bytes calldata /*_options*/
-    ) external payable override onlySendLib returns (uint256 fee) {
-        DstConfig memory config = dstConfig[_param.dstEid];
+    // ========================= OnlyRouter =========================
+    function ccipReceive(Client.Any2EVMMessage calldata _message) external {
+        if (msg.sender != address(router)) revert CCIPDVNAdapter_InvalidRouter(msg.sender);
+
+        _assertPeer(_message.sourceChainSelector, _message.sender);
 
-        Client.EVM2AnyMessage memory message = _createCCIPMessage(
-            _param.packetHeader,
-            _param.payloadHash,
-            config.peer,
-            config.gasLimit
+        _decodeAndVerify(_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
         );
 
-        fee = _getCCIPFee(config.chainSelector, message);
-        _assertBalanceAndWithdrawFee(fee);
+        DstConfig memory config = dstConfig[_dstEid];
 
-        IRouterClient(getRouter()).ccipSend{ value: fee }(config.chainSelector, message);
+        bytes memory data = _encodeEmpty();
+        Client.EVM2AnyMessage memory message = _createCCIPMessage(data, config.peer, config.gas);
 
-        if (address(feeLib) != address(0)) {
-            fee = feeLib.getFee(_param.dstEid, _param.sender, defaultMultiplierBps, config.multiplierBps, fee);
-        }
+        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 _packetHeader,
-        bytes32 _payloadHash,
+        bytes memory _data,
         bytes memory _receiver,
-        uint256 _gasLimit
+        uint256 _gas
     ) private pure returns (Client.EVM2AnyMessage memory message) {
         message = Client.EVM2AnyMessage({
             receiver: _receiver,
-            data: _encodePayload(_packetHeader, _payloadHash),
+            data: _data,
             tokenAmounts: new Client.EVMTokenAmount[](0), // Empty array indicating no tokens are being sent
-            extraArgs: Client._argsToBytes(Client.EVMExtraArgsV1({ gasLimit: _gasLimit, strict: false })),
+            extraArgs: Client._argsToBytes(Client.EVMExtraArgsV1({ gasLimit: _gas, strict: false })),
             feeToken: NATIVE_GAS_TOKEN_ADDRESS
         });
     }
 
-    function _getCCIPFee(
-        uint64 _dstChainSelector,
-        Client.EVM2AnyMessage memory _message
-    ) private view returns (uint256 ccipFee) {
-        ccipFee = IRouterClient(getRouter()).getFee(_dstChainSelector, _message);
-    }
-
-    function _ccipReceive(Client.Any2EVMMessage memory _message) internal override {
-        _assertPeer(_message.sourceChainSelector, _message.sender);
-        _verify(_message.data);
-    }
-
     function _assertPeer(uint64 _sourceChainSelector, bytes memory _sourceAddress) private view {
-        uint32 sourceEid = CCIPChainToEid[_sourceChainSelector];
-        bytes memory sourcePeer = dstConfig[sourceEid].peer;
-
-        if (keccak256(_sourceAddress) != keccak256(sourcePeer)) revert Unauthorized();
+        bytes memory sourcePeer = peers[_sourceChainSelector];
+        if (keccak256(_sourceAddress) != keccak256(sourcePeer)) {
+            revert CCIPDVNAdapter_UntrustedPeer(_sourceChainSelector, _sourceAddress);
+        }
     }
 }

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

@@ -2,6 +2,68 @@
 
 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 { 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";
 
-contract CCIPDVNAdapterFeeLib is DVNAdapterFeeLibBase {}
+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 (_options.length > 0) revert CCIPDVN_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 (_options.length > 0) revert CCIPDVN_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;
+    }
+}