ETH Price: $2,927.42 (+1.14%)

Contract

0x28B6140ead70cb2Fb669705b3598ffB4BEaA060b

Overview

ETH Balance

0.019668712216683824 ETH

ETH Value

$57.58 (@ $2,927.42/ETH)

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
Transfer Ownersh...113629542024-04-05 20:33:23217 days ago1712349203IN
0x28B6140e...4BEaA060b
0 ETH0.00006962.44
Set Default Exec...113087422024-04-03 23:29:29218 days ago1712186969IN
0x28B6140e...4BEaA060b
0 ETH0.000220924.38
Set Default Uln ...113087412024-04-03 23:29:27218 days ago1712186967IN
0x28B6140e...4BEaA060b
0 ETH0.000466754.38
Set Default Exec...113015582024-04-03 17:30:49219 days ago1712165449IN
0x28B6140e...4BEaA060b
0 ETH0.0005447510.8
Set Default Uln ...113015582024-04-03 17:30:49219 days ago1712165449IN
0x28B6140e...4BEaA060b
0 ETH0.001150910.8
Set Default Exec...113015582024-04-03 17:30:49219 days ago1712165449IN
0x28B6140e...4BEaA060b
0 ETH0.0005447510.8
Set Default Uln ...113015582024-04-03 17:30:49219 days ago1712165449IN
0x28B6140e...4BEaA060b
0 ETH0.001150910.8
Set Default Exec...113015582024-04-03 17:30:49219 days ago1712165449IN
0x28B6140e...4BEaA060b
0 ETH0.0005447510.8
Set Default Uln ...113015572024-04-03 17:30:46219 days ago1712165446IN
0x28B6140e...4BEaA060b
0 ETH0.001150910.8
Set Default Exec...103485202024-02-29 18:12:54253 days ago1709230374IN
0x28B6140e...4BEaA060b
0 ETH0.0006597513.08
Set Default Uln ...103485202024-02-29 18:12:54253 days ago1709230374IN
0x28B6140e...4BEaA060b
0 ETH0.0013938713.08
Set Default Exec...99804572024-02-16 22:21:28265 days ago1708122088IN
0x28B6140e...4BEaA060b
0 ETH0.000187033.708
Set Default Uln ...99804562024-02-16 22:21:25265 days ago1708122085IN
0x28B6140e...4BEaA060b
0 ETH0.000395143.708
Set Default Exec...99804562024-02-16 22:21:25265 days ago1708122085IN
0x28B6140e...4BEaA060b
0 ETH0.000187033.708
Set Default Uln ...99804562024-02-16 22:21:25265 days ago1708122085IN
0x28B6140e...4BEaA060b
0 ETH0.000395143.708
Set Default Exec...95600772024-01-30 1:01:45283 days ago1706576505IN
0x28B6140e...4BEaA060b
0 ETH0.00012712.52
Set Default Uln ...95600762024-01-30 1:01:45283 days ago1706576505IN
0x28B6140e...4BEaA060b
0 ETH0.000268542.52
Set Default Exec...95555032024-01-29 17:08:44284 days ago1706548124IN
0x28B6140e...4BEaA060b
0 ETH0.000234244.644
Set Default Uln ...95555022024-01-29 17:08:44284 days ago1706548124IN
0x28B6140e...4BEaA060b
0 ETH0.000494884.644
Set Default Exec...95016132024-01-28 2:22:52285 days ago1706408572IN
0x28B6140e...4BEaA060b
0 ETH0.00005461.788
Set Default Uln ...95016112024-01-28 2:22:42285 days ago1706408562IN
0x28B6140e...4BEaA060b
0 ETH0.000084911.812
Set Default Exec...95015592024-01-28 2:22:12285 days ago1706408532IN
0x28B6140e...4BEaA060b
0 ETH0.000087761.74
Set Default Uln ...95015582024-01-28 2:22:12285 days ago1706408532IN
0x28B6140e...4BEaA060b
0 ETH0.000185421.74
Set Default Exec...95015572024-01-28 2:22:12285 days ago1706408532IN
0x28B6140e...4BEaA060b
0 ETH0.000087761.74
Set Default Uln ...95015562024-01-28 2:22:02285 days ago1706408522IN
0x28B6140e...4BEaA060b
0 ETH0.000185421.74

Latest 25 internal transactions (View All)

Parent Transaction Hash Block From To
168430132024-10-15 21:23:1924 days ago1729027399
0x28B6140e...4BEaA060b
0.00000069 ETH
156932652024-09-03 23:35:3065 days ago1725406530
0x28B6140e...4BEaA060b
0.0359898 ETH
138792372024-07-02 13:21:38129 days ago1719926498
0x28B6140e...4BEaA060b
0.00170524 ETH
138696962024-07-02 5:21:11129 days ago1719897671
0x28B6140e...4BEaA060b
0.00010667 ETH
138561412024-07-01 17:57:40130 days ago1719856660
0x28B6140e...4BEaA060b
0.00004738 ETH
138267912024-06-30 17:20:55131 days ago1719768055
0x28B6140e...4BEaA060b
0.00023371 ETH
137832892024-06-29 4:53:37132 days ago1719636817
0x28B6140e...4BEaA060b
0.00142206 ETH
137636032024-06-28 12:23:38133 days ago1719577418
0x28B6140e...4BEaA060b
0.0000142 ETH
137612452024-06-28 10:25:27133 days ago1719570327
0x28B6140e...4BEaA060b
0.00002197 ETH
137579082024-06-28 7:38:16133 days ago1719560296
0x28B6140e...4BEaA060b
0.00025864 ETH
137203172024-06-27 0:08:56134 days ago1719446936
0x28B6140e...4BEaA060b
0.00791274 ETH
136964532024-06-26 4:09:44135 days ago1719374984
0x28B6140e...4BEaA060b
0.00019136 ETH
136963252024-06-26 4:03:16135 days ago1719374596
0x28B6140e...4BEaA060b
0.00023371 ETH
136963192024-06-26 4:02:58135 days ago1719374578
0x28B6140e...4BEaA060b
0.00023371 ETH
136297602024-06-23 20:19:38138 days ago1719173978
0x28B6140e...4BEaA060b
0.0056326 ETH
136094652024-06-23 3:20:13138 days ago1719112813
0x28B6140e...4BEaA060b
0.00012784 ETH
135387692024-06-20 16:07:48141 days ago1718899668
0x28B6140e...4BEaA060b
0.00107923 ETH
135361692024-06-20 13:57:08141 days ago1718891828
0x28B6140e...4BEaA060b
0.01159689 ETH
135186352024-06-19 23:15:47141 days ago1718838947
0x28B6140e...4BEaA060b
0.00018622 ETH
135109082024-06-19 16:47:09142 days ago1718815629
0x28B6140e...4BEaA060b
0.00192969 ETH
134831832024-06-18 17:34:34143 days ago1718732074
0x28B6140e...4BEaA060b
0.00311757 ETH
134582572024-06-17 20:41:25144 days ago1718656885
0x28B6140e...4BEaA060b
0.07813028 ETH
134288662024-06-16 20:03:59145 days ago1718568239
0x28B6140e...4BEaA060b
0.00034264 ETH
134288122024-06-16 20:01:18145 days ago1718568078
0x28B6140e...4BEaA060b
0.00034264 ETH
134287902024-06-16 20:00:11145 days ago1718568011
0x28B6140e...4BEaA060b
0.00034264 ETH
View All Internal Transactions
Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
SendUln302

Compiler Version
v0.8.22+commit.4fc1097e

Optimization Enabled:
Yes with 20000 runs

Other Settings:
default evmVersion
File 1 of 35 : SendUln302.sol
// SPDX-License-Identifier: LZBL-1.2

pragma solidity ^0.8.20;

import { Packet } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ISendLib.sol";
import { SetConfigParam } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/IMessageLibManager.sol";

import { ExecutorConfig } from "../../SendLibBase.sol";
import { SendLibBaseE2, WorkerOptions } from "../../SendLibBaseE2.sol";
import { UlnConfig } from "../UlnBase.sol";
import { SendUlnBase } from "../SendUlnBase.sol";

/// @dev This is a gluing contract. It simply parses the requests and forward to the super.impl() accordingly.
/// @dev In this case, it combines the logic of SendUlnBase and SendLibBaseE2
contract SendUln302 is SendUlnBase, SendLibBaseE2 {
    uint32 internal constant CONFIG_TYPE_EXECUTOR = 1;
    uint32 internal constant CONFIG_TYPE_ULN = 2;

    error LZ_ULN_InvalidConfigType(uint32 configType);

    constructor(
        address _endpoint,
        uint256 _treasuryGasLimit,
        uint256 _treasuryGasForFeeCap
    ) SendLibBaseE2(_endpoint, _treasuryGasLimit, _treasuryGasForFeeCap) {}

    // ============================ OnlyEndpoint ===================================

    // on the send side the user can config both the executor and the ULN
    function setConfig(address _oapp, SetConfigParam[] calldata _params) external override onlyEndpoint {
        for (uint256 i = 0; i < _params.length; i++) {
            SetConfigParam calldata param = _params[i];
            _assertSupportedEid(param.eid);
            if (param.configType == CONFIG_TYPE_EXECUTOR) {
                _setExecutorConfig(param.eid, _oapp, abi.decode(param.config, (ExecutorConfig)));
            } else if (param.configType == CONFIG_TYPE_ULN) {
                _setUlnConfig(param.eid, _oapp, abi.decode(param.config, (UlnConfig)));
            } else {
                revert LZ_ULN_InvalidConfigType(param.configType);
            }
        }
    }

    // ============================ View ===================================

    function getConfig(uint32 _eid, address _oapp, uint32 _configType) external view override returns (bytes memory) {
        if (_configType == CONFIG_TYPE_EXECUTOR) {
            return abi.encode(getExecutorConfig(_oapp, _eid));
        } else if (_configType == CONFIG_TYPE_ULN) {
            return abi.encode(getUlnConfig(_oapp, _eid));
        } else {
            revert LZ_ULN_InvalidConfigType(_configType);
        }
    }

    function version() external pure override returns (uint64 major, uint8 minor, uint8 endpointVersion) {
        return (3, 0, 2);
    }

    function isSupportedEid(uint32 _eid) external view override returns (bool) {
        return _isSupportedEid(_eid);
    }

    // ============================ Internal ===================================

    function _quoteVerifier(
        address _sender,
        uint32 _dstEid,
        WorkerOptions[] memory _options
    ) internal view override returns (uint256) {
        return _quoteDVNs(_sender, _dstEid, _options);
    }

    function _payVerifier(
        Packet calldata _packet,
        WorkerOptions[] memory _options
    ) internal override returns (uint256 otherWorkerFees, bytes memory encodedPacket) {
        (otherWorkerFees, encodedPacket) = _payDVNs(fees, _packet, _options);
    }

    function _splitOptions(
        bytes calldata _options
    ) internal pure override returns (bytes memory, WorkerOptions[] memory) {
        return _splitUlnOptions(_options);
    }
}

File 2 of 35 : ILayerZeroEndpointV2.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

import { IMessageLibManager } from "./IMessageLibManager.sol";
import { IMessagingComposer } from "./IMessagingComposer.sol";
import { IMessagingChannel } from "./IMessagingChannel.sol";
import { IMessagingContext } from "./IMessagingContext.sol";

struct MessagingParams {
    uint32 dstEid;
    bytes32 receiver;
    bytes message;
    bytes options;
    bool payInLzToken;
}

struct MessagingReceipt {
    bytes32 guid;
    uint64 nonce;
    MessagingFee fee;
}

struct MessagingFee {
    uint256 nativeFee;
    uint256 lzTokenFee;
}

struct Origin {
    uint32 srcEid;
    bytes32 sender;
    uint64 nonce;
}

interface ILayerZeroEndpointV2 is IMessageLibManager, IMessagingComposer, IMessagingChannel, IMessagingContext {
    event PacketSent(bytes encodedPayload, bytes options, address sendLibrary);

    event PacketVerified(Origin origin, address receiver, bytes32 payloadHash);

    event PacketDelivered(Origin origin, address receiver);

    event LzReceiveAlert(
        address indexed receiver,
        address indexed executor,
        Origin origin,
        bytes32 guid,
        uint256 gas,
        uint256 value,
        bytes message,
        bytes extraData,
        bytes reason
    );

    event LzTokenSet(address token);

    event DelegateSet(address sender, address delegate);

    function quote(MessagingParams calldata _params, address _sender) external view returns (MessagingFee memory);

    function send(
        MessagingParams calldata _params,
        address _refundAddress
    ) external payable returns (MessagingReceipt memory);

    function verify(Origin calldata _origin, address _receiver, bytes32 _payloadHash) external;

    function verifiable(Origin calldata _origin, address _receiver) external view returns (bool);

    function initializable(Origin calldata _origin, address _receiver) external view returns (bool);

    function lzReceive(
        Origin calldata _origin,
        address _receiver,
        bytes32 _guid,
        bytes calldata _message,
        bytes calldata _extraData
    ) external payable;

    // oapp can burn messages partially by calling this function with its own business logic if messages are verified in order
    function clear(address _oapp, Origin calldata _origin, bytes32 _guid, bytes calldata _message) external;

    function setLzToken(address _lzToken) external;

    function lzToken() external view returns (address);

    function nativeToken() external view returns (address);

    function setDelegate(address _delegate) external;
}

File 3 of 35 : IMessageLib.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";

import { SetConfigParam } from "./IMessageLibManager.sol";

enum MessageLibType {
    Send,
    Receive,
    SendAndReceive
}

interface IMessageLib is IERC165 {
    function setConfig(address _oapp, SetConfigParam[] calldata _config) external;

    function getConfig(uint32 _eid, address _oapp, uint32 _configType) external view returns (bytes memory config);

    function isSupportedEid(uint32 _eid) external view returns (bool);

    // message libs of same major version are compatible
    function version() external view returns (uint64 major, uint8 minor, uint8 endpointVersion);

    function messageLibType() external view returns (MessageLibType);
}

File 4 of 35 : IMessageLibManager.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

struct SetConfigParam {
    uint32 eid;
    uint32 configType;
    bytes config;
}

interface IMessageLibManager {
    struct Timeout {
        address lib;
        uint256 expiry;
    }

    event LibraryRegistered(address newLib);
    event DefaultSendLibrarySet(uint32 eid, address newLib);
    event DefaultReceiveLibrarySet(uint32 eid, address newLib);
    event DefaultReceiveLibraryTimeoutSet(uint32 eid, address oldLib, uint256 expiry);
    event SendLibrarySet(address sender, uint32 eid, address newLib);
    event ReceiveLibrarySet(address receiver, uint32 eid, address newLib);
    event ReceiveLibraryTimeoutSet(address receiver, uint32 eid, address oldLib, uint256 timeout);

    function registerLibrary(address _lib) external;

    function isRegisteredLibrary(address _lib) external view returns (bool);

    function getRegisteredLibraries() external view returns (address[] memory);

    function setDefaultSendLibrary(uint32 _eid, address _newLib) external;

    function defaultSendLibrary(uint32 _eid) external view returns (address);

    function setDefaultReceiveLibrary(uint32 _eid, address _newLib, uint256 _timeout) external;

    function defaultReceiveLibrary(uint32 _eid) external view returns (address);

    function setDefaultReceiveLibraryTimeout(uint32 _eid, address _lib, uint256 _expiry) external;

    function defaultReceiveLibraryTimeout(uint32 _eid) external view returns (address lib, uint256 expiry);

    function isSupportedEid(uint32 _eid) external view returns (bool);

    function isValidReceiveLibrary(address _receiver, uint32 _eid, address _lib) external view returns (bool);

