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

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

@@ -2,161 +2,111 @@
 
 pragma solidity ^0.8.20;
 
-import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
-import { BytesLib } from "solidity-bytes-utils/contracts/BytesLib.sol";
-
 import { Transfer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol";
-import { IMessageLib } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/IMessageLib.sol";
 import { ISendLib } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ISendLib.sol";
 
 import { ILayerZeroDVN } from "../../interfaces/ILayerZeroDVN.sol";
-import { IReceiveUlnE2 } from "../../interfaces/IReceiveUlnE2.sol";
-import { IDVNAdapterFeeLib } from "../../interfaces/IDVNAdapterFeeLib.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;
+}
 
-/// @title DVNAdapterBase
+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
-///  - doesn't support multiple libraries. One deployment per library
-abstract contract DVNAdapterBase is Ownable, ILayerZeroDVN {
-    using BytesLib for bytes;
+abstract contract DVNAdapterBase is Worker, ILayerZeroDVN {
+    // --- Errors ---
+    error DVNAdapter_InsufficientBalance(uint256 actual, uint256 requested);
+    error DVNAdapter_NotImplemented();
+    error DVNAdapter_MissingRecieveLib(address sendLib, uint32 dstEid);
 
-    struct DstMultiplierParam {
-        uint32 dstEid;
-        uint16 multiplierBps;
-    }
+    event ReceiveLibsSet(ReceiveLibParam[] params);
 
-    /// @dev for protocols that doesn't allow to configure outbound block confirmations per message,
-    /// ignore confirmations set in the config and use the maximum possible confirmations to prevent failure
-    /// in the receive library due to insufficient confirmations if the config was changed before the message is received
+    /// @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;
 
-    uint256 internal constant PACKET_HEADER_SIZE = 81;
-    uint256 internal constant PAYLOAD_HASH_SIZE = 32;
-    uint256 internal constant PAYLOAD_SIZE = PACKET_HEADER_SIZE + PAYLOAD_HASH_SIZE;
-
-    ISendLib public immutable sendLib;
-    IReceiveUlnE2 public immutable receiveLib;
-    IDVNAdapterFeeLib public feeLib;
-
-    uint16 public defaultMultiplierBps = 10_000; // no multiplier
-    mapping(address admin => bool) public admins;
-
-    error OnlySendLib();
-    error Unauthorized();
-    error InvalidPayloadSize();
-    error VersionMismatch();
-
-    event AdminSet(address indexed admin, bool isAdmin);
-    event DefaultMultiplierSet(uint16 multiplierBps);
-    event DstMultiplierSet(DstMultiplierParam[] params);
-    event FeeLibSet(address indexed feeLib);
-    event FeeWithdrawn(address indexed to, uint256 amount);
-    event TokenWithdrawn(address indexed to, address token, uint256 amount);
-
-    modifier onlySendLib() {
-        if (msg.sender != address(sendLib)) revert OnlySendLib();
-        _;
-    }
-
-    modifier onlyAdmin() {
-        if (!admins[msg.sender]) revert Unauthorized();
-        _;
-    }
-
-    constructor(address _sendLib, address _receiveLib, address[] memory _admins) {
-        (uint64 sendMajor, uint8 sendMinor, uint8 sendEndpoint) = IMessageLib(_sendLib).version();
-        (uint64 receiveMajor, uint8 receiveMinor, uint8 receiveEndpoint) = IMessageLib(_receiveLib).version();
-
-        if (sendMajor != receiveMajor || sendMinor != receiveMinor || sendEndpoint != receiveEndpoint) {
-            revert VersionMismatch();
+    /// @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;
         }
 
-        sendLib = ISendLib(_sendLib);
-        receiveLib = IReceiveUlnE2(_receiveLib);
-
-        for (uint256 i = 0; i < _admins.length; i++) {
-            admins[_admins[i]] = true;
-            emit AdminSet(_admins[i], true);
-        }
+        emit ReceiveLibsSet(_params);
     }
 
-    function setAdmin(address _admin, bool _isAdmin) external onlyOwner {
-        admins[_admin] = _isAdmin;
-        emit AdminSet(_admin, _isAdmin);
+    // ========================= 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);
     }
 
-    // -------------------- Only Admin --------------------
-
-    /// @notice sets the default fee multiplier in basis points
-    /// @param _defaultMultiplierBps default fee multiplier
-    function setDefaultMultiplier(uint16 _defaultMultiplierBps) external onlyAdmin {
-        defaultMultiplierBps = _defaultMultiplierBps;
-        emit DefaultMultiplierSet(_defaultMultiplierBps);
+    function _encode(
+        bytes32 _receiveLib,
+        bytes memory _packetHeader,
+        bytes32 _payloadHash
+    ) internal pure returns (bytes memory) {
+        return DVNAdapterMessageCodec.encode(_receiveLib, _packetHeader, _payloadHash);
     }
 
-    function setFeeLib(address _feeLib) external onlyAdmin {
-        feeLib = IDVNAdapterFeeLib(_feeLib);
-        emit FeeLibSet(_feeLib);
+    function _encodeEmpty() internal pure returns (bytes memory) {
+        return
+            DVNAdapterMessageCodec.encode(bytes32(0), new bytes(DVNAdapterMessageCodec.PACKET_HEADER_SIZE), bytes32(0));
     }
 
-    /// @dev supports withdrawing fee from ULN301, ULN302 and more
-    /// @param _to address to withdraw fee to
-    /// @param _amount amount to withdraw
-    function withdrawFee(address _to, uint256 _amount) external onlyAdmin {
-        _withdrawFee(_to, _amount);
-    }
+    function _decodeAndVerify(bytes calldata _payload) internal {
+        (address receiveLib, bytes memory packetHeader, bytes32 payloadHash) = DVNAdapterMessageCodec.decode(_payload);
 
-    /// @dev supports withdrawing token from the contract
-    /// @param _token token address
-    /// @param _to address to withdraw token to
-    /// @param _amount amount to withdraw
-    function withdrawToken(address _token, address _to, uint256 _amount) external onlyAdmin {
-        // transfers native if _token is address(0x0)
-        Transfer.nativeOrToken(_token, _to, _amount);
-        emit TokenWithdrawn(_to, _token, _amount);
+        IReceiveUln(receiveLib).verify(packetHeader, payloadHash, MAX_CONFIRMATIONS);
     }
 
-    // -------------------- Internal Functions --------------------
-
-    function _assertBalanceAndWithdrawFee(uint256 _messageFee) internal {
-        uint256 balance = address(this).balance;
-
-        if (balance < _messageFee) {
-            // withdraw fees from the sendLib if balance is insufficient
-            // sendLib will revert if not enough fees were accumulated
-            _withdrawFee(address(this), _messageFee - balance); // todo: why not withdraw all fees from sendLib? so that dont need to withdraw every time
+    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 _withdrawFee(address _to, uint256 _amount) internal {
-        sendLib.withdrawFee(_to, _amount);
-        emit FeeWithdrawn(_to, _amount);
-    }
-
-    function _encodePayload(
-        bytes memory _packetHeader,
-        bytes32 _payloadHash
-    ) internal pure returns (bytes memory payload) {
-        return abi.encodePacked(_packetHeader, _payloadHash);
-    }
-
-    function _decodePayload(
-        bytes memory _payload
-    ) internal pure returns (bytes memory packetHeader, bytes32 payloadHash) {
-        if (_payload.length != PAYLOAD_SIZE) revert InvalidPayloadSize();
-        uint256 start = 0;
-        packetHeader = _payload.slice(start, PACKET_HEADER_SIZE);
-
-        start += PACKET_HEADER_SIZE;
-        payloadHash = _payload.toBytes32(start);
-    }
+    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));
 
-    function _verify(bytes memory _payload) internal {
-        (bytes memory packetHeader, bytes32 payloadHash) = _decodePayload(_payload);
-        receiveLib.verify(packetHeader, payloadHash, MAX_CONFIRMATIONS);
+            // 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 {}
 }

package/contracts/uln/dvn/adapters/arbitrum/ArbitrumDVNAdapterL1.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.20;
+
+import { IInbox } from "@arbitrum/nitro-contracts/src/bridge/IInbox.sol";
+
+import { ArbitrumDVNAdapterL2 } from "./ArbitrumDVNAdapterL2.sol";
+import { DVNAdapterBase } from "../DVNAdapterBase.sol";
+import { DVNAdapterMessageCodec } from "../libs/DVNAdapterMessageCodec.sol";
+
+contract ArbitrumDVNAdapterL1 is DVNAdapterBase {
+    // --- Config Struct ---
+    struct DstConfig {
+        uint16 multiplierBps;
+        uint256 maxSubmissionCost;
+        uint256 gasLimit;
+        uint256 maxFeePerGas;
+    }
+
+    // --- Events ---
+    event RetryableTicketCreated(uint256 indexed ticketId);
+    error OnlyArbitrum();
+
+    uint32 public immutable arbitrumEid; // eid % 30000 (v1 eid)
+    IInbox public immutable inbox;
+
+    address public peer; // L2 adapter
+    DstConfig public dstConfig;
+
+    constructor(
+        address[] memory _admins,
+        uint32 _arbitrumEid,
+        address _inbox
+    ) DVNAdapterBase(msg.sender, _admins, 12000) {
+        arbitrumEid = _arbitrumEid; // eid % 30000 (v1 eid)
+        inbox = IInbox(_inbox);
+    }
+
+    // --- Admin ---
+    function setPeer(address _peer) external onlyRole(ADMIN_ROLE) {
+        peer = _peer;
+    }
+
+    function setDstConfig(
+        uint16 _multiplierBps,
+        uint256 _maxSubmissionCost,
+        uint256 _gasLimit,
+        uint256 _maxFeePerGas
+    ) external onlyRole(ADMIN_ROLE) {
+        dstConfig = DstConfig({
+            multiplierBps: _multiplierBps,
+            maxSubmissionCost: _maxSubmissionCost,
+            gasLimit: _gasLimit,
+            maxFeePerGas: _maxFeePerGas
+        });
+    }
+
+    // --- Send ---
+    function assignJob(
+        AssignJobParam calldata _param,
+        bytes calldata /*_options*/
+    ) external payable override onlyRole(MESSAGE_LIB_ROLE) onlyAcl(_param.sender) returns (uint256 fee) {
+        DstConfig storage config = dstConfig;
+        fee = _getArbitrumFee(_param.dstEid, config);
+
+        bytes memory payload = abi.encodeWithSelector(
+            ArbitrumDVNAdapterL2.verify.selector,
+            DVNAdapterMessageCodec.encode(
+                receiveLibs[msg.sender][_param.dstEid],
+                _param.packetHeader,
+                _param.payloadHash
+            )
+        );
+
+        // fee estimation: https://github.com/OffchainLabs/arbitrum-sdk/blob/main/src/lib/message/L1ToL2MessageCreator.ts#L52
+        uint256 ticketID = inbox.createRetryableTicket{ value: fee }(
+            peer,
+            0,
+            config.maxSubmissionCost,
+            peer,
+            peer,
+            config.gasLimit,
+            config.maxFeePerGas,
+            payload
+        );
+        emit RetryableTicketCreated(ticketID);
+
+        // adjust fee based on multiplier
+        //        if (workerFeeLib != address(0)) {
+        //            fee = IDVNAdapterFeeLib(workerFeeLib).getFee(
+        //                _param.dstEid,
+        //                _param.sender,
+        //                defaultMultiplierBps,
+        //                config.multiplierBps,
+        //                fee
+        //            );
+        //        }
+    }
+
+    // --- View ---
+    function getFee(
+        uint32 _dstEid,
+        uint64 /*_confirmations*/,
+        address _sender,
+        bytes calldata /*_options*/
+    ) public view override onlyAcl(_sender) returns (uint256 fee) {
+        DstConfig storage config = dstConfig;
+        fee = _getArbitrumFee(_dstEid, config);
+
+        // adjust fee based on multiplier
+        //        if (workerFeeLib != address(0)) {
+        //            fee = IDVNAdapterFeeLib(workerFeeLib).getFee(
+        //                _dstEid,
+        //                _sender,
+        //                defaultMultiplierBps,
+        //                config.multiplierBps,
+        //                fee
+        //            );
+        //        }
+    }
+
+    function _getArbitrumFee(uint32 _dstEid, DstConfig storage _dstConfig) internal view returns (uint256 fee) {
+        if (_dstEid % 30000 != arbitrumEid) revert OnlyArbitrum();
+        fee = _dstConfig.maxSubmissionCost + _dstConfig.gasLimit * _dstConfig.maxFeePerGas;
+    }
+}

package/contracts/uln/dvn/adapters/arbitrum/ArbitrumDVNAdapterL2.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.20;
+
+import { AddressAliasHelper } from "@arbitrum/nitro-contracts/src/libraries/AddressAliasHelper.sol";
+
+import { DVNAdapterBase } from "../DVNAdapterBase.sol";
+
+contract ArbitrumDVNAdapterL2 is DVNAdapterBase {
+    // --- Errors ---
+    error UntrustedPeer(address peer);
+
+    // --- Events ---
+    event PeerSet(address peer);
+
+    // --- Variables ---
+    address public peer; // L1 adapter
+
+    constructor(address[] memory _admins) DVNAdapterBase(msg.sender, _admins, 12000) {}
+
+    // --- 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 {
+        // To check that message came from L1, we check that the sender is the L1 contract's L2 alias.
+        if (msg.sender != AddressAliasHelper.applyL1ToL2Alias(peer)) revert UntrustedPeer(msg.sender);
+        _decodeAndVerify(_payload);
+    }
+}

package/contracts/uln/dvn/adapters/avalanche/NOTES.md

@@ -0,0 +1,4 @@
+https://github.com/ava-labs/teleporter/blob/main/contracts/src/Teleporter/README.md
+https://github.com/ava-labs/teleporter/blob/main/contracts/src/CrossChainApplications/ExampleMessenger/ExampleCrossChainMessenger.sol
+https://github.com/ava-labs/public-avalanche-sdks/tree/main/apps/teleporter-demo
+https://github.com/ava-labs/xsvm

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

@@ -3,154 +3,139 @@
 pragma solidity ^0.8.20;
 
 import { AxelarExecutable } from "@axelar-network/axelar-gmp-sdk-solidity/contracts/executable/AxelarExecutable.sol";
-import { IAxelarGasService } from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGasService.sol";
+import { ISendLib } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ISendLib.sol";
 
 import { DVNAdapterBase } from "../DVNAdapterBase.sol";
+import { IAxelarDVNAdapter } from "../../../interfaces/adapters/IAxelarDVNAdapter.sol";
+import { IAxelarDVNAdapterFeeLib } from "../../../interfaces/adapters/IAxelarDVNAdapterFeeLib.sol";
 
-contract AxelarDVNAdapter is AxelarExecutable, DVNAdapterBase {
-    struct DstConfigParam {
-        uint32 dstEid;
-        uint16 multiplierBps;
-        uint256 nativeGasFee;
-        string peer;
-        string chainName;
-    }
-
-    struct DstFeeParam {
-        uint32 dstEid;
-        uint256 nativeGasFee;
-    }
-
-    struct DstConfig {
-        uint256 nativeGasFee;
-        uint16 multiplierBps;
-        string peer;
-        string chainName;
-    }
-
-    event DstConfigSet(DstConfigParam[] params);
-    event DstFeeSet(DstFeeParam[] params);
-
-    IAxelarGasService public immutable gasService;
-
-    mapping(uint32 dstEid => DstConfig config) public dstConfig;
-    mapping(string axelarChain => uint32 eid) public axelarChainToEid;
+interface ISendLibBase {
+    function fees(address _worker) external view returns (uint256);
+}
 
+/// @title AxelarDVNAdapter
+/// @dev How Axelar DVN Adapter works:
+///  1. Estimate gas fee off-chain using the Axelar SDK.
+///     refer to https://docs.axelar.dev/dev/axelarjs-sdk/axelar-query-api#estimategasfee
+///  2. Pay gas fee by calling `payNativeGasForContractCall` on the AxelarGasService contract.
+///     refer to https://docs.axelar.dev/dev/general-message-passing/gas-services/pay-gas#paynativegasforcontractcall
+///  3. Send message by calling `callContract` on the AxelarGateway contract.
+///     refer to https://docs.axelar.dev/dev/general-message-passing/gmp-messages#call-a-contract-on-chain-b-from-chain-a
+///  4. Refund surplus gas fee asynchronously.
+///     refer to https://docs.axelar.dev/dev/general-message-passing/gas-services/refund
+/// @dev Recovery:
+///  1. If not enough gas fee is paid, the message will be hangup on source chain and can `add gas` to retry.
+///     refer to https://docs.axelar.dev/dev/general-message-passing/recovery#increase-gas-payment-to-the-gas-receiver-on-the-source-chain
+///  2. If the message is not executed on the destination chain, you can manually retry by calling `execute` on the `ReceiveAxelarDVNAdapter` contract.
+///     refer to https://docs.axelar.dev/dev/general-message-passing/recovery#manually-execute-a-transfer
+/// @dev As the Gas is estimated off-chain, we need to update the gas fee periodically on-chain by calling `setNativeGasFee` with the new fee.
+contract AxelarDVNAdapter is DVNAdapterBase, AxelarExecutable, IAxelarDVNAdapter {
+    mapping(string axelarChain => string peer) public peers; // by chain name
+    mapping(uint32 dstEid => DstConfig) public dstConfig; // by dstEid
+
+    // set default multiplier to 2.5x
     constructor(
-        address _sendLib,
-        address _receiveLib,
         address[] memory _admins,
-        address _gateway,
-        address _gasReceiver
-    ) AxelarExecutable(_gateway) DVNAdapterBase(_sendLib, _receiveLib, _admins) {
-        gasService = IAxelarGasService(_gasReceiver);
-    }
+        address _gateway
+    ) AxelarExecutable(_gateway) DVNAdapterBase(msg.sender, _admins, 12000) {}
 
-    /// @notice sets configuration (`nativeGasFee`, `multiplierBps`, `peer`, and `chainName`) for destination chains
-    /// @dev The `nativeGasFee` and `multiplierBps` can be updated separately using `setDstNativeGasFee` and `setDstMultiplier` functions
-    /// @param _params array of chain configurations
-    function setDstConfig(DstConfigParam[] calldata _params) external onlyAdmin {
+    // ========================= OnlyAdmin =========================
+    function setDstConfig(DstConfigParam[] calldata _params) external onlyRole(ADMIN_ROLE) {
         for (uint256 i = 0; i < _params.length; i++) {
             DstConfigParam calldata param = _params[i];
 
-            delete axelarChainToEid[dstConfig[param.dstEid].chainName];
+            delete peers[dstConfig[param.dstEid].chainName]; // delete old peer in case chain name by dstEid is updated
+            peers[param.chainName] = param.peer; // update peer
 
-            axelarChainToEid[param.chainName] = param.dstEid;
-            dstConfig[param.dstEid] = DstConfig({
-                nativeGasFee: param.nativeGasFee,
-                multiplierBps: param.multiplierBps,
-                peer: param.peer,
-                chainName: param.chainName
-            });
+            dstConfig[param.dstEid] = DstConfig(param.chainName, param.peer, param.multiplierBps, param.nativeGasFee); // update config by dstEid
         }
 
         emit DstConfigSet(_params);
     }
 
     /// @notice sets message fee in native gas for destination chains.
-    /// @dev Axelar does not support quoting fee onchain. Instead, the fee needs to be obtained off-chain by querying through the Axelar SDK.
+    /// @dev Axelar does not support quoting fee on-chain. Instead, the fee needs to be obtained off-chain by querying through the Axelar SDK.
     /// @dev The fee may change over time when token prices change, requiring admins to monitor and make necessary updates to reflect the actual fee.
     /// @dev Adding a buffer to the required fee is advisable. Any surplus fee will be refunded asynchronously if it exceeds the necessary amount.
     /// https://docs.axelar.dev/dev/general-message-passing/gas-services/pay-gas
     /// https://github.com/axelarnetwork/axelarjs/blob/070c8fe061f1082e79772fdc5c4675c0237bbba2/packages/api/src/axelar-query/isomorphic.ts#L54
     /// https://github.com/axelarnetwork/axelar-cgp-solidity/blob/d4536599321774927bf9716178a9e360f8e0efac/contracts/gas-service/AxelarGasService.sol#L403
-    /// @param _params array of message fees for destination chains
-    function setDstNativeGasFee(DstFeeParam[] calldata _params) external onlyAdmin {
-        // TODO - can delete and call setDstConfig instead?
+    function setNativeGasFee(NativeGasFeeParam[] calldata _params) external onlyRole(ADMIN_ROLE) {
         for (uint256 i = 0; i < _params.length; i++) {
-            DstFeeParam calldata param = _params[i];
+            NativeGasFeeParam calldata param = _params[i];
             dstConfig[param.dstEid].nativeGasFee = param.nativeGasFee;
         }
-
-        emit DstFeeSet(_params);
+        emit NativeGasFeeSet(_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 {
-        // TODO - can delete and call setDstConfig instead?
-        for (uint256 i = 0; i < _params.length; i++) {
-            DstMultiplierParam calldata param = _params[i];
-            dstConfig[param.dstEid].multiplierBps = param.multiplierBps;
-        }
+    // ========================= OnlyWorkerFeeLib =========================
+    function withdrawToFeeLib(address _sendLib) external {
+        if (msg.sender != workerFeeLib) revert AxelarDVNAdapter_OnlyWorkerFeeLib();
 
-        emit DstMultiplierSet(_params);
+        _withdrawFeeFromSendLib(_sendLib, workerFeeLib);
     }
 
+    // ========================= OnlyMessageLib =========================
     function assignJob(
         AssignJobParam calldata _param,
-        bytes calldata /*_options*/
-    ) external payable override onlySendLib returns (uint256 fee) {
-        DstConfig storage config = dstConfig[_param.dstEid];
-        fee = config.nativeGasFee;
-        string memory dstChainName = config.chainName;
-        string memory dstPeer = config.peer;
-        bytes memory payload = _encodePayload(_param.packetHeader, _param.payloadHash);
-
-        _assertBalanceAndWithdrawFee(fee);
-
-        // https://docs.axelar.dev/dev/general-message-passing/gas-services/pay-gas#paynativegasforcontractcall
-        gasService.payNativeGasForContractCall{ value: fee }(
-            address(this), // sender
-            dstChainName, // destinationChain
-            dstPeer, // destinationAddress
-            payload, // payload
-            address(this) // refundAddress
+        bytes calldata _options
+    ) external payable override onlyAcl(_param.sender) returns (uint totalFee) {
+        bytes32 receiveLib = _getAndAssertReceiveLib(msg.sender, _param.dstEid);
+
+        IAxelarDVNAdapterFeeLib.Param memory feeLibParam = IAxelarDVNAdapterFeeLib.Param({
+            dstEid: _param.dstEid,
+            confirmations: _param.confirmations,
+            sender: _param.sender,
+            defaultMultiplierBps: defaultMultiplierBps
+        });
+        DstConfig memory config = dstConfig[_param.dstEid];
+
+        bytes memory payload = _encode(receiveLib, _param.packetHeader, _param.payloadHash);
+
+        totalFee = IAxelarDVNAdapterFeeLib(workerFeeLib).getFeeOnSend(
+            feeLibParam,
+            config,
+            payload,
+            _options,
+            msg.sender
         );
-        // https://docs.axelar.dev/dev/general-message-passing/gmp-messages#call-a-contract-on-chain-b-from-chain-a
-        gateway.callContract(dstChainName, dstPeer, payload);
 
-        if (address(feeLib) != address(0)) {
-            fee = feeLib.getFee(_param.dstEid, _param.sender, defaultMultiplierBps, config.multiplierBps, fee);
-        }
+        gateway.callContract(config.chainName, config.peer, payload);
     }
 
+    // ========================= View =========================
     function getFee(
         uint32 _dstEid,
-        uint64 /*_confirmations*/,
+        uint64 _confirmations,
         address _sender,
-        bytes calldata /*_options*/
-    ) external view override returns (uint256 fee) {
-        DstConfig storage config = dstConfig[_dstEid];
-        fee = config.nativeGasFee;
-        if (address(feeLib) != address(0)) {
-            fee = feeLib.getFee(_dstEid, _sender, defaultMultiplierBps, config.multiplierBps, fee);
-        }
+        bytes calldata _options
+    ) external view override returns (uint256 totalFee) {
+        IAxelarDVNAdapterFeeLib.Param memory feeLibParam = IAxelarDVNAdapterFeeLib.Param(
+            _dstEid,
+            _confirmations,
+            _sender,
+            defaultMultiplierBps
+        );
+
+        totalFee = IAxelarDVNAdapterFeeLib(workerFeeLib).getFee(feeLibParam, dstConfig[_dstEid], _options);
     }
 
+    // ========================= Internal =========================
     function _execute(
         string calldata _sourceChain,
         string calldata _sourceAddress,
         bytes calldata _payload
     ) internal override {
+        // assert peer is the same as the source chain
         _assertPeer(_sourceChain, _sourceAddress);
-        _verify(_payload);
-    }
 
-    function _assertPeer(string calldata _sourceChain, string calldata _sourceAddress) private view {
-        uint32 sourceEid = axelarChainToEid[_sourceChain];
-        string memory sourcePeer = dstConfig[sourceEid].peer;
+        _decodeAndVerify(_payload);
+    }
 
-        if (keccak256(bytes(_sourceAddress)) != keccak256(bytes(sourcePeer))) revert Unauthorized();
+    function _assertPeer(string memory _sourceChain, string memory _sourceAddress) private view {
+        string memory sourcePeer = peers[_sourceChain];
+        if (keccak256(bytes(_sourceAddress)) != keccak256(bytes(sourcePeer))) {
+            revert AxelarDVNAdapter_UntrustedPeer(_sourceChain, _sourceAddress);
+        }
     }
 }