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

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(0, _payload); //todo: fix
+    }
+}

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

@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { AxelarExecutable } from "@axelar-network/axelar-gmp-sdk-solidity/contracts/executable/AxelarExecutable.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";
+
+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 srcChainName => SrcConfig) public srcConfig; // by chain name
+    mapping(uint32 dstEid => DstConfig) public dstConfig; // by dstEid
+
+    // set default multiplier to 2.5x
+    constructor(
+        address[] memory _admins,
+        address _gateway
+    ) AxelarExecutable(_gateway) DVNAdapterBase(msg.sender, _admins, 10000) {}
+
+    // ========================= OnlyAdmin =========================
+    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 chainName
+            // only one adapter per dvn that services both endpoint v1 and v2
+            // we standardize the eid stored here with mod 30000
+            if (bytes(dstConfig[eid].chainName).length == 0) {
+                dstConfig[eid].chainName = param.chainName;
+                dstConfig[eid].peer = param.peer;
+                srcConfig[param.chainName].eid = eid;
+                srcConfig[param.chainName].peer = param.peer;
+            }
+
+            dstConfig[eid].multiplierBps = param.multiplierBps;
+            dstConfig[eid].nativeGasFee = param.nativeGasFee;
+        }
+
+        emit DstConfigSet(_params);
+    }
+
+    /// @notice sets message fee in native gas for destination chains.
+    /// @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
+    function setNativeGasFee(NativeGasFeeParam[] calldata _params) external onlyRole(ADMIN_ROLE) {
+        for (uint256 i = 0; i < _params.length; i++) {
+            NativeGasFeeParam calldata param = _params[i];
+            dstConfig[param.dstEid % 30000].nativeGasFee = param.nativeGasFee;
+        }
+        emit NativeGasFeeSet(_params);
+    }
+
+    // ========================= OnlyWorkerFeeLib =========================
+    function withdrawToFeeLib(address _sendLib) external {
+        if (msg.sender != workerFeeLib) revert AxelarDVNAdapter_OnlyWorkerFeeLib();
+
+        _withdrawFeeFromSendLib(_sendLib, workerFeeLib);
+    }
+
+    // ========================= OnlyMessageLib =========================
+    function assignJob(
+        AssignJobParam calldata _param,
+        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 % 30000];
+
+        bytes memory payload = _encode(receiveLib, _param.packetHeader, _param.payloadHash);
+
+        totalFee = IAxelarDVNAdapterFeeLib(workerFeeLib).getFeeOnSend(
+            feeLibParam,
+            config,
+            payload,
+            _options,
+            msg.sender
+        );
+
+        gateway.callContract(config.chainName, config.peer, payload);
+    }
+
+    // ========================= View =========================
+    function getFee(
+        uint32 _dstEid,
+        uint64 _confirmations,
+        address _sender,
+        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 % 30000], _options);
+    }
+
+    // ========================= Internal =========================
+    function _execute(
+        string calldata _sourceChain,
+        string calldata _sourceAddress,
+        bytes calldata _payload
+    ) internal override {
+        SrcConfig memory config = srcConfig[_sourceChain];
+
+        // assert peer is the same as the source chain
+        _assertPeer(_sourceChain, _sourceAddress, config.peer);
+
+        _decodeAndVerify(config.eid, _payload);
+    }
+
+    function _assertPeer(string memory _sourceChain, string memory _sourceAddress, string memory peer) private pure {
+        if (keccak256(bytes(_sourceAddress)) != keccak256(bytes(peer))) {
+            revert AxelarDVNAdapter_UntrustedPeer(_sourceChain, _sourceAddress);
+        }
+    }
+}

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

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

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

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

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

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

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

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

package/contracts/uln/interfaces/IDVN.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import { IWorker } from "../../interfaces/IWorker.sol";
+import { ILayerZeroDVN } from "./ILayerZeroDVN.sol";
+import { ILayerZeroReadDVN } from "./ILayerZeroReadDVN.sol";
+
+interface IDVN is IWorker, ILayerZeroDVN, ILayerZeroReadDVN {
+    struct DstConfigParam {
+        uint32 dstEid;
+        uint64 gas;
+        uint16 multiplierBps;
+        uint128 floorMarginUSD;
+    }
+
+    struct DstConfig {
+        uint64 gas;
+        uint16 multiplierBps;
+        uint128 floorMarginUSD; // uses priceFeed PRICE_RATIO_DENOMINATOR
+    }
+
+    event SetDstConfig(DstConfigParam[] params);
+
+    function dstConfig(uint32 _dstEid) external view returns (uint64, uint16, uint128);
+}