    /// ------------------- OApp interfaces -------------------
    function setSendLibrary(address _oapp, uint32 _eid, address _newLib) external;

    function getSendLibrary(address _sender, uint32 _eid) external view returns (address lib);

    function isDefaultSendLibrary(address _sender, uint32 _eid) external view returns (bool);

    function setReceiveLibrary(address _oapp, uint32 _eid, address _newLib, uint256 _gracePeriod) external;

    function getReceiveLibrary(address _receiver, uint32 _eid) external view returns (address lib, bool isDefault);

    function setReceiveLibraryTimeout(address _oapp, uint32 _eid, address _lib, uint256 _gracePeriod) external;

    function receiveLibraryTimeout(address _receiver, uint32 _eid) external view returns (address lib, uint256 expiry);

    function setConfig(address _oapp, address _lib, SetConfigParam[] calldata _params) external;

    function getConfig(
        address _oapp,
        address _lib,
        uint32 _eid,
        uint32 _configType
    ) external view returns (bytes memory config);
}

File 5 of 35 : IMessagingChannel.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

interface IMessagingChannel {
    event InboundNonceSkipped(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce);
    event PacketNilified(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce, bytes32 payloadHash);
    event PacketBurnt(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce, bytes32 payloadHash);

    function eid() external view returns (uint32);

    // this is an emergency function if a message cannot be verified for some reasons
    // required to provide _nextNonce to avoid race condition
    function skip(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce) external;

    function nilify(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce, bytes32 _payloadHash) external;

    function burn(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce, bytes32 _payloadHash) external;

    function nextGuid(address _sender, uint32 _dstEid, bytes32 _receiver) external view returns (bytes32);

    function inboundNonce(address _receiver, uint32 _srcEid, bytes32 _sender) external view returns (uint64);

    function outboundNonce(address _sender, uint32 _dstEid, bytes32 _receiver) external view returns (uint64);

    function inboundPayloadHash(
        address _receiver,
        uint32 _srcEid,
        bytes32 _sender,
        uint64 _nonce
    ) external view returns (bytes32);

    function lazyInboundNonce(address _receiver, uint32 _srcEid, bytes32 _sender) external view returns (uint64);
}

File 6 of 35 : IMessagingComposer.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

interface IMessagingComposer {
    event ComposeSent(address from, address to, bytes32 guid, uint16 index, bytes message);
    event ComposeDelivered(address from, address to, bytes32 guid, uint16 index);
    event LzComposeAlert(
        address indexed from,
        address indexed to,
        address indexed executor,
        bytes32 guid,
        uint16 index,
        uint256 gas,
        uint256 value,
        bytes message,
        bytes extraData,
        bytes reason
    );

    function composeQueue(
        address _from,
        address _to,
        bytes32 _guid,
        uint16 _index
    ) external view returns (bytes32 messageHash);

    function sendCompose(address _to, bytes32 _guid, uint16 _index, bytes calldata _message) external;

    function lzCompose(
        address _from,
        address _to,
        bytes32 _guid,
        uint16 _index,
        bytes calldata _message,
        bytes calldata _extraData
    ) external payable;
}

File 7 of 35 : IMessagingContext.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

interface IMessagingContext {
    function isSendingMessage() external view returns (bool);

    function getSendContext() external view returns (uint32 dstEid, address sender);
}

File 8 of 35 : ISendLib.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

import { MessagingFee } from "./ILayerZeroEndpointV2.sol";
import { IMessageLib } from "./IMessageLib.sol";

struct Packet {
    uint64 nonce;
    uint32 srcEid;
    address sender;
    uint32 dstEid;
    bytes32 receiver;
    bytes32 guid;
    bytes message;
}

interface ISendLib is IMessageLib {
    function send(
        Packet calldata _packet,
        bytes calldata _options,
        bool _payInLzToken
    ) external returns (MessagingFee memory, bytes memory encodedPacket);

    function quote(
        Packet calldata _packet,
        bytes calldata _options,
        bool _payInLzToken
    ) external view returns (MessagingFee memory);

    function setTreasury(address _treasury) external;

    function withdrawFee(address _to, uint256 _amount) external;

    function withdrawLzTokenFee(address _lzToken, address _to, uint256 _amount) external;
}

File 9 of 35 : AddressCast.sol
// SPDX-License-Identifier: LZBL-1.2

pragma solidity ^0.8.20;

library AddressCast {
    error AddressCast_InvalidSizeForAddress();
    error AddressCast_InvalidAddress();

    function toBytes32(bytes calldata _addressBytes) internal pure returns (bytes32 result) {
        if (_addressBytes.length > 32) revert AddressCast_InvalidAddress();
        result = bytes32(_addressBytes);
        unchecked {
            uint256 offset = 32 - _addressBytes.length;
            result = result >> (offset * 8);
        }
    }

    function toBytes32(address _address) internal pure returns (bytes32 result) {
        result = bytes32(uint256(uint160(_address)));
    }

    function toBytes(bytes32 _addressBytes32, uint256 _size) internal pure returns (bytes memory result) {
        if (_size == 0 || _size > 32) revert AddressCast_InvalidSizeForAddress();
        result = new bytes(_size);
        unchecked {
            uint256 offset = 256 - _size * 8;
            assembly {
                mstore(add(result, 32), shl(offset, _addressBytes32))
            }
        }
    }

    function toAddress(bytes32 _addressBytes32) internal pure returns (address result) {
        result = address(uint160(uint256(_addressBytes32)));
    }

    function toAddress(bytes calldata _addressBytes) internal pure returns (address result) {
        if (_addressBytes.length != 20) revert AddressCast_InvalidAddress();
        result = address(bytes20(_addressBytes));
    }
}

File 10 of 35 : CalldataBytesLib.sol
// SPDX-License-Identifier: LZBL-1.2

pragma solidity ^0.8.20;

library CalldataBytesLib {
    function toU8(bytes calldata _bytes, uint256 _start) internal pure returns (uint8) {
        return uint8(_bytes[_start]);
    }

    function toU16(bytes calldata _bytes, uint256 _start) internal pure returns (uint16) {
        unchecked {
            uint256 end = _start + 2;
            return uint16(bytes2(_bytes[_start:end]));
        }
    }

    function toU32(bytes calldata _bytes, uint256 _start) internal pure returns (uint32) {
        unchecked {
            uint256 end = _start + 4;
            return uint32(bytes4(_bytes[_start:end]));
        }
    }

    function toU64(bytes calldata _bytes, uint256 _start) internal pure returns (uint64) {
        unchecked {
            uint256 end = _start + 8;
            return uint64(bytes8(_bytes[_start:end]));
        }
    }

    function toU128(bytes calldata _bytes, uint256 _start) internal pure returns (uint128) {
        unchecked {
            uint256 end = _start + 16;
            return uint128(bytes16(_bytes[_start:end]));
        }
    }

    function toU256(bytes calldata _bytes, uint256 _start) internal pure returns (uint256) {
        unchecked {
            uint256 end = _start + 32;
            return uint256(bytes32(_bytes[_start:end]));
        }
    }

    function toAddr(bytes calldata _bytes, uint256 _start) internal pure returns (address) {
        unchecked {
            uint256 end = _start + 20;
            return address(bytes20(_bytes[_start:end]));
        }
    }

    function toB32(bytes calldata _bytes, uint256 _start) internal pure returns (bytes32) {
        unchecked {
            uint256 end = _start + 32;
            return bytes32(_bytes[_start:end]);
        }
    }
}

File 11 of 35 : Transfer.sol
// SPDX-License-Identifier: LZBL-1.2

pragma solidity ^0.8.20;

import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

library Transfer {
    using SafeERC20 for IERC20;

    address internal constant ADDRESS_ZERO = address(0);

    error Transfer_NativeFailed(address _to, uint256 _value);
    error Transfer_ToAddressIsZero();

    function native(address _to, uint256 _value) internal {
        if (_to == ADDRESS_ZERO) revert Transfer_ToAddressIsZero();
        (bool success, ) = _to.call{ value: _value }("");
        if (!success) revert Transfer_NativeFailed(_to, _value);
    }

    function token(address _token, address _to, uint256 _value) internal {
        if (_to == ADDRESS_ZERO) revert Transfer_ToAddressIsZero();
        IERC20(_token).safeTransfer(_to, _value);
    }

    function nativeOrToken(address _token, address _to, uint256 _value) internal {
        if (_token == ADDRESS_ZERO) {
            native(_to, _value);
        } else {
            token(_token, _to, _value);
        }
    }
}

File 12 of 35 : BitMaps.sol
// SPDX-License-Identifier: MIT

// modified from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/structs/BitMaps.sol
pragma solidity ^0.8.20;

type BitMap256 is uint256;

using BitMaps for BitMap256 global;

library BitMaps {
    /**
     * @dev Returns whether the bit at `index` is set.
     */
    function get(BitMap256 bitmap, uint8 index) internal pure returns (bool) {
        uint256 mask = 1 << index;
        return BitMap256.unwrap(bitmap) & mask != 0;
    }

    /**
     * @dev Sets the bit at `index`.
     */
    function set(BitMap256 bitmap, uint8 index) internal pure returns (BitMap256) {
        uint256 mask = 1 << index;
        return BitMap256.wrap(BitMap256.unwrap(bitmap) | mask);
    }
}

File 13 of 35 : ExecutorOptions.sol
// SPDX-License-Identifier: LZBL-1.2

pragma solidity ^0.8.20;

import { CalldataBytesLib } from "../../libs/CalldataBytesLib.sol";

library ExecutorOptions {
    using CalldataBytesLib for bytes;

    uint8 internal constant WORKER_ID = 1;

    uint8 internal constant OPTION_TYPE_LZRECEIVE = 1;
    uint8 internal constant OPTION_TYPE_NATIVE_DROP = 2;
    uint8 internal constant OPTION_TYPE_LZCOMPOSE = 3;
    uint8 internal constant OPTION_TYPE_ORDERED_EXECUTION = 4;

    error Executor_InvalidLzReceiveOption();
    error Executor_InvalidNativeDropOption();
    error Executor_InvalidLzComposeOption();

    /// @dev decode the next executor option from the options starting from the specified cursor
    /// @param _options [executor_id][executor_option][executor_id][executor_option]...
    ///        executor_option = [option_size][option_type][option]
    ///        option_size = len(option_type) + len(option)
    ///        executor_id: uint8, option_size: uint16, option_type: uint8, option: bytes
    /// @param _cursor the cursor to start decoding from
    /// @return optionType the type of the option
    /// @return option the option of the executor
    /// @return cursor the cursor to start decoding the next executor option
    function nextExecutorOption(
        bytes calldata _options,
        uint256 _cursor
    ) internal pure returns (uint8 optionType, bytes calldata option, uint256 cursor) {
        unchecked {
            // skip worker id
            cursor = _cursor + 1;

            // read option size
            uint16 size = _options.toU16(cursor);
            cursor += 2;

            // read option type
            optionType = _options.toU8(cursor);

            // startCursor and endCursor are used to slice the option from _options
            uint256 startCursor = cursor + 1; // skip option type
            uint256 endCursor = cursor + size;
            option = _options[startCursor:endCursor];
            cursor += size;
        }
    }

    function decodeLzReceiveOption(bytes calldata _option) internal pure returns (uint128 gas, uint128 value) {
        if (_option.length != 16 && _option.length != 32) revert Executor_InvalidLzReceiveOption();
        gas = _option.toU128(0);
        value = _option.length == 32 ? _option.toU128(16) : 0;
    }

    function decodeNativeDropOption(bytes calldata _option) internal pure returns (uint128 amount, bytes32 receiver) {
        if (_option.length != 48) revert Executor_InvalidNativeDropOption();
        amount = _option.toU128(0);
        receiver = _option.toB32(16);
    }

    function decodeLzComposeOption(
        bytes calldata _option
    ) internal pure returns (uint16 index, uint128 gas, uint128 value) {
        if (_option.length != 18 && _option.length != 34) revert Executor_InvalidLzComposeOption();
        index = _option.toU16(0);
        gas = _option.toU128(2);
        value = _option.length == 34 ? _option.toU128(18) : 0;
    }

    function encodeLzReceiveOption(uint128 _gas, uint128 _value) internal pure returns (bytes memory) {
        return _value == 0 ? abi.encodePacked(_gas) : abi.encodePacked(_gas, _value);
    }

    function encodeNativeDropOption(uint128 _amount, bytes32 _receiver) internal pure returns (bytes memory) {
        return abi.encodePacked(_amount, _receiver);
    }

    function encodeLzComposeOption(uint16 _index, uint128 _gas, uint128 _value) internal pure returns (bytes memory) {
        return _value == 0 ? abi.encodePacked(_index, _gas) : abi.encodePacked(_index, _gas, _value);
    }
}

File 14 of 35 : PacketV1Codec.sol
// SPDX-License-Identifier: LZBL-1.2

pragma solidity ^0.8.20;

import { Packet } from "../../interfaces/ISendLib.sol";
import { AddressCast } from "../../libs/AddressCast.sol";

library PacketV1Codec {
    using AddressCast for address;
    using AddressCast for bytes32;

    uint8 internal constant PACKET_VERSION = 1;

    // header (version + nonce + path)
    // version
    uint256 private constant PACKET_VERSION_OFFSET = 0;
    //    nonce
    uint256 private constant NONCE_OFFSET = 1;
    //    path
    uint256 private constant SRC_EID_OFFSET = 9;
    uint256 private constant SENDER_OFFSET = 13;
    uint256 private constant DST_EID_OFFSET = 45;
    uint256 private constant RECEIVER_OFFSET = 49;
    // payload (guid + message)
    uint256 private constant GUID_OFFSET = 81; // keccak256(nonce + path)
    uint256 private constant MESSAGE_OFFSET = 113;

    function encode(Packet memory _packet) internal pure returns (bytes memory encodedPacket) {
        encodedPacket = abi.encodePacked(
            PACKET_VERSION,
            _packet.nonce,
            _packet.srcEid,
            _packet.sender.toBytes32(),
            _packet.dstEid,
            _packet.receiver,
            _packet.guid,
            _packet.message
        );
    }

    function encodePacketHeader(Packet memory _packet) internal pure returns (bytes memory) {
        return
            abi.encodePacked(
                PACKET_VERSION,
                _packet.nonce,
                _packet.srcEid,
                _packet.sender.toBytes32(),
                _packet.dstEid,
                _packet.receiver
            );
    }

    function encodePayload(Packet memory _packet) internal pure returns (bytes memory) {
        return abi.encodePacked(_packet.guid, _packet.message);
    }

    function header(bytes calldata _packet) internal pure returns (bytes calldata) {
        return _packet[0:GUID_OFFSET];
    }

    function version(bytes calldata _packet) internal pure returns (uint8) {
        return uint8(bytes1(_packet[PACKET_VERSION_OFFSET:NONCE_OFFSET]));
    }

    function nonce(bytes calldata _packet) internal pure returns (uint64) {
        return uint64(bytes8(_packet[NONCE_OFFSET:SRC_EID_OFFSET]));
    }

    function srcEid(bytes calldata _packet) internal pure returns (uint32) {
        return uint32(bytes4(_packet[SRC_EID_OFFSET:SENDER_OFFSET]));
    }

    function sender(bytes calldata _packet) internal pure returns (bytes32) {
        return bytes32(_packet[SENDER_OFFSET:DST_EID_OFFSET]);
    }

    function senderAddressB20(bytes calldata _packet) internal pure returns (address) {
        return sender(_packet).toAddress();
    }

    function dstEid(bytes calldata _packet) internal pure returns (uint32) {
        return uint32(bytes4(_packet[DST_EID_OFFSET:RECEIVER_OFFSET]));
    }

    function receiver(bytes calldata _packet) internal pure returns (bytes32) {
        return bytes32(_packet[RECEIVER_OFFSET:GUID_OFFSET]);
    }

    function receiverB20(bytes calldata _packet) internal pure returns (address) {
        return receiver(_packet).toAddress();
    }

    function guid(bytes calldata _packet) internal pure returns (bytes32) {
        return bytes32(_packet[GUID_OFFSET:MESSAGE_OFFSET]);
    }

    function message(bytes calldata _packet) internal pure returns (bytes calldata) {
        return bytes(_packet[MESSAGE_OFFSET:]);
    }

    function payload(bytes calldata _packet) internal pure returns (bytes calldata) {
        return bytes(_packet[GUID_OFFSET:]);
    }

    function payloadHash(bytes calldata _packet) internal pure returns (bytes32) {
        return keccak256(payload(_packet));
    }
}

File 15 of 35 : Ownable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

File 16 of 35 : IERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

File 17 of 35 : IERC20Permit.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

File 18 of 35 : SafeERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
    }
}

File 19 of 35 : Address.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

File 20 of 35 : Context.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

File 21 of 35 : ERC165.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

File 22 of 35 : IERC165.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

File 23 of 35 : SafeCast.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.

pragma solidity ^0.8.0;

/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */
library SafeCast {
    /**
     * @dev Returns the downcasted uint248 from uint256, reverting on
     * overflow (when the input is greater than largest uint248).
     *
     * Counterpart to Solidity's `uint248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     *
     * _Available since v4.7._
     */
    function toUint248(uint256 value) internal pure returns (uint248) {
        require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
        return uint248(value);
    }

    /**
     * @dev Returns the downcasted uint240 from uint256, reverting on
     * overflow (when the input is greater than largest uint240).
     *
     * Counterpart to Solidity's `uint240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     *
     * _Available since v4.7._
     */
    function toUint240(uint256 value) internal pure returns (uint240) {
        require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
        return uint240(value);
    }

    /**
     * @dev Returns the downcasted uint232 from uint256, reverting on
     * overflow (when the input is greater than largest uint232).
     *
     * Counterpart to Solidity's `uint232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     *
     * _Available since v4.7._
     */
    function toUint232(uint256 value) internal pure returns (uint232) {
        require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
        return uint232(value);
    }

    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     *
     * _Available since v4.2._
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint216 from uint256, reverting on
     * overflow (when the input is greater than largest uint216).
     *
     * Counterpart to Solidity's `uint216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     *
     * _Available since v4.7._
     */
    function toUint216(uint256 value) internal pure returns (uint216) {
        require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
        return uint216(value);
    }

    /**
     * @dev Returns the downcasted uint208 from uint256, reverting on
     * overflow (when the input is greater than largest uint208).
     *
     * Counterpart to Solidity's `uint208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     *
     * _Available since v4.7._
     */
    function toUint208(uint256 value) internal pure returns (uint208) {
        require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
        return uint208(value);
    }

    /**
     * @dev Returns the downcasted uint200 from uint256, reverting on
     * overflow (when the input is greater than largest uint200).
     *
     * Counterpart to Solidity's `uint200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     *
     * _Available since v4.7._
     */
    function toUint200(uint256 value) internal pure returns (uint200) {
        require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
        return uint200(value);
    }

    /**
     * @dev Returns the downcasted uint192 from uint256, reverting on
     * overflow (when the input is greater than largest uint192).
     *
     * Counterpart to Solidity's `uint192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     *
     * _Available since v4.7._
     */
    function toUint192(uint256 value) internal pure returns (uint192) {
        require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
        return uint192(value);
    }

    /**
     * @dev Returns the downcasted uint184 from uint256, reverting on
     * overflow (when the input is greater than largest uint184).
     *
     * Counterpart to Solidity's `uint184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     *
     * _Available since v4.7._
     */
    function toUint184(uint256 value) internal pure returns (uint184) {
        require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
        return uint184(value);
    }

    /**
     * @dev Returns the downcasted uint176 from uint256, reverting on
     * overflow (when the input is greater than largest uint176).
     *
     * Counterpart to Solidity's `uint176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     *
     * _Available since v4.7._
     */
    function toUint176(uint256 value) internal pure returns (uint176) {
        require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
        return uint176(value);
    }

    /**
     * @dev Returns the downcasted uint168 from uint256, reverting on
     * overflow (when the input is greater than largest uint168).
     *
     * Counterpart to Solidity's `uint168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     *
     * _Available since v4.7._
     */
    function toUint168(uint256 value) internal pure returns (uint168) {
        require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
        return uint168(value);
    }

    /**
     * @dev Returns the downcasted uint160 from uint256, reverting on
     * overflow (when the input is greater than largest uint160).
     *
     * Counterpart to Solidity's `uint160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     *
     * _Available since v4.7._
     */
    function toUint160(uint256 value) internal pure returns (uint160) {
        require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
        return uint160(value);
    }

    /**
     * @dev Returns the downcasted uint152 from uint256, reverting on
     * overflow (when the input is greater than largest uint152).
     *
     * Counterpart to Solidity's `uint152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     *
     * _Available since v4.7._
     */
    function toUint152(uint256 value) internal pure returns (uint152) {
        require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
        return uint152(value);
    }

    /**
     * @dev Returns the downcasted uint144 from uint256, reverting on
     * overflow (when the input is greater than largest uint144).
     *
     * Counterpart to Solidity's `uint144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     *
     * _Available since v4.7._
     */
    function toUint144(uint256 value) internal pure returns (uint144) {
        require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
        return uint144(value);
    }

    /**
     * @dev Returns the downcasted uint136 from uint256, reverting on
     * overflow (when the input is greater than largest uint136).
     *
     * Counterpart to Solidity's `uint136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     *
     * _Available since v4.7._
     */
    function toUint136(uint256 value) internal pure returns (uint136) {
        require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
        return uint136(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v2.5._
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint120 from uint256, reverting on
     * overflow (when the input is greater than largest uint120).
     *
     * Counterpart to Solidity's `uint120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     *
     * _Available since v4.7._
     */
    function toUint120(uint256 value) internal pure returns (uint120) {
        require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
        return uint120(value);
    }

    /**
     * @dev Returns the downcasted uint112 from uint256, reverting on
     * overflow (when the input is greater than largest uint112).
     *
     * Counterpart to Solidity's `uint112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     *
     * _Available since v4.7._
     */
    function toUint112(uint256 value) internal pure returns (uint112) {
        require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
        return uint112(value);
    }

    /**
     * @dev Returns the downcasted uint104 from uint256, reverting on
     * overflow (when the input is greater than largest uint104).
     *
     * Counterpart to Solidity's `uint104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     *
     * _Available since v4.7._
     */
    function toUint104(uint256 value) internal pure returns (uint104) {
        require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
        return uint104(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     *
     * _Available since v4.2._
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint88 from uint256, reverting on
     * overflow (when the input is greater than largest uint88).
     *
     * Counterpart to Solidity's `uint88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     *
     * _Available since v4.7._
     */
    function toUint88(uint256 value) internal pure returns (uint88) {
        require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
        return uint88(value);
    }

    /**
     * @dev Returns the downcasted uint80 from uint256, reverting on
     * overflow (when the input is greater than largest uint80).
     *
     * Counterpart to Solidity's `uint80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     *
     * _Available since v4.7._
     */
    function toUint80(uint256 value) internal pure returns (uint80) {
        require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
        return uint80(value);
    }

    /**
     * @dev Returns the downcasted uint72 from uint256, reverting on
     * overflow (when the input is greater than largest uint72).
     *
     * Counterpart to Solidity's `uint72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     *
     * _Available since v4.7._
     */
    function toUint72(uint256 value) internal pure returns (uint72) {
        require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
        return uint72(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v2.5._
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint56 from uint256, reverting on
     * overflow (when the input is greater than largest uint56).
     *
     * Counterpart to Solidity's `uint56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     *
     * _Available since v4.7._
     */
    function toUint56(uint256 value) internal pure returns (uint56) {
        require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
        return uint56(value);
    }

    /**
     * @dev Returns the downcasted uint48 from uint256, reverting on
     * overflow (when the input is greater than largest uint48).
     *
     * Counterpart to Solidity's `uint48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     *
     * _Available since v4.7._
     */
    function toUint48(uint256 value) internal pure returns (uint48) {
        require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
        return uint48(value);
    }

    /**
     * @dev Returns the downcasted uint40 from uint256, reverting on
     * overflow (when the input is greater than largest uint40).
     *
     * Counterpart to Solidity's `uint40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     *
     * _Available since v4.7._
     */
    function toUint40(uint256 value) internal pure returns (uint40) {
        require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
        return uint40(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v2.5._
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint24 from uint256, reverting on
     * overflow (when the input is greater than largest uint24).
     *
     * Counterpart to Solidity's `uint24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     *
     * _Available since v4.7._
     */
    function toUint24(uint256 value) internal pure returns (uint24) {
        require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
        return uint24(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v2.5._
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     *
     * _Available since v2.5._
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     *
     * _Available since v3.0._
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        require(value >= 0, "SafeCast: value must be positive");
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int248 from int256, reverting on
     * overflow (when the input is less than smallest int248 or
     * greater than largest int248).
     *
     * Counterpart to Solidity's `int248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     *
     * _Available since v4.7._
     */
    function toInt248(int256 value) internal pure returns (int248 downcasted) {
        downcasted = int248(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
    }

    /**
     * @dev Returns the downcasted int240 from int256, reverting on
     * overflow (when the input is less than smallest int240 or
     * greater than largest int240).
     *
     * Counterpart to Solidity's `int240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     *
     * _Available since v4.7._
     */
    function toInt240(int256 value) internal pure returns (int240 downcasted) {
        downcasted = int240(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
    }

    /**
     * @dev Returns the downcasted int232 from int256, reverting on
     * overflow (when the input is less than smallest int232 or
     * greater than largest int232).
     *
     * Counterpart to Solidity's `int232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     *
     * _Available since v4.7._
     */
    function toInt232(int256 value) internal pure returns (int232 downcasted) {
        downcasted = int232(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
    }

    /**
     * @dev Returns the downcasted int224 from int256, reverting on
     * overflow (when the input is less than smallest int224 or
     * greater than largest int224).
     *
     * Counterpart to Solidity's `int224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     *
     * _Available since v4.7._
     */
    function toInt224(int256 value) internal pure returns (int224 downcasted) {
        downcasted = int224(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
    }

    /**
     * @dev Returns the downcasted int216 from int256, reverting on
     * overflow (when the input is less than smallest int216 or
     * greater than largest int216).
     *
     * Counterpart to Solidity's `int216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     *
     * _Available since v4.7._
     */
    function toInt216(int256 value) internal pure returns (int216 downcasted) {
        downcasted = int216(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
    }

    /**
     * @dev Returns the downcasted int208 from int256, reverting on
     * overflow (when the input is less than smallest int208 or
     * greater than largest int208).
     *
     * Counterpart to Solidity's `int208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     *
     * _Available since v4.7._
     */
    function toInt208(int256 value) internal pure returns (int208 downcasted) {
        downcasted = int208(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
    }

    /**
     * @dev Returns the downcasted int200 from int256, reverting on
     * overflow (when the input is less than smallest int200 or
     * greater than largest int200).
     *
     * Counterpart to Solidity's `int200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     *
     * _Available since v4.7._
     */
    function toInt200(int256 value) internal pure returns (int200 downcasted) {
        downcasted = int200(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
    }

    /**
     * @dev Returns the downcasted int192 from int256, reverting on
     * overflow (when the input is less than smallest int192 or
     * greater than largest int192).
     *
     * Counterpart to Solidity's `int192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     *
     * _Available since v4.7._
     */
    function toInt192(int256 value) internal pure returns (int192 downcasted) {
        downcasted = int192(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
    }

    /**
     * @dev Returns the downcasted int184 from int256, reverting on
     * overflow (when the input is less than smallest int184 or
     * greater than largest int184).
     *
     * Counterpart to Solidity's `int184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     *
     * _Available since v4.7._
     */
    function toInt184(int256 value) internal pure returns (int184 downcasted) {
        downcasted = int184(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
    }

    /**
     * @dev Returns the downcasted int176 from int256, reverting on
     * overflow (when the input is less than smallest int176 or
     * greater than largest int176).
     *
     * Counterpart to Solidity's `int176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     *
     * _Available since v4.7._
     */
    function toInt176(int256 value) internal pure returns (int176 downcasted) {
        downcasted = int176(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
    }

    /**
     * @dev Returns the downcasted int168 from int256, reverting on
     * overflow (when the input is less than smallest int168 or
     * greater than largest int168).
     *
     * Counterpart to Solidity's `int168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     *
     * _Available since v4.7._
     */
    function toInt168(int256 value) internal pure returns (int168 downcasted) {
        downcasted = int168(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
    }

    /**
     * @dev Returns the downcasted int160 from int256, reverting on
     * overflow (when the input is less than smallest int160 or
     * greater than largest int160).
     *
     * Counterpart to Solidity's `int160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     *
     * _Available since v4.7._
     */
    function toInt160(int256 value) internal pure returns (int160 downcasted) {
        downcasted = int160(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
    }

    /**
     * @dev Returns the downcasted int152 from int256, reverting on
     * overflow (when the input is less than smallest int152 or
     * greater than largest int152).
     *
     * Counterpart to Solidity's `int152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     *
     * _Available since v4.7._
     */
    function toInt152(int256 value) internal pure returns (int152 downcasted) {
        downcasted = int152(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
    }

    /**
     * @dev Returns the downcasted int144 from int256, reverting on
     * overflow (when the input is less than smallest int144 or
     * greater than largest int144).
     *
     * Counterpart to Solidity's `int144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     *
     * _Available since v4.7._
     */
    function toInt144(int256 value) internal pure returns (int144 downcasted) {
        downcasted = int144(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
    }

    /**
     * @dev Returns the downcasted int136 from int256, reverting on
     * overflow (when the input is less than smallest int136 or
     * greater than largest int136).
     *
     * Counterpart to Solidity's `int136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     *
     * _Available since v4.7._
     */
    function toInt136(int256 value) internal pure returns (int136 downcasted) {
        downcasted = int136(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v3.1._
     */
    function toInt128(int256 value) internal pure returns (int128 downcasted) {
        downcasted = int128(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
    }

    /**
     * @dev Returns the downcasted int120 from int256, reverting on
     * overflow (when the input is less than smallest int120 or
     * greater than largest int120).
     *
     * Counterpart to Solidity's `int120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     *
     * _Available since v4.7._
     */
    function toInt120(int256 value) internal pure returns (int120 downcasted) {
        downcasted = int120(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
    }

    /**
     * @dev Returns the downcasted int112 from int256, reverting on
     * overflow (when the input is less than smallest int112 or
     * greater than largest int112).
     *
     * Counterpart to Solidity's `int112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     *
     * _Available since v4.7._
     */
    function toInt112(int256 value) internal pure returns (int112 downcasted) {
        downcasted = int112(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
    }

    /**
     * @dev Returns the downcasted int104 from int256, reverting on
     * overflow (when the input is less than smallest int104 or
     * greater than largest int104).
     *
     * Counterpart to Solidity's `int104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     *
     * _Available since v4.7._
     */
    function toInt104(int256 value) internal pure returns (int104 downcasted) {
        downcasted = int104(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
    }

    /**
     * @dev Returns the downcasted int96 from int256, reverting on
     * overflow (when the input is less than smallest int96 or
     * greater than largest int96).
     *
     * Counterpart to Solidity's `int96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     *
     * _Available since v4.7._
     */
    function toInt96(int256 value) internal pure returns (int96 downcasted) {
        downcasted = int96(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
    }

    /**
     * @dev Returns the downcasted int88 from int256, reverting on
     * overflow (when the input is less than smallest int88 or
     * greater than largest int88).
     *
     * Counterpart to Solidity's `int88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     *
     * _Available since v4.7._
     */
    function toInt88(int256 value) internal pure returns (int88 downcasted) {
        downcasted = int88(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
    }

    /**
     * @dev Returns the downcasted int80 from int256, reverting on
     * overflow (when the input is less than smallest int80 or
     * greater than largest int80).
     *
     * Counterpart to Solidity's `int80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     *
     * _Available since v4.7._
     */
    function toInt80(int256 value) internal pure returns (int80 downcasted) {
        downcasted = int80(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
    }

    /**
     * @dev Returns the downcasted int72 from int256, reverting on
     * overflow (when the input is less than smallest int72 or
     * greater than largest int72).
     *
     * Counterpart to Solidity's `int72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     *
     * _Available since v4.7._
     */
    function toInt72(int256 value) internal pure returns (int72 downcasted) {
        downcasted = int72(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v3.1._
     */
    function toInt64(int256 value) internal pure returns (int64 downcasted) {
        downcasted = int64(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
    }

    /**
     * @dev Returns the downcasted int56 from int256, reverting on
     * overflow (when the input is less than smallest int56 or
     * greater than largest int56).
     *
     * Counterpart to Solidity's `int56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     *
     * _Available since v4.7._
     */
    function toInt56(int256 value) internal pure returns (int56 downcasted) {
        downcasted = int56(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
    }

    /**
     * @dev Returns the downcasted int48 from int256, reverting on
     * overflow (when the input is less than smallest int48 or
     * greater than largest int48).
     *
     * Counterpart to Solidity's `int48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     *
     * _Available since v4.7._
     */
    function toInt48(int256 value) internal pure returns (int48 downcasted) {
        downcasted = int48(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
    }

    /**
     * @dev Returns the downcasted int40 from int256, reverting on
     * overflow (when the input is less than smallest int40 or
     * greater than largest int40).
     *
     * Counterpart to Solidity's `int40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     *
     * _Available since v4.7._
     */
    function toInt40(int256 value) internal pure returns (int40 downcasted) {
        downcasted = int40(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v3.1._
     */
    function toInt32(int256 value) internal pure returns (int32 downcasted) {
        downcasted = int32(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
    }

    /**
     * @dev Returns the downcasted int24 from int256, reverting on
     * overflow (when the input is less than smallest int24 or
     * greater than largest int24).
     *
     * Counterpart to Solidity's `int24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     *
     * _Available since v4.7._
     */
    function toInt24(int256 value) internal pure returns (int24 downcasted) {
        downcasted = int24(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v3.1._
     */
    function toInt16(int256 value) internal pure returns (int16 downcasted) {
        downcasted = int16(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     *
     * _Available since v3.1._
     */
    function toInt8(int256 value) internal pure returns (int8 downcasted) {
        downcasted = int8(value);
        require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     *
     * _Available since v3.0._
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
        return int256(value);
    }
}

File 24 of 35 : MessageLibBase.sol
// SPDX-License-Identifier: LZBL-1.2

pragma solidity ^0.8.20;

/// @dev simply a container of endpoint address and local eid
abstract contract MessageLibBase {
    address internal immutable endpoint;
    uint32 internal immutable localEid;

    error LZ_MessageLib_OnlyEndpoint();

    modifier onlyEndpoint() {
        if (endpoint != msg.sender) revert LZ_MessageLib_OnlyEndpoint();
        _;
    }

    constructor(address _endpoint, uint32 _localEid) {
        endpoint = _endpoint;
        localEid = _localEid;
    }
}

File 25 of 35 : SendLibBase.sol
// SPDX-License-Identifier: LZBL-1.2

pragma solidity ^0.8.20;

import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { Transfer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol";

import { ILayerZeroExecutor } from "./interfaces/ILayerZeroExecutor.sol";
import { ILayerZeroTreasury } from "./interfaces/ILayerZeroTreasury.sol";
import { SafeCall } from "./libs/SafeCall.sol";
import { MessageLibBase } from "./MessageLibBase.sol";

struct WorkerOptions {
    uint8 workerId;
    bytes options;
}

struct SetDefaultExecutorConfigParam {
    uint32 eid;
    ExecutorConfig config;
}

struct ExecutorConfig {
    uint32 maxMessageSize;
    address executor;
}

/// @dev base contract for both SendLibBaseE1 and SendLibBaseE2
abstract contract SendLibBase is MessageLibBase, Ownable {
    using SafeCall for address;

    address private constant DEFAULT_CONFIG = address(0);
    uint16 internal constant TREASURY_MAX_COPY = 32;

    uint256 internal immutable treasuryGasLimit;
    uint256 internal treasuryNativeFeeCap;

    // config
    address public treasury;
    mapping(address oapp => mapping(uint32 eid => ExecutorConfig)) public executorConfigs;

    // accumulated fees for workers and treasury
    mapping(address worker => uint256) public fees;

    event ExecutorFeePaid(address executor, uint256 fee);
    event TreasurySet(address treasury);
    event DefaultExecutorConfigsSet(SetDefaultExecutorConfigParam[] params);
    event ExecutorConfigSet(address oapp, uint32 eid, ExecutorConfig config);
    event TreasuryNativeFeeCapSet(uint256 newTreasuryNativeFeeCap);

    error LZ_MessageLib_InvalidMessageSize(uint256 actual, uint256 max);
    error LZ_MessageLib_InvalidAmount(uint256 requested, uint256 available);
    error LZ_MessageLib_TransferFailed();
    error LZ_MessageLib_InvalidExecutor();
    error LZ_MessageLib_ZeroMessageSize();

    constructor(
        address _endpoint,
        uint32 _localEid,
        uint256 _treasuryGasLimit,
        uint256 _treasuryNativeFeeCap
    ) MessageLibBase(_endpoint, _localEid) {
        treasuryGasLimit = _treasuryGasLimit;
        treasuryNativeFeeCap = _treasuryNativeFeeCap;
    }

    function setDefaultExecutorConfigs(SetDefaultExecutorConfigParam[] calldata _params) external onlyOwner {
        for (uint256 i = 0; i < _params.length; ++i) {
            SetDefaultExecutorConfigParam calldata param = _params[i];

            if (param.config.executor == address(0x0)) revert LZ_MessageLib_InvalidExecutor();
            if (param.config.maxMessageSize == 0) revert LZ_MessageLib_ZeroMessageSize();

            executorConfigs[DEFAULT_CONFIG][param.eid] = param.config;
        }
        emit DefaultExecutorConfigsSet(_params);
    }

    /// @dev the new value can not be greater than the old value, i.e. down only
    function setTreasuryNativeFeeCap(uint256 _newTreasuryNativeFeeCap) external onlyOwner {
        // assert the new value is no greater than the old value
        if (_newTreasuryNativeFeeCap > treasuryNativeFeeCap)
            revert LZ_MessageLib_InvalidAmount(_newTreasuryNativeFeeCap, treasuryNativeFeeCap);
        treasuryNativeFeeCap = _newTreasuryNativeFeeCap;
        emit TreasuryNativeFeeCapSet(_newTreasuryNativeFeeCap);
    }

    // ============================ View ===================================
    // @dev get the executor config and if not set, return the default config
    function getExecutorConfig(address _oapp, uint32 _remoteEid) public view returns (ExecutorConfig memory rtnConfig) {
        ExecutorConfig storage defaultConfig = executorConfigs[DEFAULT_CONFIG][_remoteEid];
        ExecutorConfig storage customConfig = executorConfigs[_oapp][_remoteEid];

        uint32 maxMessageSize = customConfig.maxMessageSize;
        rtnConfig.maxMessageSize = maxMessageSize != 0 ? maxMessageSize : defaultConfig.maxMessageSize;

        address executor = customConfig.executor;
        rtnConfig.executor = executor != address(0x0) ? executor : defaultConfig.executor;
    }

    // ======================= Internal =======================
    function _assertMessageSize(uint256 _actual, uint256 _max) internal pure {
        if (_actual > _max) revert LZ_MessageLib_InvalidMessageSize(_actual, _max);
    }

    function _payExecutor(
        address _executor,
        uint32 _dstEid,
        address _sender,
        uint256 _msgSize,
        bytes memory _executorOptions
    ) internal returns (uint256 executorFee) {
        executorFee = ILayerZeroExecutor(_executor).assignJob(_dstEid, _sender, _msgSize, _executorOptions);
        if (executorFee > 0) {
            fees[_executor] += executorFee;
        }
        emit ExecutorFeePaid(_executor, executorFee);
    }

    function _payTreasury(
        address _sender,
        uint32 _dstEid,
        uint256 _totalNativeFee,
        bool _payInLzToken
    ) internal returns (uint256 treasuryNativeFee, uint256 lzTokenFee) {
        if (treasury != address(0x0)) {
            bytes memory callData = abi.encodeCall(
                ILayerZeroTreasury.payFee,
                (_sender, _dstEid, _totalNativeFee, _payInLzToken)
            );
            (bool success, bytes memory result) = treasury.safeCall(treasuryGasLimit, 0, TREASURY_MAX_COPY, callData);

            (treasuryNativeFee, lzTokenFee) = _parseTreasuryResult(_totalNativeFee, _payInLzToken, success, result);
            // fee should be in lzTokenFee if payInLzToken, otherwise in native
            if (treasuryNativeFee > 0) {
                fees[treasury] += treasuryNativeFee;
            }
        }
    }

    /// @dev the abstract process for quote() is:
    /// 0/ split out the executor options and options of other workers
    /// 1/ quote workers
    /// 2/ quote executor
    /// 3/ quote treasury
    /// @return nativeFee, lzTokenFee
    function _quote(
        address _sender,
        uint32 _dstEid,
        uint256 _msgSize,
        bool _payInLzToken,
        bytes calldata _options
    ) internal view returns (uint256, uint256) {
        (bytes memory executorOptions, WorkerOptions[] memory validationOptions) = _splitOptions(_options);

        // quote the verifier used in the library. for ULN, it is a list of DVNs
        uint256 nativeFee = _quoteVerifier(_sender, _dstEid, validationOptions);

        // quote executor
        ExecutorConfig memory config = getExecutorConfig(_sender, _dstEid);
        // assert msg size
        _assertMessageSize(_msgSize, config.maxMessageSize);

        nativeFee += ILayerZeroExecutor(config.executor).getFee(_dstEid, _sender, _msgSize, executorOptions);

        // quote treasury
        (uint256 treasuryNativeFee, uint256 lzTokenFee) = _quoteTreasury(_sender, _dstEid, nativeFee, _payInLzToken);
        nativeFee += treasuryNativeFee;

        return (nativeFee, lzTokenFee);
    }

    /// @dev this interface should be DoS-free if the user is paying with native. properties
    /// 1/ treasury can return an overly high lzToken fee
    /// 2/ if treasury returns an overly high native fee, it will be capped by maxNativeFee,
    ///    which can be reasoned with the configurations
    /// 3/ the owner can not configure the treasury in a way that force this function to revert
    function _quoteTreasury(
        address _sender,
        uint32 _dstEid,
        uint256 _totalNativeFee,
        bool _payInLzToken
    ) internal view returns (uint256 nativeFee, uint256 lzTokenFee) {
        // treasury must be set, and it has to be a contract
        if (treasury != address(0x0)) {
            bytes memory callData = abi.encodeCall(
                ILayerZeroTreasury.getFee,
                (_sender, _dstEid, _totalNativeFee, _payInLzToken)
            );
            (bool success, bytes memory result) = treasury.safeStaticCall(
                treasuryGasLimit,
                TREASURY_MAX_COPY,
                callData
            );

            return _parseTreasuryResult(_totalNativeFee, _payInLzToken, success, result);
        }
    }

    function _parseTreasuryResult(
        uint256 _totalNativeFee,
        bool _payInLzToken,
        bool _success,
        bytes memory _result
    ) internal view returns (uint256 nativeFee, uint256 lzTokenFee) {
        // failure, charges nothing
        if (!_success || _result.length < TREASURY_MAX_COPY) return (0, 0);

        // parse the result
        uint256 treasureFeeQuote = abi.decode(_result, (uint256));
        if (_payInLzToken) {
            lzTokenFee = treasureFeeQuote;
        } else {
            // pay in native
            // we must prevent high-treasuryFee Dos attack
            // nativeFee = min(treasureFeeQuote, maxNativeFee)
            // opportunistically raise the maxNativeFee to be the same as _totalNativeFee
            // can't use the _totalNativeFee alone because the oapp can use custom workers to force the fee to 0.
            // maxNativeFee = max (_totalNativeFee, treasuryNativeFeeCap)
            uint256 maxNativeFee = _totalNativeFee > treasuryNativeFeeCap ? _totalNativeFee : treasuryNativeFeeCap;

            // min (treasureFeeQuote, nativeFeeCap)
            nativeFee = treasureFeeQuote > maxNativeFee ? maxNativeFee : treasureFeeQuote;
        }
    }

    /// @dev authenticated by msg.sender only
    function _debitFee(uint256 _amount) internal {
        uint256 fee = fees[msg.sender];
        if (_amount > fee) revert LZ_MessageLib_InvalidAmount(_amount, fee);
        unchecked {
            fees[msg.sender] = fee - _amount;
        }
    }

    function _setTreasury(address _treasury) internal {
        treasury = _treasury;
        emit TreasurySet(_treasury);
    }

    function _setExecutorConfig(uint32 _remoteEid, address _oapp, ExecutorConfig memory _config) internal {
        executorConfigs[_oapp][_remoteEid] = _config;
        emit ExecutorConfigSet(_oapp, _remoteEid, _config);
    }

    // ======================= Virtual =======================
    /// @dev these two functions will be overridden with specific logics of the library function
    function _quoteVerifier(
        address _oapp,
        uint32 _eid,
        WorkerOptions[] memory _options
    ) internal view virtual returns (uint256 nativeFee);

    /// @dev this function will split the options into executorOptions and validationOptions
    function _splitOptions(
        bytes calldata _options
    ) internal view virtual returns (bytes memory executorOptions, WorkerOptions[] memory validationOptions);
}

File 26 of 35 : SendLibBaseE2.sol
// SPDX-License-Identifier: LZBL-1.2

pragma solidity ^0.8.20;

import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import { ERC165 } from "@openzeppelin/contracts/utils/introspection/ERC165.sol";

import { ILayerZeroEndpointV2, MessagingFee } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
import { IMessageLib, MessageLibType } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/IMessageLib.sol";
import { ISendLib, Packet } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ISendLib.sol";
import { Transfer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol";

import { SendLibBase, WorkerOptions, ExecutorConfig } from "./SendLibBase.sol";

/// @dev send-side message library base contract on endpoint v2.
/// design: the high level logic is the same as SendLibBaseE1
/// 1/ with added interfaces
/// 2/ adapt the functions to the new types, like uint32 for eid, address for sender.
abstract contract SendLibBaseE2 is SendLibBase, ERC165, ISendLib {
    event NativeFeeWithdrawn(address worker, address receiver, uint256 amount);
    event LzTokenFeeWithdrawn(address lzToken, address receiver, uint256 amount);

    error LZ_MessageLib_NotTreasury();
    error LZ_MessageLib_CannotWithdrawAltToken();

    constructor(
        address _endpoint,
        uint256 _treasuryGasLimit,
        uint256 _treasuryNativeFeeCap
    ) SendLibBase(_endpoint, ILayerZeroEndpointV2(_endpoint).eid(), _treasuryGasLimit, _treasuryNativeFeeCap) {}

    function supportsInterface(bytes4 _interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            _interfaceId == type(IMessageLib).interfaceId ||
            _interfaceId == type(ISendLib).interfaceId ||
            super.supportsInterface(_interfaceId);
    }

    // ========================= OnlyEndpoint =========================
    // @dev this function is marked as virtual and public for testing purpose
    function send(
        Packet calldata _packet,
        bytes calldata _options,
        bool _payInLzToken
    ) public virtual onlyEndpoint returns (MessagingFee memory, bytes memory) {
        (bytes memory encodedPacket, uint256 totalNativeFee) = _payWorkers(_packet, _options);

        (uint256 treasuryNativeFee, uint256 lzTokenFee) = _payTreasury(
            _packet.sender,
            _packet.dstEid,
            totalNativeFee,
            _payInLzToken
        );
        totalNativeFee += treasuryNativeFee;

        return (MessagingFee(totalNativeFee, lzTokenFee), encodedPacket);
    }

    // ========================= OnlyOwner =========================
    function setTreasury(address _treasury) external onlyOwner {
        _setTreasury(_treasury);
    }

    // ========================= External =========================
    /// @dev E2 only
    function withdrawFee(address _to, uint256 _amount) external {
        _debitFee(_amount);
        address nativeToken = ILayerZeroEndpointV2(endpoint).nativeToken();
        // transfers native if nativeToken == address(0x0)
        Transfer.nativeOrToken(nativeToken, _to, _amount);
        emit NativeFeeWithdrawn(msg.sender, _to, _amount);
    }

    /// @dev _lzToken is a user-supplied value because lzToken might change in the endpoint before all lzToken can be taken out
    /// @dev E2 only
    /// @dev treasury only function
    function withdrawLzTokenFee(address _lzToken, address _to, uint256 _amount) external {
        if (msg.sender != treasury) revert LZ_MessageLib_NotTreasury();

        // lz token cannot be the same as the native token
        if (ILayerZeroEndpointV2(endpoint).nativeToken() == _lzToken) revert LZ_MessageLib_CannotWithdrawAltToken();

        Transfer.token(_lzToken, _to, _amount);

        emit LzTokenFeeWithdrawn(_lzToken, _to, _amount);
    }

    // ========================= View =========================
    function quote(
        Packet calldata _packet,
        bytes calldata _options,
        bool _payInLzToken
    ) external view returns (MessagingFee memory) {
        (uint256 nativeFee, uint256 lzTokenFee) = _quote(
            _packet.sender,
            _packet.dstEid,
            _packet.message.length,
            _payInLzToken,
            _options
        );
        return MessagingFee(nativeFee, lzTokenFee);
    }

    function messageLibType() external pure virtual override returns (MessageLibType) {
        return MessageLibType.Send;
    }

    // ========================= Internal =========================
    /// 1/ handle executor
    /// 2/ handle other workers
    function _payWorkers(
        Packet calldata _packet,
        bytes calldata _options
    ) internal returns (bytes memory encodedPacket, uint256 totalNativeFee) {
        // split workers options
        (bytes memory executorOptions, WorkerOptions[] memory validationOptions) = _splitOptions(_options);

        // handle executor
        ExecutorConfig memory config = getExecutorConfig(_packet.sender, _packet.dstEid);
        uint256 msgSize = _packet.message.length;
        _assertMessageSize(msgSize, config.maxMessageSize);
        totalNativeFee += _payExecutor(config.executor, _packet.dstEid, _packet.sender, msgSize, executorOptions);

        // handle other workers
        (uint256 verifierFee, bytes memory packetBytes) = _payVerifier(_packet, validationOptions); //for ULN, it will be dvns
        totalNativeFee += verifierFee;

        encodedPacket = packetBytes;
    }

    // ======================= Virtual =======================
    // For implementation to override
    function _payVerifier(
        Packet calldata _packet,
        WorkerOptions[] memory _options
    ) internal virtual returns (uint256 otherWorkerFees, bytes memory encodedPacket);

    // receive native token from endpoint
    receive() external payable virtual {}
}

File 27 of 35 : ILayerZeroExecutor.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

interface ILayerZeroExecutor {
    // @notice query price and assign jobs at the same time
    // @param _dstEid - the destination endpoint identifier
    // @param _sender - the source sending contract address. executors may apply price discrimination to senders
    // @param _calldataSize - dynamic data size of message + caller params
    // @param _options - optional parameters for extra service plugins, e.g. sending dust tokens at the destination chain
    function assignJob(
        uint32 _dstEid,
        address _sender,
        uint256 _calldataSize,
        bytes calldata _options
    ) external returns (uint256 price);

    // @notice query the executor price for relaying the payload and its proof to the destination chain
    // @param _dstEid - the destination endpoint identifier
    // @param _sender - the source sending contract address. executors may apply price discrimination to senders
    // @param _calldataSize - dynamic data size of message + caller params
    // @param _options - optional parameters for extra service plugins, e.g. sending dust tokens at the destination chain
    function getFee(
        uint32 _dstEid,
        address _sender,
        uint256 _calldataSize,
        bytes calldata _options
    ) external view returns (uint256 price);
}

File 28 of 35 : ILayerZeroTreasury.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

interface ILayerZeroTreasury {
    function getFee(
        address _sender,
        uint32 _dstEid,
        uint256 _totalNativeFee,
        bool _payInLzToken
    ) external view returns (uint256 fee);

    function payFee(
        address _sender,
        uint32 _dstEid,
        uint256 _totalNativeFee,
        bool _payInLzToken
    ) external payable returns (uint256 fee);
}

File 29 of 35 : SafeCall.sol
// SPDX-License-Identifier: MIT OR Apache-2.0

pragma solidity ^0.8.20;

/// @dev copied from https://github.com/nomad-xyz/ExcessivelySafeCall/blob/main/src/ExcessivelySafeCall.sol.
library SafeCall {
    /// @notice calls a contract with a specified gas limit and value and captures the return data
    /// @param _target The address to call
    /// @param _gas The amount of gas to forward to the remote contract
    /// @param _value The value in wei to send to the remote contract
    /// to memory.
    /// @param _maxCopy The maximum number of bytes of returndata to copy
    /// to memory.
    /// @param _calldata The data to send to the remote contract
    /// @return success and returndata, as `.call()`. Returndata is capped to
    /// `_maxCopy` bytes.
    function safeCall(
        address _target,
        uint256 _gas,
        uint256 _value,
        uint16 _maxCopy,
        bytes memory _calldata
    ) internal returns (bool, bytes memory) {
        // check that target has code
        uint size;
        assembly {
            size := extcodesize(_target)
        }
        if (size == 0) {
            return (false, new bytes(0));
        }

        // set up for assembly call
        uint256 _toCopy;
        bool _success;
        bytes memory _returnData = new bytes(_maxCopy);
        // dispatch message to recipient
        // by assembly calling "handle" function
        // we call via assembly to avoid memcopying a very large returndata
        // returned by a malicious contract
        assembly {
            _success := call(
                _gas, // gas
                _target, // recipient
                _value, // ether value
                add(_calldata, 0x20), // inloc
                mload(_calldata), // inlen
                0, // outloc
                0 // outlen
            )
            // limit our copy to 100 bytes
            _toCopy := returndatasize()
            if gt(_toCopy, _maxCopy) {
                _toCopy := _maxCopy
            }
            // Store the length of the copied bytes
            mstore(_returnData, _toCopy)
            // copy the bytes from returndata[0:_toCopy]
            returndatacopy(add(_returnData, 0x20), 0, _toCopy)
        }
        return (_success, _returnData);
    }

    /// @notice Use when you _really_ really _really_ don't trust the called
    /// contract. This prevents the called contract from causing reversion of
    /// the caller in as many ways as we can.
    /// @dev The main difference between this and a solidity low-level call is
    /// that we limit the number of bytes that the callee can cause to be
    /// copied to caller memory. This prevents stupid things like malicious
    /// contracts returning 10,000,000 bytes causing a local OOG when copying
    /// to memory.
    /// @param _target The address to call
    /// @param _gas The amount of gas to forward to the remote contract
    /// @param _maxCopy The maximum number of bytes of returndata to copy
    /// to memory.
    /// @param _calldata The data to send to the remote contract
    /// @return success and returndata, as `.call()`. Returndata is capped to
    /// `_maxCopy` bytes.
    function safeStaticCall(
        address _target,
        uint256 _gas,
        uint16 _maxCopy,
        bytes memory _calldata
    ) internal view returns (bool, bytes memory) {
        // check that target has code
        uint size;
        assembly {
            size := extcodesize(_target)
        }
        if (size == 0) {
            return (false, new bytes(0));
        }

        // set up for assembly call
        uint256 _toCopy;
        bool _success;
        bytes memory _returnData = new bytes(_maxCopy);
        // dispatch message to recipient
        // by assembly calling "handle" function
        // we call via assembly to avoid memcopying a very large returndata
        // returned by a malicious contract
        assembly {
            _success := staticcall(
                _gas, // gas
                _target, // recipient
                add(_calldata, 0x20), // inloc
                mload(_calldata), // inlen
                0, // outloc
                0 // outlen
            )
            // limit our copy to 256 bytes
            _toCopy := returndatasize()
            if gt(_toCopy, _maxCopy) {
                _toCopy := _maxCopy
            }
            // Store the length of the copied bytes
            mstore(_returnData, _toCopy)
            // copy the bytes from returndata[0:_toCopy]
            returndatacopy(add(_returnData, 0x20), 0, _toCopy)
        }
        return (_success, _returnData);
    }
}

File 30 of 35 : SendUlnBase.sol
// SPDX-License-Identifier: LZBL-1.2

pragma solidity ^0.8.20;

import { Packet } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ISendLib.sol";
import { PacketV1Codec } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/PacketV1Codec.sol";

import { ILayerZeroDVN } from "./interfaces/ILayerZeroDVN.sol";
import { DVNOptions } from "./libs/DVNOptions.sol";
import { UlnOptions } from "./libs/UlnOptions.sol";
import { WorkerOptions } from "../SendLibBase.sol";
import { UlnConfig, UlnBase } from "./UlnBase.sol";

/// @dev includes the utility functions for checking ULN states and logics
abstract contract SendUlnBase is UlnBase {
    event DVNFeePaid(address[] requiredDVNs, address[] optionalDVNs, uint256[] fees);

    function _splitUlnOptions(bytes calldata _options) internal pure returns (bytes memory, WorkerOptions[] memory) {
        (bytes memory executorOpts, bytes memory dvnOpts) = UlnOptions.decode(_options);

        if (dvnOpts.length == 0) {
            return (executorOpts, new WorkerOptions[](0));
        }

        WorkerOptions[] memory workerOpts = new WorkerOptions[](1);
        workerOpts[0] = WorkerOptions(DVNOptions.WORKER_ID, dvnOpts);
        return (executorOpts, workerOpts);
    }

    /// ---------- pay and assign jobs ----------

    function _payDVNs(
        mapping(address => uint256) storage _fees,
        Packet memory _packet,
        WorkerOptions[] memory _options
    ) internal returns (uint256 totalFee, bytes memory encodedPacket) {
        bytes memory packetHeader = PacketV1Codec.encodePacketHeader(_packet);
        bytes memory payload = PacketV1Codec.encodePayload(_packet);
        bytes32 payloadHash = keccak256(payload);
        uint32 dstEid = _packet.dstEid;
        address sender = _packet.sender;
        UlnConfig memory config = getUlnConfig(sender, dstEid);

        // if options is not empty, it must be dvn options
        bytes memory dvnOptions = _options.length == 0 ? bytes("") : _options[0].options;
        uint256[] memory dvnFees;
        (totalFee, dvnFees) = _assignJobs(
            _fees,
            config,
            ILayerZeroDVN.AssignJobParam(dstEid, packetHeader, payloadHash, config.confirmations, sender),
            dvnOptions
        );
        encodedPacket = abi.encodePacked(packetHeader, payload);

        emit DVNFeePaid(config.requiredDVNs, config.optionalDVNs, dvnFees);
    }

    function _assignJobs(
        mapping(address => uint256) storage _fees,
        UlnConfig memory _ulnConfig,
        ILayerZeroDVN.AssignJobParam memory _param,
        bytes memory dvnOptions
    ) internal returns (uint256 totalFee, uint256[] memory dvnFees) {
        (bytes[] memory optionsArray, uint8[] memory dvnIds) = DVNOptions.groupDVNOptionsByIdx(dvnOptions);

        uint8 dvnsLength = _ulnConfig.requiredDVNCount + _ulnConfig.optionalDVNCount;
        dvnFees = new uint256[](dvnsLength);
        for (uint8 i = 0; i < dvnsLength; ++i) {
            address dvn = i < _ulnConfig.requiredDVNCount
                ? _ulnConfig.requiredDVNs[i]
                : _ulnConfig.optionalDVNs[i - _ulnConfig.requiredDVNCount];

            bytes memory options = "";
            for (uint256 j = 0; j < dvnIds.length; ++j) {
                if (dvnIds[j] == i) {
                    options = optionsArray[j];
                    break;
                }
            }

            dvnFees[i] = ILayerZeroDVN(dvn).assignJob(_param, options);
            if (dvnFees[i] > 0) {
                _fees[dvn] += dvnFees[i];
                totalFee += dvnFees[i];
            }
        }
    }

    /// ---------- quote ----------
    function _quoteDVNs(
        address _sender,
        uint32 _dstEid,
        WorkerOptions[] memory _options
    ) internal view returns (uint256 totalFee) {
        UlnConfig memory config = getUlnConfig(_sender, _dstEid);

        // if options is not empty, it must be dvn options
        bytes memory dvnOptions = _options.length == 0 ? bytes("") : _options[0].options;
        (bytes[] memory optionsArray, uint8[] memory dvnIndices) = DVNOptions.groupDVNOptionsByIdx(dvnOptions);

        totalFee = _getFees(config, _dstEid, _sender, optionsArray, dvnIndices);
    }

    function _getFees(
        UlnConfig memory _config,
        uint32 _dstEid,
        address _sender,
        bytes[] memory _optionsArray,
        uint8[] memory _dvnIds
    ) internal view returns (uint256 totalFee) {
        // here we merge 2 list of dvns into 1 to allocate the indexed dvn options to the right dvn
        uint8 dvnsLength = _config.requiredDVNCount + _config.optionalDVNCount;
        for (uint8 i = 0; i < dvnsLength; ++i) {
            address dvn = i < _config.requiredDVNCount
                ? _config.requiredDVNs[i]
                : _config.optionalDVNs[i - _config.requiredDVNCount];

            bytes memory options = "";
            // it is a double loop here. however, if the list is short, the cost is very acceptable.
            for (uint256 j = 0; j < _dvnIds.length; ++j) {
                if (_dvnIds[j] == i) {
                    options = _optionsArray[j];
                    break;
                }
            }
            totalFee += ILayerZeroDVN(dvn).getFee(_dstEid, _config.confirmations, _sender, options);
        }
    }
}

File 31 of 35 : UlnBase.sol
// SPDX-License-Identifier: LZBL-1.2

pragma solidity ^0.8.20;

import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";

// the formal properties are documented in the setter functions
struct UlnConfig {
    uint64 confirmations;
    // we store the length of required DVNs and optional DVNs instead of using DVN.length directly to save gas
    uint8 requiredDVNCount; // 0 indicate DEFAULT, NIL_DVN_COUNT indicate NONE (to override the value of default)
    uint8 optionalDVNCount; // 0 indicate DEFAULT, NIL_DVN_COUNT indicate NONE (to override the value of default)
    uint8 optionalDVNThreshold; // (0, optionalDVNCount]
    address[] requiredDVNs; // no duplicates. sorted an an ascending order. allowed overlap with optionalDVNs
    address[] optionalDVNs; // no duplicates. sorted an an ascending order. allowed overlap with requiredDVNs
}

struct SetDefaultUlnConfigParam {
    uint32 eid;
    UlnConfig config;
}

/// @dev includes the utility functions for checking ULN states and logics
abstract contract UlnBase is Ownable {
    address private constant DEFAULT_CONFIG = address(0);
    // reserved values for
    uint8 internal constant DEFAULT = 0;
    uint8 internal constant NIL_DVN_COUNT = type(uint8).max;
    uint64 internal constant NIL_CONFIRMATIONS = type(uint64).max;
    // 127 to prevent total number of DVNs (127 * 2) exceeding uint8.max (255)
    // by limiting the total size, it would help constraint the design of DVNOptions
    uint8 private constant MAX_COUNT = (type(uint8).max - 1) / 2;

    mapping(address oapp => mapping(uint32 eid => UlnConfig)) internal ulnConfigs;

    error LZ_ULN_Unsorted();
    error LZ_ULN_InvalidRequiredDVNCount();
    error LZ_ULN_InvalidOptionalDVNCount();
    error LZ_ULN_AtLeastOneDVN();
    error LZ_ULN_InvalidOptionalDVNThreshold();
    error LZ_ULN_InvalidConfirmations();
    error LZ_ULN_UnsupportedEid(uint32 eid);

    event DefaultUlnConfigsSet(SetDefaultUlnConfigParam[] params);
    event UlnConfigSet(address oapp, uint32 eid, UlnConfig config);

    // ============================ OnlyOwner ===================================

    /// @dev about the DEFAULT ULN config
    /// 1) its values are all LITERAL (e.g. 0 is 0). whereas in the oapp ULN config, 0 (default value) points to the default ULN config
    ///     this design enables the oapp to point to DEFAULT config without explicitly setting the config
    /// 2) its configuration is more restrictive than the oapp ULN config that
    ///     a) it must not use NIL value, where NIL is used only by oapps to indicate the LITERAL 0
    ///     b) it must have at least one DVN
    function setDefaultUlnConfigs(SetDefaultUlnConfigParam[] calldata _params) external onlyOwner {
        for (uint256 i = 0; i < _params.length; ++i) {
            SetDefaultUlnConfigParam calldata param = _params[i];

            // 2.a must not use NIL
            if (param.config.requiredDVNCount == NIL_DVN_COUNT) revert LZ_ULN_InvalidRequiredDVNCount();
            if (param.config.optionalDVNCount == NIL_DVN_COUNT) revert LZ_ULN_InvalidOptionalDVNCount();
            if (param.config.confirmations == NIL_CONFIRMATIONS) revert LZ_ULN_InvalidConfirmations();

            // 2.b must have at least one dvn
            _assertAtLeastOneDVN(param.config);

            _setConfig(DEFAULT_CONFIG, param.eid, param.config);
        }
        emit DefaultUlnConfigsSet(_params);
    }

    // ============================ View ===================================
    // @dev assuming most oapps use default, we get default as memory and custom as storage to save gas
    function getUlnConfig(address _oapp, uint32 _remoteEid) public view returns (UlnConfig memory rtnConfig) {
        UlnConfig storage defaultConfig = ulnConfigs[DEFAULT_CONFIG][_remoteEid];
        UlnConfig storage customConfig = ulnConfigs[_oapp][_remoteEid];

        // if confirmations is 0, use default
        uint64 confirmations = customConfig.confirmations;
        if (confirmations == DEFAULT) {
            rtnConfig.confirmations = defaultConfig.confirmations;
        } else if (confirmations != NIL_CONFIRMATIONS) {
            // if confirmations is uint64.max, no block confirmations required
            rtnConfig.confirmations = confirmations;
        } // else do nothing, rtnConfig.confirmation is 0

        if (customConfig.requiredDVNCount == DEFAULT) {
            if (defaultConfig.requiredDVNCount > 0) {
                // copy only if count > 0. save gas
                rtnConfig.requiredDVNs = defaultConfig.requiredDVNs;
                rtnConfig.requiredDVNCount = defaultConfig.requiredDVNCount;
            } // else, do nothing
        } else {
            if (customConfig.requiredDVNCount != NIL_DVN_COUNT) {
                rtnConfig.requiredDVNs = customConfig.requiredDVNs;
                rtnConfig.requiredDVNCount = customConfig.requiredDVNCount;
            } // else, do nothing
        }

        if (customConfig.optionalDVNCount == DEFAULT) {
            if (defaultConfig.optionalDVNCount > 0) {
                // copy only if count > 0. save gas
                rtnConfig.optionalDVNs = defaultConfig.optionalDVNs;
                rtnConfig.optionalDVNCount = defaultConfig.optionalDVNCount;
                rtnConfig.optionalDVNThreshold = defaultConfig.optionalDVNThreshold;
            }
        } else {
            if (customConfig.optionalDVNCount != NIL_DVN_COUNT) {
                rtnConfig.optionalDVNs = customConfig.optionalDVNs;
                rtnConfig.optionalDVNCount = customConfig.optionalDVNCount;
                rtnConfig.optionalDVNThreshold = customConfig.optionalDVNThreshold;
            }
        }

        // the final value must have at least one dvn
        // it is possible that some default config result into 0 dvns
        _assertAtLeastOneDVN(rtnConfig);
    }

    /// @dev Get the uln config without the default config for the given remoteEid.
    function getAppUlnConfig(address _oapp, uint32 _remoteEid) external view returns (UlnConfig memory) {
        return ulnConfigs[_oapp][_remoteEid];
    }

    // ============================ Internal ===================================
    function _setUlnConfig(uint32 _remoteEid, address _oapp, UlnConfig memory _param) internal {
        _setConfig(_oapp, _remoteEid, _param);

        // get ULN config again as a catch all to ensure the config is valid
        getUlnConfig(_oapp, _remoteEid);
        emit UlnConfigSet(_oapp, _remoteEid, _param);
    }

    /// @dev a supported Eid must have a valid default uln config, which has at least one dvn
    function _isSupportedEid(uint32 _remoteEid) internal view returns (bool) {
        UlnConfig storage defaultConfig = ulnConfigs[DEFAULT_CONFIG][_remoteEid];
        return defaultConfig.requiredDVNCount > 0 || defaultConfig.optionalDVNThreshold > 0;
    }

    function _assertSupportedEid(uint32 _remoteEid) internal view {
        if (!_isSupportedEid(_remoteEid)) revert LZ_ULN_UnsupportedEid(_remoteEid);
    }

    // ============================ Private ===================================

    function _assertAtLeastOneDVN(UlnConfig memory _config) private pure {
        if (_config.requiredDVNCount == 0 && _config.optionalDVNThreshold == 0) revert LZ_ULN_AtLeastOneDVN();
    }

    /// @dev this private function is used in both setDefaultUlnConfigs and setUlnConfig
    function _setConfig(address _oapp, uint32 _eid, UlnConfig memory _param) private {
        // @dev required dvns
        // if dvnCount == NONE, dvns list must be empty
        // if dvnCount == DEFAULT, dvn list must be empty
        // otherwise, dvnList.length == dvnCount and assert the list is valid
        if (_param.requiredDVNCount == NIL_DVN_COUNT || _param.requiredDVNCount == DEFAULT) {
            if (_param.requiredDVNs.length != 0) revert LZ_ULN_InvalidRequiredDVNCount();
        } else {
            if (_param.requiredDVNs.length != _param.requiredDVNCount || _param.requiredDVNCount > MAX_COUNT)
                revert LZ_ULN_InvalidRequiredDVNCount();
            _assertNoDuplicates(_param.requiredDVNs);
        }

        // @dev optional dvns
        // if optionalDVNCount == NONE, optionalDVNs list must be empty and threshold must be 0
        // if optionalDVNCount == DEFAULT, optionalDVNs list must be empty and threshold must be 0
        // otherwise, optionalDVNs.length == optionalDVNCount, threshold > 0 && threshold <= optionalDVNCount and assert the list is valid

        // example use case: an oapp uses the DEFAULT 'required' but
        //     a) use a custom 1/1 dvn (practically a required dvn), or
        //     b) use a custom 2/3 dvn
        if (_param.optionalDVNCount == NIL_DVN_COUNT || _param.optionalDVNCount == DEFAULT) {
            if (_param.optionalDVNs.length != 0) revert LZ_ULN_InvalidOptionalDVNCount();
            if (_param.optionalDVNThreshold != 0) revert LZ_ULN_InvalidOptionalDVNThreshold();
        } else {
            if (_param.optionalDVNs.length != _param.optionalDVNCount || _param.optionalDVNCount > MAX_COUNT)
                revert LZ_ULN_InvalidOptionalDVNCount();
            if (_param.optionalDVNThreshold == 0 || _param.optionalDVNThreshold > _param.optionalDVNCount)
                revert LZ_ULN_InvalidOptionalDVNThreshold();
            _assertNoDuplicates(_param.optionalDVNs);
        }
        // don't assert valid count here, as it needs to be validated along side default config

        ulnConfigs[_oapp][_eid] = _param;
    }

    function _assertNoDuplicates(address[] memory _dvns) private pure {
        address lastDVN = address(0);
        for (uint256 i = 0; i < _dvns.length; i++) {
            address dvn = _dvns[i];
            if (dvn <= lastDVN) revert LZ_ULN_Unsorted(); // to ensure no duplicates
            lastDVN = dvn;
        }
    }
}

File 32 of 35 : ILayerZeroDVN.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

interface ILayerZeroDVN {
    struct AssignJobParam {
        uint32 dstEid;
        bytes packetHeader;
        bytes32 payloadHash;
        uint64 confirmations;
        address sender;
    }

    // @notice query price and assign jobs at the same time
    // @param _dstEid - the destination endpoint identifier
    // @param _packetHeader - version + nonce + path
    // @param _payloadHash - hash of guid + message
    // @param _confirmations - block confirmation delay before relaying blocks
    // @param _sender - the source sending contract address
    // @param _options - options
    function assignJob(AssignJobParam calldata _param, bytes calldata _options) external payable returns (uint256 fee);

    // @notice query the dvn fee for relaying block information to the destination chain
    // @param _dstEid the destination endpoint identifier
    // @param _confirmations - block confirmation delay before relaying blocks
    // @param _sender - the source sending contract address
    // @param _options - options
    function getFee(
        uint32 _dstEid,
        uint64 _confirmations,
        address _sender,
        bytes calldata _options
    ) external view returns (uint256 fee);
}

File 33 of 35 : DVNOptions.sol
// SPDX-License-Identifier: LZBL-1.2

pragma solidity ^0.8.20;

import { BytesLib } from "solidity-bytes-utils/contracts/BytesLib.sol";

import { BitMap256 } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/BitMaps.sol";
import { CalldataBytesLib } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/CalldataBytesLib.sol";

library DVNOptions {
    using CalldataBytesLib for bytes;
    using BytesLib for bytes;

    uint8 internal constant WORKER_ID = 2;
    uint8 internal constant OPTION_TYPE_PRECRIME = 1;

    error DVN_InvalidDVNIdx();
    error DVN_InvalidDVNOptions(uint256 cursor);

    /// @dev group dvn options by its idx
    /// @param _options [dvn_id][dvn_option][dvn_id][dvn_option]...
    ///        dvn_option = [option_size][dvn_idx][option_type][option]
    ///        option_size = len(dvn_idx) + len(option_type) + len(option)
    ///        dvn_id: uint8, dvn_idx: uint8, option_size: uint16, option_type: uint8, option: bytes
    /// @return dvnOptions the grouped options, still share the same format of _options
    /// @return dvnIndices the dvn indices
    function groupDVNOptionsByIdx(
        bytes memory _options
    ) internal pure returns (bytes[] memory dvnOptions, uint8[] memory dvnIndices) {
        if (_options.length == 0) return (dvnOptions, dvnIndices);

        uint8 numDVNs = getNumDVNs(_options);

        // if there is only 1 dvn, we can just return the whole options
        if (numDVNs == 1) {
            dvnOptions = new bytes[](1);
            dvnOptions[0] = _options;

            dvnIndices = new uint8[](1);
            dvnIndices[0] = _options.toUint8(3); // dvn idx
            return (dvnOptions, dvnIndices);
        }

        // otherwise, we need to group the options by dvn_idx
        dvnIndices = new uint8[](numDVNs);
        dvnOptions = new bytes[](numDVNs);
        unchecked {
            uint256 cursor = 0;
            uint256 start = 0;
            uint8 lastDVNIdx = 255; // 255 is an invalid dvn_idx

            while (cursor < _options.length) {
                ++cursor; // skip worker_id

                // optionLength asserted in getNumDVNs (skip check)
                uint16 optionLength = _options.toUint16(cursor);
                cursor += 2;

                // dvnIdx asserted in getNumDVNs (skip check)
                uint8 dvnIdx = _options.toUint8(cursor);

                // dvnIdx must equal to the lastDVNIdx for the first option
                // so it is always skipped in the first option
                // this operation slices out options whenever the scan finds a different lastDVNIdx
                if (lastDVNIdx == 255) {
                    lastDVNIdx = dvnIdx;
                } else if (dvnIdx != lastDVNIdx) {
                    uint256 len = cursor - start - 3; // 3 is for worker_id and option_length
                    bytes memory opt = _options.slice(start, len);
                    _insertDVNOptions(dvnOptions, dvnIndices, lastDVNIdx, opt);

                    // reset the start and lastDVNIdx
                    start += len;
                    lastDVNIdx = dvnIdx;
                }

                cursor += optionLength;
            }

            // skip check the cursor here because the cursor is asserted in getNumDVNs
            // if we have reached the end of the options, we need to process the last dvn
            uint256 size = cursor - start;
            bytes memory op = _options.slice(start, size);
            _insertDVNOptions(dvnOptions, dvnIndices, lastDVNIdx, op);

            // revert dvnIndices to start from 0
            for (uint8 i = 0; i < numDVNs; ++i) {
                --dvnIndices[i];
            }
        }
    }

    function _insertDVNOptions(
        bytes[] memory _dvnOptions,
        uint8[] memory _dvnIndices,
        uint8 _dvnIdx,
        bytes memory _newOptions
    ) internal pure {
        // dvnIdx starts from 0 but default value of dvnIndices is 0,
        // so we tell if the slot is empty by adding 1 to dvnIdx
        if (_dvnIdx == 255) revert DVN_InvalidDVNIdx();
        uint8 dvnIdxAdj = _dvnIdx + 1;

        for (uint256 j = 0; j < _dvnIndices.length; ++j) {
            uint8 index = _dvnIndices[j];
            if (dvnIdxAdj == index) {
                _dvnOptions[j] = abi.encodePacked(_dvnOptions[j], _newOptions);
                break;
            } else if (index == 0) {
                // empty slot, that means it is the first time we see this dvn
                _dvnIndices[j] = dvnIdxAdj;
                _dvnOptions[j] = _newOptions;
                break;
            }
        }
    }

    /// @dev get the number of unique dvns
    /// @param _options the format is the same as groupDVNOptionsByIdx
    function getNumDVNs(bytes memory _options) internal pure returns (uint8 numDVNs) {
        uint256 cursor = 0;
        BitMap256 bitmap;

        // find number of unique dvn_idx
        unchecked {
            while (cursor < _options.length) {
                ++cursor; // skip worker_id

                uint16 optionLength = _options.toUint16(cursor);
                cursor += 2;
                if (optionLength < 2) revert DVN_InvalidDVNOptions(cursor); // at least 1 byte for dvn_idx and 1 byte for option_type

                uint8 dvnIdx = _options.toUint8(cursor);

                // if dvnIdx is not set, increment numDVNs
                // max num of dvns is 255, 255 is an invalid dvn_idx
                // The order of the dvnIdx is not required to be sequential, as enforcing the order may weaken
                // the composability of the options. e.g. if we refrain from enforcing the order, an OApp that has
                // already enforced certain options can append additional options to the end of the enforced
                // ones without restrictions.
                if (dvnIdx == 255) revert DVN_InvalidDVNIdx();
                if (!bitmap.get(dvnIdx)) {
                    ++numDVNs;
                    bitmap = bitmap.set(dvnIdx);
                }

                cursor += optionLength;
            }
        }
        if (cursor != _options.length) revert DVN_InvalidDVNOptions(cursor);
    }

    /// @dev decode the next dvn option from _options starting from the specified cursor
    /// @param _options the format is the same as groupDVNOptionsByIdx
    /// @param _cursor the cursor to start decoding
    /// @return optionType the type of the option
    /// @return option the option
    /// @return cursor the cursor to start decoding the next option
    function nextDVNOption(
        bytes calldata _options,
        uint256 _cursor
    ) internal pure returns (uint8 optionType, bytes calldata option, uint256 cursor) {
        unchecked {
            // skip worker id
            cursor = _cursor + 1;

            // read option size
            uint16 size = _options.toU16(cursor);
            cursor += 2;

            // read option type
            optionType = _options.toU8(cursor + 1); // skip dvn_idx

            // startCursor and endCursor are used to slice the option from _options
            uint256 startCursor = cursor + 2; // skip option type and dvn_idx
            uint256 endCursor = cursor + size;
            option = _options[startCursor:endCursor];
            cursor += size;
        }
    }
}

File 34 of 35 : UlnOptions.sol
// SPDX-License-Identifier: LZBL-1.2

pragma solidity ^0.8.20;

import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";

import { ExecutorOptions } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/ExecutorOptions.sol";

import { DVNOptions } from "./DVNOptions.sol";

library UlnOptions {
    using SafeCast for uint256;

    uint16 internal constant TYPE_1 = 1; // legacy options type 1
    uint16 internal constant TYPE_2 = 2; // legacy options type 2
    uint16 internal constant TYPE_3 = 3;

    error LZ_ULN_InvalidWorkerOptions(uint256 cursor);
    error LZ_ULN_InvalidWorkerId(uint8 workerId);
    error LZ_ULN_InvalidLegacyType1Option();
    error LZ_ULN_InvalidLegacyType2Option();
    error LZ_ULN_UnsupportedOptionType(uint16 optionType);

    /// @dev decode the options into executorOptions and dvnOptions
    /// @param _options the options can be either legacy options (type 1 or 2) or type 3 options
    /// @return executorOptions the executor options, share the same format of type 3 options
    /// @return dvnOptions the dvn options, share the same format of type 3 options
    function decode(
        bytes calldata _options
    ) internal pure returns (bytes memory executorOptions, bytes memory dvnOptions) {
        // at least 2 bytes for the option type, but can have no options
        if (_options.length < 2) revert LZ_ULN_InvalidWorkerOptions(0);

        uint16 optionsType = uint16(bytes2(_options[0:2]));
        uint256 cursor = 2;

        // type3 options: [worker_option][worker_option]...
        // worker_option: [worker_id][option_size][option]
        // worker_id: uint8, option_size: uint16, option: bytes
        if (optionsType == TYPE_3) {
            unchecked {
                uint256 start = cursor;
                uint8 lastWorkerId; // worker_id starts from 1, so 0 is an invalid worker_id

                // heuristic: we assume that the options are mostly EXECUTOR options only
                // checking the workerID can reduce gas usage for most cases
                while (cursor < _options.length) {
                    uint8 workerId = uint8(bytes1(_options[cursor:cursor + 1]));
                    if (workerId == 0) revert LZ_ULN_InvalidWorkerId(0);

                    // workerId must equal to the lastWorkerId for the first option
                    // so it is always skipped in the first option
                    // this operation slices out options whenever the the scan finds a different workerId
                    if (lastWorkerId == 0) {
                        lastWorkerId = workerId;
                    } else if (workerId != lastWorkerId) {
                        bytes calldata op = _options[start:cursor]; // slice out the last worker's options
                        (executorOptions, dvnOptions) = _insertWorkerOptions(
                            executorOptions,
                            dvnOptions,
                            lastWorkerId,
                            op
                        );

                        // reset the start cursor and lastWorkerId
                        start = cursor;
                        lastWorkerId = workerId;
                    }

                    ++cursor; // for workerId

                    uint16 size = uint16(bytes2(_options[cursor:cursor + 2]));
                    if (size == 0) revert LZ_ULN_InvalidWorkerOptions(cursor);
                    cursor += size + 2;
                }

                // the options length must be the same as the cursor at the end
                if (cursor != _options.length) revert LZ_ULN_InvalidWorkerOptions(cursor);

                // if we have reached the end of the options and the options are not empty
                // we need to process the last worker's options
                if (_options.length > 2) {
                    bytes calldata op = _options[start:cursor];
                    (executorOptions, dvnOptions) = _insertWorkerOptions(executorOptions, dvnOptions, lastWorkerId, op);
                }
            }
        } else {
            executorOptions = decodeLegacyOptions(optionsType, _options);
        }
    }

    function _insertWorkerOptions(
        bytes memory _executorOptions,
        bytes memory _dvnOptions,
        uint8 _workerId,
        bytes calldata _newOptions
    ) private pure returns (bytes memory, bytes memory) {
        if (_workerId == ExecutorOptions.WORKER_ID) {
            _executorOptions = _executorOptions.length == 0
                ? _newOptions
                : abi.encodePacked(_executorOptions, _newOptions);
        } else if (_workerId == DVNOptions.WORKER_ID) {
            _dvnOptions = _dvnOptions.length == 0 ? _newOptions : abi.encodePacked(_dvnOptions, _newOptions);
        } else {
            revert LZ_ULN_InvalidWorkerId(_workerId);
        }
        return (_executorOptions, _dvnOptions);
    }

    /// @dev decode the legacy options (type 1 or 2) into executorOptions
    /// @param _optionType the legacy option type
    /// @param _options the legacy options, which still has the option type in the first 2 bytes
    /// @return executorOptions the executor options, share the same format of type 3 options
    /// Data format:
    /// legacy type 1: [extraGas]
    /// legacy type 2: [extraGas][dstNativeAmt][dstNativeAddress]
    /// extraGas: uint256, dstNativeAmt: uint256, dstNativeAddress: bytes
    function decodeLegacyOptions(
        uint16 _optionType,
        bytes calldata _options
    ) internal pure returns (bytes memory executorOptions) {
        if (_optionType == TYPE_1) {
            if (_options.length != 34) revert LZ_ULN_InvalidLegacyType1Option();

            // execution gas
            uint128 executionGas = uint256(bytes32(_options[2:2 + 32])).toUint128();

            // dont use the encode function in the ExecutorOptions lib for saving gas by calling abi.encodePacked once
            // the result is a lzReceive option: [executor_id][option_size][option_type][execution_gas]
            // option_type: uint8, execution_gas: uint128
            // option_size = len(option_type) + len(execution_gas) = 1 + 16 = 17
            executorOptions = abi.encodePacked(
                ExecutorOptions.WORKER_ID,
                uint16(17), // 16 + 1, 16 for option_length, + 1 for option_type
                ExecutorOptions.OPTION_TYPE_LZRECEIVE,
                executionGas
            );
        } else if (_optionType == TYPE_2) {
            // receiver size <= 32
            if (_options.length <= 66 || _options.length > 98) revert LZ_ULN_InvalidLegacyType2Option();

            // execution gas
            uint128 executionGas = uint256(bytes32(_options[2:2 + 32])).toUint128();

            // nativeDrop (amount + receiver)
            uint128 amount = uint256(bytes32(_options[34:34 + 32])).toUint128(); // offset 2 + 32
            bytes32 receiver;
            unchecked {
                uint256 receiverLen = _options.length - 66; // offset 2 + 32 + 32
                receiver = bytes32(_options[66:]);
                receiver = receiver >> (8 * (32 - receiverLen)); // padding 0 to the left
            }

            // dont use the encode function in the ExecutorOptions lib for saving gas by calling abi.encodePacked once
            // the result has one lzReceive option and one nativeDrop option:
            //      [executor_id][lzReceive_option_size][option_type][execution_gas] +
            //      [executor_id][nativeDrop_option_size][option_type][nativeDrop_amount][receiver]
            // option_type: uint8, execution_gas: uint128, nativeDrop_amount: uint128, receiver: bytes32
            // lzReceive_option_size = len(option_type) + len(execution_gas) = 1 + 16 = 17
            // nativeDrop_option_size = len(option_type) + len(nativeDrop_amount) + len(receiver) = 1 + 16 + 32 = 49
            executorOptions = abi.encodePacked(
                ExecutorOptions.WORKER_ID,
                uint16(17), // 16 + 1, 16 for option_length, + 1 for option_type
                ExecutorOptions.OPTION_TYPE_LZRECEIVE,
                executionGas,
                ExecutorOptions.WORKER_ID,
                uint16(49), // 48 + 1, 32 + 16 for option_length, + 1 for option_type
                ExecutorOptions.OPTION_TYPE_NATIVE_DROP,
                amount,
                receiver
            );
        } else {
            revert LZ_ULN_UnsupportedOptionType(_optionType);
        }
    }
}

File 35 of 35 : BytesLib.sol
// SPDX-License-Identifier: Unlicense
/*
 * @title Solidity Bytes Arrays Utils
 * @author Gonçalo Sá <[email protected]>
 *
 * @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.
 *      The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.
 */
pragma solidity >=0.8.0 <0.9.0;


library BytesLib {
    function concat(
        bytes memory _preBytes,
        bytes memory _postBytes
    )
        internal
        pure
        returns (bytes memory)
    {
        bytes memory tempBytes;

        assembly {
            // Get a location of some free memory and store it in tempBytes as
            // Solidity does for memory variables.
            tempBytes := mload(0x40)

            // Store the length of the first bytes array at the beginning of
            // the memory for tempBytes.
            let length := mload(_preBytes)
            mstore(tempBytes, length)

            // Maintain a memory counter for the current write location in the
            // temp bytes array by adding the 32 bytes for the array length to
            // the starting location.
            let mc := add(tempBytes, 0x20)
            // Stop copying when the memory counter reaches the length of the
            // first bytes array.
            let end := add(mc, length)

            for {
                // Initialize a copy counter to the start of the _preBytes data,
                // 32 bytes into its memory.
                let cc := add(_preBytes, 0x20)
            } lt(mc, end) {
                // Increase both counters by 32 bytes each iteration.
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                // Write the _preBytes data into the tempBytes memory 32 bytes
                // at a time.
                mstore(mc, mload(cc))
            }

            // Add the length of _postBytes to the current length of tempBytes
            // and store it as the new length in the first 32 bytes of the
            // tempBytes memory.
            length := mload(_postBytes)
            mstore(tempBytes, add(length, mload(tempBytes)))

            // Move the memory counter back from a multiple of 0x20 to the
            // actual end of the _preBytes data.
            mc := end
            // Stop copying when the memory counter reaches the new combined
            // length of the arrays.
            end := add(mc, length)

            for {
                let cc := add(_postBytes, 0x20)
            } lt(mc, end) {
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                mstore(mc, mload(cc))
            }

            // Update the free-memory pointer by padding our last write location
            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
            // next 32 byte block, then round down to the nearest multiple of
            // 32. If the sum of the length of the two arrays is zero then add
            // one before rounding down to leave a blank 32 bytes (the length block with 0).
            mstore(0x40, and(
              add(add(end, iszero(add(length, mload(_preBytes)))), 31),
              not(31) // Round down to the nearest 32 bytes.
            ))
        }

        return tempBytes;
    }

    function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
        assembly {
            // Read the first 32 bytes of _preBytes storage, which is the length
            // of the array. (We don't need to use the offset into the slot
            // because arrays use the entire slot.)
            let fslot := sload(_preBytes.slot)
            // Arrays of 31 bytes or less have an even value in their slot,
            // while longer arrays have an odd value. The actual length is
            // the slot divided by two for odd values, and the lowest order
            // byte divided by two for even values.
            // If the slot is even, bitwise and the slot with 255 and divide by
            // two to get the length. If the slot is odd, bitwise and the slot
            // with -1 and divide by two.
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)
            let newlength := add(slength, mlength)
            // slength can contain both the length and contents of the array
            // if length < 32 bytes so let's prepare for that
            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
            switch add(lt(slength, 32), lt(newlength, 32))
            case 2 {
                // Since the new array still fits in the slot, we just need to
                // update the contents of the slot.
                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
                sstore(
                    _preBytes.slot,
                    // all the modifications to the slot are inside this
                    // next block
                    add(
                        // we can just add to the slot contents because the
                        // bytes we want to change are the LSBs
                        fslot,
                        add(
                            mul(
                                div(
                                    // load the bytes from memory
                                    mload(add(_postBytes, 0x20)),
                                    // zero all bytes to the right
                                    exp(0x100, sub(32, mlength))
                                ),
                                // and now shift left the number of bytes to
                                // leave space for the length in the slot
                                exp(0x100, sub(32, newlength))
                            ),
                            // increase length by the double of the memory
                            // bytes length
                            mul(mlength, 2)
                        )
                    )
                )
            }
            case 1 {
                // The stored value fits in the slot, but the combined value
                // will exceed it.
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))

                // The contents of the _postBytes array start 32 bytes into
                // the structure. Our first read should obtain the `submod`
                // bytes that can fit into the unused space in the last word
                // of the stored array. To get this, we read 32 bytes starting
                // from `submod`, so the data we read overlaps with the array
                // contents by `submod` bytes. Masking the lowest-order
                // `submod` bytes allows us to add that value directly to the
                // stored value.

                let submod := sub(32, slength)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(
                    sc,
                    add(
                        and(
                            fslot,
                            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
                        ),
                        and(mload(mc), mask)
                    )
                )

                for {
                    mc := add(mc, 0x20)
                    sc := add(sc, 1)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
            default {
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                // Start copying to the last used word of the stored array.
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))

                // Copy over the first `submod` bytes of the new data as in
                // case 1 above.
                let slengthmod := mod(slength, 32)
                let mlengthmod := mod(mlength, 32)
                let submod := sub(32, slengthmod)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(sc, add(sload(sc), and(mload(mc), mask)))

                for {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
        }
    }

    function slice(
        bytes memory _bytes,
        uint256 _start,
        uint256 _length
    )
        internal
        pure
        returns (bytes memory)
    {
        require(_length + 31 >= _length, "slice_overflow");
        require(_bytes.length >= _start + _length, "slice_outOfBounds");

        bytes memory tempBytes;

        assembly {
            switch iszero(_length)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)

                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                let lengthmod := and(_length, 31)

                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)

                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, _length)

                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)
                //zero out the 32 bytes slice we are about to return
                //we need to do it because Solidity does not garbage collect
                mstore(tempBytes, 0)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return tempBytes;
    }

    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
        require(_bytes.length >= _start + 20, "toAddress_outOfBounds");
        address tempAddress;

        assembly {
            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
        }

        return tempAddress;
    }

    function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) {
        require(_bytes.length >= _start + 1 , "toUint8_outOfBounds");
        uint8 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x1), _start))
        }

        return tempUint;
    }

    function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16) {
        require(_bytes.length >= _start + 2, "toUint16_outOfBounds");
        uint16 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x2), _start))
        }

        return tempUint;
    }

    function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) {
        require(_bytes.length >= _start + 4, "toUint32_outOfBounds");
        uint32 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x4), _start))
        }

        return tempUint;
    }

    function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) {
        require(_bytes.length >= _start + 8, "toUint64_outOfBounds");
        uint64 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x8), _start))
        }

        return tempUint;
    }

    function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96) {
        require(_bytes.length >= _start + 12, "toUint96_outOfBounds");
        uint96 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0xc), _start))
        }

        return tempUint;
    }

    function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128) {
        require(_bytes.length >= _start + 16, "toUint128_outOfBounds");
        uint128 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x10), _start))
        }

        return tempUint;
    }

    function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) {
        require(_bytes.length >= _start + 32, "toUint256_outOfBounds");
        uint256 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x20), _start))
        }

        return tempUint;
    }

    function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) {
        require(_bytes.length >= _start + 32, "toBytes32_outOfBounds");
        bytes32 tempBytes32;

        assembly {
            tempBytes32 := mload(add(add(_bytes, 0x20), _start))
        }

        return tempBytes32;
    }

    function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
        bool success = true;

        assembly {
            let length := mload(_preBytes)

            // if lengths don't match the arrays are not equal
            switch eq(length, mload(_postBytes))
            case 1 {
                // cb is a circuit breaker in the for loop since there's
                //  no said feature for inline assembly loops
                // cb = 1 - don't breaker
                // cb = 0 - break
                let cb := 1

                let mc := add(_preBytes, 0x20)
                let end := add(mc, length)

                for {
                    let cc := add(_postBytes, 0x20)
                // the next line is the loop condition:
                // while(uint256(mc < end) + cb == 2)
                } eq(add(lt(mc, end), cb), 2) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    // if any of these checks fails then arrays are not equal
                    if iszero(eq(mload(mc), mload(cc))) {
                        // unsuccess:
                        success := 0
                        cb := 0
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }

    function equalStorage(
        bytes storage _preBytes,
        bytes memory _postBytes
    )
        internal
        view
        returns (bool)
    {
        bool success = true;

        assembly {
            // we know _preBytes_offset is 0
            let fslot := sload(_preBytes.slot)
            // Decode the length of the stored array like in concatStorage().
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)

            // if lengths don't match the arrays are not equal
            switch eq(slength, mlength)
            case 1 {
                // slength can contain both the length and contents of the array
                // if length < 32 bytes so let's prepare for that
                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                if iszero(iszero(slength)) {
                    switch lt(slength, 32)
                    case 1 {
                        // blank the last byte which is the length
                        fslot := mul(div(fslot, 0x100), 0x100)

                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
                            // unsuccess:
                            success := 0
                        }
                    }
                    default {
                        // cb is a circuit breaker in the for loop since there's
                        //  no said feature for inline assembly loops
                        // cb = 1 - don't breaker
                        // cb = 0 - break
                        let cb := 1

                        // get the keccak hash to get the contents of the array
                        mstore(0x0, _preBytes.slot)
                        let sc := keccak256(0x0, 0x20)

                        let mc := add(_postBytes, 0x20)
                        let end := add(mc, mlength)

                        // the next line is the loop condition:
                        // while(uint256(mc < end) + cb == 2)
                        for {} eq(add(lt(mc, end), cb), 2) {
                            sc := add(sc, 1)
                            mc := add(mc, 0x20)
                        } {
                            if iszero(eq(sload(sc), mload(mc))) {
                                // unsuccess:
                                success := 0
                                cb := 0
                            }
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }
}

Settings
{
  "evmVersion": "paris",
  "optimizer": {
    "enabled": true,
    "runs": 20000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_endpoint","type":"address"},{"internalType":"uint256","name":"_treasuryGasLimit","type":"uint256"},{"internalType":"uint256","name":"_treasuryGasForFeeCap","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"DVN_InvalidDVNIdx","type":"error"},{"inputs":[{"internalType":"uint256","name":"cursor","type":"uint256"}],"name":"DVN_InvalidDVNOptions","type":"error"},{"inputs":[],"name":"LZ_MessageLib_CannotWithdrawAltToken","type":"error"},{"inputs":[{"internalType":"uint256","name":"requested","type":"uint256"},{"internalType":"uint256","name":"available","type":"uint256"}],"name":"LZ_MessageLib_InvalidAmount","type":"error"},{"inputs":[],"name":"LZ_MessageLib_InvalidExecutor","type":"error"},{"inputs":[{"internalType":"uint256","name":"actual","type":"uint256"},{"internalType":"uint256","name":"max","type":"uint256"}],"name":"LZ_MessageLib_InvalidMessageSize","type":"error"},{"inputs":[],"name":"LZ_MessageLib_NotTreasury","type":"error"},{"inputs":[],"name":"LZ_MessageLib_OnlyEndpoint","type":"error"},{"inputs":[],"name":"LZ_MessageLib_TransferFailed","type":"error"},{"inputs":[],"name":"LZ_MessageLib_ZeroMessageSize","type":"error"},{"inputs":[],"name":"LZ_ULN_AtLeastOneDVN","type":"error"},{"inputs":[{"internalType":"uint32","name":"configType","type":"uint32"}],"name":"LZ_ULN_InvalidConfigType","type":"error"},{"inputs":[],"name":"LZ_ULN_InvalidConfirmations","type":"error"},{"inputs":[],"name":"LZ_ULN_InvalidLegacyType1Option","type":"error"},{"inputs":[],"name":"LZ_ULN_InvalidLegacyType2Option","type":"error"},{"inputs":[],"name":"LZ_ULN_InvalidOptionalDVNCount","type":"error"},{"inputs":[],"name":"LZ_ULN_InvalidOptionalDVNThreshold","type":"error"},{"inputs":[],"name":"LZ_ULN_InvalidRequiredDVNCount","type":"error"},{"inputs":[{"internalType":"uint8","name":"workerId","type":"uint8"}],"name":"LZ_ULN_InvalidWorkerId","type":"error"},{"inputs":[{"internalType":"uint256","name":"cursor","type":"uint256"}],"name":"LZ_ULN_InvalidWorkerOptions","type":"error"},{"inputs":[],"name":"LZ_ULN_Unsorted","type":"error"},{"inputs":[{"internalType":"uint32","name":"eid","type":"uint32"}],"name":"LZ_ULN_UnsupportedEid","type":"error"},{"inputs":[{"internalType":"uint16","name":"optionType","type":"uint16"}],"name":"LZ_ULN_UnsupportedOptionType","type":"error"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"Transfer_NativeFailed","type":"error"},{"inputs":[],"name":"Transfer_ToAddressIsZero","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[]","name":"requiredDVNs","type":"address[]"},{"indexed":false,"internalType":"address[]","name":"optionalDVNs","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"fees","type":"uint256[]"}],"name":"DVNFeePaid","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"uint32","name":"eid","type":"uint32"},{"components":[{"internalType":"uint32","name":"maxMessageSize","type":"uint32"},{"internalType":"address","name":"executor","type":"address"}],"internalType":"struct ExecutorConfig","name":"config","type":"tuple"}],"indexed":false,"internalType":"struct SetDefaultExecutorConfigParam[]","name":"params","type":"tuple[]"}],"name":"DefaultExecutorConfigsSet","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"uint32","name":"eid","type":"uint32"},{"components":[{"internalType":"uint64","name":"confirmations","type":"uint64"},{"internalType":"uint8","name":"requiredDVNCount","type":"uint8"},{"internalType":"uint8","name":"optionalDVNCount","type":"uint8"},{"internalType":"uint8","name":"optionalDVNThreshold","type":"uint8"},{"internalType":"address[]","name":"requiredDVNs","type":"address[]"},{"internalType":"address[]","name":"optionalDVNs","type":"address[]"}],"internalType":"struct UlnConfig","name":"config","type":"tuple"}],"indexed":false,"internalType":"struct SetDefaultUlnConfigParam[]","name":"params","type":"tuple[]"}],"name":"DefaultUlnConfigsSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oapp","type":"address"},{"indexed":false,"internalType":"uint32","name":"eid","type":"uint32"},{"components":[{"internalType":"uint32","name":"maxMessageSize","type":"uint32"},{"internalType":"address","name":"executor","type":"address"}],"indexed":false,"internalType":"struct ExecutorConfig","name":"config","type":"tuple"}],"name":"ExecutorConfigSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"executor","type":"address"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"}],"name":"ExecutorFeePaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"lzToken","type":"address"},{"indexed":false,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LzTokenFeeWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"worker","type":"address"},{"indexed":false,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"NativeFeeWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newTreasuryNativeFeeCap","type":"uint256"}],"name":"TreasuryNativeFeeCapSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"treasury","type":"address"}],"name":"TreasurySet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oapp","type":"address"},{"indexed":false,"internalType":"uint32","name":"eid","type":"uint32"},{"components":[{"internalType":"uint64","name":"confirmations","type":"uint64"},{"internalType":"uint8","name":"requiredDVNCount","type":"uint8"},{"internalType":"uint8","name":"optionalDVNCount","type":"uint8"},{"internalType":"uint8","name":"optionalDVNThreshold","type":"uint8"},{"internalType":"address[]","name":"requiredDVNs","type":"address[]"},{"internalType":"address[]","name":"optionalDVNs","type":"address[]"}],"indexed":false,"internalType":"struct UlnConfig","name":"config","type":"tuple"}],"name":"UlnConfigSet","type":"event"},{"inputs":[{"internalType":"address","name":"oapp","type":"address"},{"internalType":"uint32","name":"eid","type":"uint32"}],"name":"executorConfigs","outputs":[{"internalType":"uint32","name":"maxMessageSize","type":"uint32"},{"internalType":"address","name":"executor","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"worker","type":"address"}],"name":"fees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_oapp","type":"address"},{"internalType":"uint32","name":"_remoteEid","type":"uint32"}],"name":"getAppUlnConfig","outputs":[{"components":[{"internalType":"uint64","name":"confirmations","type":"uint64"},{"internalType":"uint8","name":"requiredDVNCount","type":"uint8"},{"internalType":"uint8","name":"optionalDVNCount","type":"uint8"},{"internalType":"uint8","name":"optionalDVNThreshold","type":"uint8"},{"internalType":"address[]","name":"requiredDVNs","type":"address[]"},{"internalType":"address[]","name":"optionalDVNs","type":"address[]"}],"internalType":"struct UlnConfig","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"_eid","type":"uint32"},{"internalType":"address","name":"_oapp","type":"address"},{"internalType":"uint32","name":"_configType","type":"uint32"}],"name":"getConfig","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_oapp","type":"address"},{"internalType":"uint32","name":"_remoteEid","type":"uint32"}],"name":"getExecutorConfig","outputs":[{"components":[{"internalType":"uint32","name":"maxMessageSize","type":"uint32"},{"internalType":"address","name":"executor","type":"address"}],"internalType":"struct ExecutorConfig","name":"rtnConfig","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_oapp","type":"address"},{"internalType":"uint32","name":"_remoteEid","type":"uint32"}],"name":"getUlnConfig","outputs":[{"components":[{"internalType":"uint64","name":"confirmations","type":"uint64"},{"internalType":"uint8","name":"requiredDVNCount","type":"uint8"},{"internalType":"uint8","name":"optionalDVNCount","type":"uint8"},{"internalType":"uint8","name":"optionalDVNThreshold","type":"uint8"},{"internalType":"address[]","name":"requiredDVNs","type":"address[]"},{"internalType":"address[]","name":"optionalDVNs","type":"address[]"}],"internalType":"struct UlnConfig","name":"rtnConfig","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"_eid","type":"uint32"}],"name":"isSupportedEid","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"messageLibType","outputs":[{"internalType":"enum MessageLibType","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint64","name":"nonce","type":"uint64"},{"internalType":"uint32","name":"srcEid","type":"uint32"},{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint32","name":"dstEid","type":"uint32"},{"internalType":"bytes32","name":"receiver","type":"bytes32"},{"internalType":"bytes32","name":"guid","type":"bytes32"},{"internalType":"bytes","name":"message","type":"bytes"}],"internalType":"struct Packet","name":"_packet","type":"tuple"},{"internalType":"bytes","name":"_options","type":"bytes"},{"internalType":"bool","name":"_payInLzToken","type":"bool"}],"name":"quote","outputs":[{"components":[{"internalType":"uint256","name":"nativeFee","type":"uint256"},{"internalType":"uint256","name":"lzTokenFee","type":"uint256"}],"internalType":"struct MessagingFee","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint64","name":"nonce","type":"uint64"},{"internalType":"uint32","name":"srcEid","type":"uint32"},{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint32","name":"dstEid","type":"uint32"},{"internalType":"bytes32","name":"receiver","type":"bytes32"},{"internalType":"bytes32","name":"guid","type":"bytes32"},{"internalType":"bytes","name":"message","type":"bytes"}],"internalType":"struct Packet","name":"_packet","type":"tuple"},{"internalType":"bytes","name":"_options","type":"bytes"},{"internalType":"bool","name":"_payInLzToken","type":"bool"}],"name":"send","outputs":[{"components":[{"internalType":"uint256","name":"nativeFee","type":"uint256"},{"internalType":"uint256","name":"lzTokenFee","type":"uint256"}],"internalType":"struct MessagingFee","name":"","type":"tuple"},{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_oapp","type":"address"},{"components":[{"internalType":"uint32","name":"eid","type":"uint32"},{"internalType":"uint32","name":"configType","type":"uint32"},{"internalType":"bytes","name":"config","type":"bytes"}],"internalType":"struct SetConfigParam[]","name":"_params","type":"tuple[]"}],"name":"setConfig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint32","name":"eid","type":"uint32"},{"components":[{"internalType":"uint32","name":"maxMessageSize","type":"uint32"},{"internalType":"address","name":"executor","type":"address"}],"internalType":"struct ExecutorConfig","name":"config","type":"tuple"}],"internalType":"struct SetDefaultExecutorConfigParam[]","name":"_params","type":"tuple[]"}],"name":"setDefaultExecutorConfigs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint32","name":"eid","type":"uint32"},{"components":[{"internalType":"uint64","name":"confirmations","type":"uint64"},{"internalType":"uint8","name":"requiredDVNCount","type":"uint8"},{"internalType":"uint8","name":"optionalDVNCount","type":"uint8"},{"internalType":"uint8","name":"optionalDVNThreshold","type":"uint8"},{"internalType":"address[]","name":"requiredDVNs","type":"address[]"},{"internalType":"address[]","name":"optionalDVNs","type":"address[]"}],"internalType":"struct UlnConfig","name":"config","type":"tuple"}],"internalType":"struct SetDefaultUlnConfigParam[]","name":"_params","type":"tuple[]"}],"name":"setDefaultUlnConfigs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newTreasuryNativeFeeCap","type":"uint256"}],"name":"setTreasuryNativeFeeCap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"_interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"uint64","name":"major","type":"uint64"},{"internalType":"uint8","name":"minor","type":"uint8"},{"internalType":"uint8","name":"endpointVersion","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_lzToken","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawLzTokenFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000001a44076050125825900e736c501f859c50fe728c0000000000000000000000000000000000000000000000000000000000030d4000000000000000000000000000000000000000000000000000019945ca262000

-----Decoded View---------------
Arg [0] : _endpoint (address): 0x1a44076050125825900e736c501f859c50fE728c
Arg [1] : _treasuryGasLimit (uint256): 200000
Arg [2] : _treasuryGasForFeeCap (uint256): 450000000000000

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000001a44076050125825900e736c501f859c50fe728c
Arg [1] : 0000000000000000000000000000000000000000000000000000000000030d40
Arg [2] : 00000000000000000000000000000000000000000000000000019945ca262000


Block Transaction Gas Used Reward
view all blocks sequenced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
[ Download: CSV Export  ]
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.