Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// File: contracts\openzeppelin\contracts\token\ERC20\IERC20.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 value) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}
// File: contracts\openzeppelin\contracts\interfaces\IERC20.sol
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)
pragma solidity ^0.8.19;
// File: contracts\openzeppelin\contracts\utils\introspection\IERC165.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)
pragma solidity ^0.8.19;
/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * 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[ERC 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: contracts\openzeppelin\contracts\interfaces\IERC165.sol
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)
pragma solidity ^0.8.19;
// File: contracts\openzeppelin\contracts\interfaces\IERC1363.sol
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1363.sol)
pragma solidity ^0.8.19;
/**
 * @title IERC1363
 * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
 *
 * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
 * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
 */
interface IERC1363 is IERC20, IERC165 {
    /*
     * Note: the ERC-165 identifier for this interface is 0xb0202a11.
     * 0xb0202a11 ===
     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
     */
    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value) external returns (bool);
    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value) external returns (bool);
    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @param data Additional data with no specified format, sent in call to `spender`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}
// File: contracts\openzeppelin\contracts\utils\Errors.sol
pragma solidity ^0.8.19;
/**
 * @dev Collection of common custom errors used in multiple contracts
 *
 * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.
 * It is recommended to avoid relying on the error API for critical functionality.
 */
library Errors {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error InsufficientBalance(uint256 balance, uint256 needed);
    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedCall();
    /**
     * @dev The deployment failed.
     */
    error FailedDeployment();
    /**
     * @dev A necessary precompile is missing.
     */
    error MissingPrecompile(address);
}
// File: contracts\openzeppelin\contracts\utils\Address.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)
pragma solidity ^0.8.19;
/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);
    /**
     * @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.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert Errors.InsufficientBalance(address(this).balance, amount);
        }
        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert Errors.FailedCall();
        }
    }
    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {Errors.FailedCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }
    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert Errors.InsufficientBalance(address(this).balance, value);
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }
    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }
    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }
    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case
     * of an unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }
    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {Errors.FailedCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }
    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {Errors.FailedCall}.
     */
    function _revert(bytes memory returndata) 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
            assembly ("memory-safe") {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert Errors.FailedCall();
        }
    }
}
// File: contracts\openzeppelin\contracts\token\ERC20\utils\SafeERC20.sol
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.19;
/**
 * @title SafeERC20
 * @dev Wrappers around ERC-20 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 {
    /**
     * @dev An operation with an ERC-20 token failed.
     */
    error SafeERC20FailedOperation(address token);
    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
    /**
     * @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.encodeCall(token.transfer, (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.encodeCall(token.transferFrom, (from, to, 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);
        forceApprove(token, spender, oldAllowance + value);
    }
    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }
    /**
     * @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.encodeCall(token.approve, (spender, value));
        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }
    /**
     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            safeTransfer(token, to, value);
        } else if (!token.transferAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }
    /**
     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferFromAndCallRelaxed(
        IERC1363 token,
        address from,
        address to,
        uint256 value,
        bytes memory data
    ) internal {
        if (to.code.length == 0) {
            safeTransferFrom(token, from, to, value);
        } else if (!token.transferFromAndCall(from, to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }
    /**
     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
     * once without retrying, and relies on the returned value to be true.
     *
     * Reverts if the returned value is other than `true`.
     */
    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            forceApprove(token, to, value);
        } else if (!token.approveAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }
    /**
     * @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 {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            // bubble errors
            if iszero(success) {
                let ptr := mload(0x40)
                returndatacopy(ptr, 0, returndatasize())
                revert(ptr, returndatasize())
            }
            returnSize := returndatasize()
            returnValue := mload(0)
        }
        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
            revert SafeERC20FailedOperation(address(token));
        }
    }
    /**
     * @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 silently catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        bool success;
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            returnSize := returndatasize()
            returnValue := mload(0)
        }
        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
    }
}
// File: contracts\Layerzero\lz-evm-protocol-v2\contracts\interfaces\IMessageLibManager.sol
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 _gracePeriod) 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 _expiry) 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: contracts\Layerzero\lz-evm-protocol-v2\contracts\interfaces\IMessagingComposer.sol
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: contracts\Layerzero\lz-evm-protocol-v2\contracts\interfaces\IMessagingChannel.sol
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: contracts\Layerzero\lz-evm-protocol-v2\contracts\interfaces\IMessagingContext.sol
pragma solidity >=0.8.0;
interface IMessagingContext {
    function isSendingMessage() external view returns (bool);
    function getSendContext() external view returns (uint32 dstEid, address sender);
}
// File: contracts\Layerzero\lz-evm-protocol-v2\contracts\interfaces\ILayerZeroEndpointV2.sol
pragma solidity >=0.8.0;
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: contracts\openzeppelin\contracts\utils\Context.sol
pragma solidity ^0.8.19;
/**
 * @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: contracts\openzeppelin\contracts\access\Ownable.sol
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
pragma solidity ^0.8.19;
/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. 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;
    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);
    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }
    /**
     * @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 {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }
    /**
     * @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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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: contracts\Layerzero\oapp-evm\contracts\oapp\interfaces\IOAppCore.sol
pragma solidity ^0.8.19;
/**
 * @title IOAppCore
 */
interface IOAppCore {
    // Custom error messages
    error OnlyPeer(uint32 eid, bytes32 sender);
    error NoPeer(uint32 eid);
    error InvalidEndpointCall();
    error InvalidDelegate();
    // Event emitted when a peer (OApp) is set for a corresponding endpoint
    event PeerSet(uint32 eid, bytes32 peer);
    /**
     * @notice Retrieves the OApp version information.
     * @return senderVersion The version of the OAppSender.sol contract.
     * @return receiverVersion The version of the OAppReceiver.sol contract.
     */
    function oAppVersion() external view returns (uint64 senderVersion, uint64 receiverVersion);
    /**
     * @notice Retrieves the LayerZero endpoint associated with the OApp.
     * @return iEndpoint The LayerZero endpoint as an interface.
     */
    function endpoint() external view returns (ILayerZeroEndpointV2 iEndpoint);
    /**
     * @notice Retrieves the peer (OApp) associated with a corresponding endpoint.
     * @param _eid The endpoint ID.
     * @return peer The peer address (OApp instance) associated with the corresponding endpoint.
     */
    function peers(uint32 _eid) external view returns (bytes32 peer);
    /**
     * @notice Sets the peer address (OApp instance) for a corresponding endpoint.
     * @param _eid The endpoint ID.
     * @param _peer The address of the peer to be associated with the corresponding endpoint.
     */
    function setPeer(uint32 _eid, bytes32 _peer) external;
    /**
     * @notice Sets the delegate address for the OApp Core.
     * @param _delegate The address of the delegate to be set.
     */
    function setDelegate(address _delegate) external;
}
// File: contracts\Layerzero\oapp-evm\contracts\oapp\OAppCore.sol
pragma solidity ^0.8.19;
/**
 * @title OAppCore
 * @dev Abstract contract implementing the IOAppCore interface with basic OApp configurations.
 */
abstract contract OAppCore is IOAppCore, Ownable {
    // The LayerZero endpoint associated with the given OApp
    ILayerZeroEndpointV2 public immutable endpoint;
    // Mapping to store peers associated with corresponding endpoints
    mapping(uint32 eid => bytes32 peer) public peers;
    /**
     * @dev Constructor to initialize the OAppCore with the provided endpoint and delegate.
     * @param _endpoint The address of the LOCAL Layer Zero endpoint.
     * @param _delegate The delegate capable of making OApp configurations inside of the endpoint.
     *
     * @dev The delegate typically should be set as the owner of the contract.
     */
    constructor(address _endpoint, address _delegate) {
        endpoint = ILayerZeroEndpointV2(_endpoint);
        if (_delegate == address(0)) revert InvalidDelegate();
        endpoint.setDelegate(_delegate);
    }
    /**
     * @notice Sets the peer address (OApp instance) for a corresponding endpoint.
     * @param _eid The endpoint ID.
     * @param _peer The address of the peer to be associated with the corresponding endpoint.
     *
     * @dev Only the owner/admin of the OApp can call this function.
     * @dev Indicates that the peer is trusted to send LayerZero messages to this OApp.
     * @dev Set this to bytes32(0) to remove the peer address.
     * @dev Peer is a bytes32 to accommodate non-evm chains.
     */
    function setPeer(uint32 _eid, bytes32 _peer) public virtual onlyOwner {
        _setPeer(_eid, _peer);
    }
    /**
     * @notice Sets the peer address (OApp instance) for a corresponding endpoint.
     * @param _eid The endpoint ID.
     * @param _peer The address of the peer to be associated with the corresponding endpoint.
     *
     * @dev Indicates that the peer is trusted to send LayerZero messages to this OApp.
     * @dev Set this to bytes32(0) to remove the peer address.
     * @dev Peer is a bytes32 to accommodate non-evm chains.
     */
    function _setPeer(uint32 _eid, bytes32 _peer) internal virtual {
        peers[_eid] = _peer;
        emit PeerSet(_eid, _peer);
    }
    /**
     * @notice Internal function to get the peer address associated with a specific endpoint; reverts if NOT set.
     * ie. the peer is set to bytes32(0).
     * @param _eid The endpoint ID.
     * @return peer The address of the peer associated with the specified endpoint.
     */
    function _getPeerOrRevert(uint32 _eid) internal view virtual returns (bytes32) {
        bytes32 peer = peers[_eid];
        if (peer == bytes32(0)) revert NoPeer(_eid);
        return peer;
    }
    /**
     * @notice Sets the delegate address for the OApp.
     * @param _delegate The address of the delegate to be set.
     *
     * @dev Only the owner/admin of the OApp can call this function.
     * @dev Provides the ability for a delegate to set configs, on behalf of the OApp, directly on the Endpoint contract.
     */
    function setDelegate(address _delegate) public onlyOwner {
        endpoint.setDelegate(_delegate);
    }
}
// File: contracts\Layerzero\oapp-evm\contracts\oapp\OAppSender.sol
pragma solidity ^0.8.19;
/**
 * @title OAppSender
 * @dev Abstract contract implementing the OAppSender functionality for sending messages to a LayerZero endpoint.
 */
abstract contract OAppSender is OAppCore {
    using SafeERC20 for IERC20;
    // Custom error messages
    error NotEnoughNative(uint256 msgValue);
    error LzTokenUnavailable();
    // @dev The version of the OAppSender implementation.
    // @dev Version is bumped when changes are made to this contract.
    uint64 internal constant SENDER_VERSION = 1;
    /**
     * @notice Retrieves the OApp version information.
     * @return senderVersion The version of the OAppSender.sol contract.
     * @return receiverVersion The version of the OAppReceiver.sol contract.
     *
     * @dev Providing 0 as the default for OAppReceiver version. Indicates that the OAppReceiver is not implemented.
     * ie. this is a SEND only OApp.
     * @dev If the OApp uses both OAppSender and OAppReceiver, then this needs to be override returning the correct versions
     */
    function oAppVersion() public view virtual returns (uint64 senderVersion, uint64 receiverVersion) {
        return (SENDER_VERSION, 0);
    }
    /**
     * @dev Internal function to interact with the LayerZero EndpointV2.quote() for fee calculation.
     * @param _dstEid The destination endpoint ID.
     * @param _message The message payload.
     * @param _options Additional options for the message.
     * @param _payInLzToken Flag indicating whether to pay the fee in LZ tokens.
     * @return fee The calculated MessagingFee for the message.
     *      - nativeFee: The native fee for the message.
     *      - lzTokenFee: The LZ token fee for the message.
     */
    function _quote(
        uint32 _dstEid,
        bytes memory _message,
        bytes memory _options,
        bool _payInLzToken
    ) internal view virtual returns (MessagingFee memory fee) {
        return
            endpoint.quote(
                MessagingParams(_dstEid, _getPeerOrRevert(_dstEid), _message, _options, _payInLzToken),
                address(this)
            );
    }
    /**
     * @dev Internal function to interact with the LayerZero EndpointV2.send() for sending a message.
     * @param _dstEid The destination endpoint ID.
     * @param _message The message payload.
     * @param _options Additional options for the message.
     * @param _fee The calculated LayerZero fee for the message.
     *      - nativeFee: The native fee.
     *      - lzTokenFee: The lzToken fee.
     * @param _refundAddress The address to receive any excess fee values sent to the endpoint.
     * @return receipt The receipt for the sent message.
     *      - guid: The unique identifier for the sent message.
     *      - nonce: The nonce of the sent message.
     *      - fee: The LayerZero fee incurred for the message.
     */
    function _lzSend(
        uint32 _dstEid,
        bytes memory _message,
        bytes memory _options,
        MessagingFee memory _fee,
        address _refundAddress
    ) internal virtual returns (MessagingReceipt memory receipt) {
        // @dev Push corresponding fees to the endpoint, any excess is sent back to the _refundAddress from the endpoint.
        uint256 messageValue = _payNative(_fee.nativeFee);
        if (_fee.lzTokenFee > 0) _payLzToken(_fee.lzTokenFee);
        return
            // solhint-disable-next-line check-send-result
            endpoint.send{ value: messageValue }(
                MessagingParams(_dstEid, _getPeerOrRevert(_dstEid), _message, _options, _fee.lzTokenFee > 0),
                _refundAddress
            );
    }
    /**
     * @dev Internal function to pay the native fee associated with the message.
     * @param _nativeFee The native fee to be paid.
     * @return nativeFee The amount of native currency paid.
     *
     * @dev If the OApp needs to initiate MULTIPLE LayerZero messages in a single transaction,
     * this will need to be overridden because msg.value would contain multiple lzFees.
     * @dev Should be overridden in the event the LayerZero endpoint requires a different native currency.
     * @dev Some EVMs use an ERC20 as a method for paying transactions/gasFees.
     * @dev The endpoint is EITHER/OR, ie. it will NOT support both types of native payment at a time.
     */
    function _payNative(uint256 _nativeFee) internal virtual returns (uint256 nativeFee) {
        if (msg.value != _nativeFee) revert NotEnoughNative(msg.value);
        return _nativeFee;
    }
    /**
     * @dev Internal function to pay the LZ token fee associated with the message.
     * @param _lzTokenFee The LZ token fee to be paid.
     *
     * @dev If the caller is trying to pay in the specified lzToken, then the lzTokenFee is passed to the endpoint.
     * @dev Any excess sent, is passed back to the specified _refundAddress in the _lzSend().
     */
    function _payLzToken(uint256 _lzTokenFee) internal virtual {
        // @dev Cannot cache the token because it is not immutable in the endpoint.
        address lzToken = endpoint.lzToken();
        if (lzToken == address(0)) revert LzTokenUnavailable();
        // Pay LZ token fee by sending tokens to the endpoint.
        IERC20(lzToken).safeTransferFrom(msg.sender, address(endpoint), _lzTokenFee);
    }
}
// File: contracts\Layerzero\lz-evm-protocol-v2\contracts\interfaces\ILayerZeroReceiver.sol
pragma solidity >=0.8.0;
interface ILayerZeroReceiver {
    function allowInitializePath(Origin calldata _origin) external view returns (bool);
    function nextNonce(uint32 _eid, bytes32 _sender) external view returns (uint64);
    function lzReceive(
        Origin calldata _origin,
        bytes32 _guid,
        bytes calldata _message,
        address _executor,
        bytes calldata _extraData
    ) external payable;
}
// File: contracts\Layerzero\oapp-evm\contracts\oapp\interfaces\IOAppReceiver.sol
pragma solidity ^0.8.19;
interface IOAppReceiver is ILayerZeroReceiver {
    /**
     * @notice Indicates whether an address is an approved composeMsg sender to the Endpoint.
     * @param _origin The origin information containing the source endpoint and sender address.
     *  - srcEid: The source chain endpoint ID.
     *  - sender: The sender address on the src chain.
     *  - nonce: The nonce of the message.
     * @param _message The lzReceive payload.
     * @param _sender The sender address.
     * @return isSender Is a valid sender.
     *
     * @dev Applications can optionally choose to implement a separate composeMsg sender that is NOT the bridging layer.
     * @dev The default sender IS the OAppReceiver implementer.
     */
    function isComposeMsgSender(
        Origin calldata _origin,
        bytes calldata _message,
        address _sender
    ) external view returns (bool isSender);
}
// File: contracts\Layerzero\oapp-evm\contracts\oapp\OAppReceiver.sol
pragma solidity ^0.8.19;
/**
 * @title OAppReceiver
 * @dev Abstract contract implementing the ILayerZeroReceiver interface and extending OAppCore for OApp receivers.
 */
abstract contract OAppReceiver is IOAppReceiver, OAppCore {
    // Custom error message for when the caller is not the registered endpoint/
    error OnlyEndpoint(address addr);
    // @dev The version of the OAppReceiver implementation.
    // @dev Version is bumped when changes are made to this contract.
    uint64 internal constant RECEIVER_VERSION = 2;
    /**
     * @notice Retrieves the OApp version information.
     * @return senderVersion The version of the OAppSender.sol contract.
     * @return receiverVersion The version of the OAppReceiver.sol contract.
     *
     * @dev Providing 0 as the default for OAppSender version. Indicates that the OAppSender is not implemented.
     * ie. this is a RECEIVE only OApp.
     * @dev If the OApp uses both OAppSender and OAppReceiver, then this needs to be override returning the correct versions.
     */
    function oAppVersion() public view virtual returns (uint64 senderVersion, uint64 receiverVersion) {
        return (0, RECEIVER_VERSION);
    }
    /**
     * @notice Indicates whether an address is an approved composeMsg sender to the Endpoint.
     * @dev _origin The origin information containing the source endpoint and sender address.
     *  - srcEid: The source chain endpoint ID.
     *  - sender: The sender address on the src chain.
     *  - nonce: The nonce of the message.
     * @dev _message The lzReceive payload.
     * @param _sender The sender address.
     * @return isSender Is a valid sender.
     *
     * @dev Applications can optionally choose to implement separate composeMsg senders that are NOT the bridging layer.
     * @dev The default sender IS the OAppReceiver implementer.
     */
    function isComposeMsgSender(
        Origin calldata /*_origin*/,
        bytes calldata /*_message*/,
        address _sender
    ) public view virtual returns (bool) {
        return _sender == address(this);
    }
    /**
     * @notice Checks if the path initialization is allowed based on the provided origin.
     * @param origin The origin information containing the source endpoint and sender address.
     * @return Whether the path has been initialized.
     *
     * @dev This indicates to the endpoint that the OApp has enabled msgs for this particular path to be received.
     * @dev This defaults to assuming if a peer has been set, its initialized.
     * Can be overridden by the OApp if there is other logic to determine this.
     */
    function allowInitializePath(Origin calldata origin) public view virtual returns (bool) {
        return peers[origin.srcEid] == origin.sender;
    }
    /**
     * @notice Retrieves the next nonce for a given source endpoint and sender address.
     * @dev _srcEid The source endpoint ID.
     * @dev _sender The sender address.
     * @return nonce The next nonce.
     *
     * @dev The path nonce starts from 1. If 0 is returned it means that there is NO nonce ordered enforcement.
     * @dev Is required by the off-chain executor to determine the OApp expects msg execution is ordered.
     * @dev This is also enforced by the OApp.
     * @dev By default this is NOT enabled. ie. nextNonce is hardcoded to return 0.
     */
    function nextNonce(uint32 /*_srcEid*/, bytes32 /*_sender*/) public view virtual returns (uint64 nonce) {
        return 0;
    }
    /**
     * @dev Entry point for receiving messages or packets from the endpoint.
     * @param _origin The origin information containing the source endpoint and sender address.
     *  - srcEid: The source chain endpoint ID.
     *  - sender: The sender address on the src chain.
     *  - nonce: The nonce of the message.
     * @param _guid The unique identifier for the received LayerZero message.
     * @param _message The payload of the received message.
     * @param _executor The address of the executor for the received message.
     * @param _extraData Additional arbitrary data provided by the corresponding executor.
     *
     * @dev Entry point for receiving msg/packet from the LayerZero endpoint.
     */
    function lzReceive(
        Origin calldata _origin,
        bytes32 _guid,
        bytes calldata _message,
        address _executor,
        bytes calldata _extraData
    ) public payable virtual {
        // Ensures that only the endpoint can attempt to lzReceive() messages to this OApp.
        if (address(endpoint) != msg.sender) revert OnlyEndpoint(msg.sender);
        // Ensure that the sender matches the expected peer for the source endpoint.
        if (_getPeerOrRevert(_origin.srcEid) != _origin.sender) revert OnlyPeer(_origin.srcEid, _origin.sender);
        // Call the internal OApp implementation of lzReceive.
        _lzReceive(_origin, _guid, _message, _executor, _extraData);
    }
    /**
     * @dev Internal function to implement lzReceive logic without needing to copy the basic parameter validation.
     */
    function _lzReceive(
        Origin calldata _origin,
        bytes32 _guid,
        bytes calldata _message,
        address _executor,
        bytes calldata _extraData
    ) internal virtual;
}
// File: contracts\Layerzero\oapp-evm\contracts\oapp\OApp.sol
pragma solidity ^0.8.19;
// @dev Import the 'MessagingFee' and 'MessagingReceipt' so it's exposed to OApp implementers
// solhint-disable-next-line no-unused-import
// @dev Import the 'Origin' so it's exposed to OApp implementers
// solhint-disable-next-line no-unused-import
/**
 * @title OApp
 * @dev Abstract contract serving as the base for OApp implementation, combining OAppSender and OAppReceiver functionality.
 */
abstract contract OApp is OAppSender, OAppReceiver {
    /**
     * @dev Constructor to initialize the OApp with the provided endpoint and owner.
     * @param _endpoint The address of the LOCAL LayerZero endpoint.
     * @param _delegate The delegate capable of making OApp configurations inside of the endpoint.
     */
    constructor(address _endpoint, address _delegate) OAppCore(_endpoint, _delegate) {}
    /**
     * @notice Retrieves the OApp version information.
     * @return senderVersion The version of the OAppSender.sol implementation.
     * @return receiverVersion The version of the OAppReceiver.sol implementation.
     */
    function oAppVersion()
        public
        pure
        virtual
        override(OAppSender, OAppReceiver)
        returns (uint64 senderVersion, uint64 receiverVersion)
    {
        return (SENDER_VERSION, RECEIVER_VERSION);
    }
}
// File: contracts\solidity-bytes-utils\contracts\BytesLib.sol
/*
 * @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 equal_nonAligned(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 endMinusWord := add(_preBytes, length)
                let mc := add(_preBytes, 0x20)
                let cc := add(_postBytes, 0x20)
                for {
                // the next line is the loop condition:
                // while(uint256(mc < endWord) + cb == 2)
                } eq(add(lt(mc, endMinusWord), 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
                    }
                }
                // Only if still successful
                // For <1 word tail bytes
                if gt(success, 0) {
                    // Get the remainder of length/32
                    // length % 32 = AND(length, 32 - 1)
                    let numTailBytes := and(length, 0x1f)
                    let mcRem := mload(mc)
                    let ccRem := mload(cc)
                    for {
                        let i := 0
                    // the next line is the loop condition:
                    // while(uint256(i < numTailBytes) + cb == 2)
                    } eq(add(lt(i, numTailBytes), cb), 2) {
                        i := add(i, 1)
                    } {
                        if iszero(eq(byte(i, mcRem), byte(i, ccRem))) {
                            // 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;
    }
}
// File: contracts\openzeppelin\contracts\utils\math\SafeCast.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
pragma solidity ^0.8.19;
/**
 * @dev Wrappers over Solidity's uintXX/intXX/bool 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.
 */
library SafeCast {
    /**
     * @dev Value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
    /**
     * @dev An int value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedIntToUint(int256 value);
    /**
     * @dev Value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);
    /**
     * @dev An uint value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedUintToInt(uint256 value);
    /**
     * @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
     */
    function toUint248(uint256 value) internal pure returns (uint248) {
        if (value > type(uint248).max) {
            revert SafeCastOverflowedUintDowncast(248, value);
        }
        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
     */
    function toUint240(uint256 value) internal pure returns (uint240) {
        if (value > type(uint240).max) {
            revert SafeCastOverflowedUintDowncast(240, value);
        }
        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
     */
    function toUint232(uint256 value) internal pure returns (uint232) {
        if (value > type(uint232).max) {
            revert SafeCastOverflowedUintDowncast(232, value);
        }
        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
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        if (value > type(uint224).max) {
            revert SafeCastOverflowedUintDowncast(224, value);
        }
        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
     */
    function toUint216(uint256 value) internal pure returns (uint216) {
        if (value > type(uint216).max) {
            revert SafeCastOverflowedUintDowncast(216, value);
        }
        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
     */
    function toUint208(uint256 value) internal pure returns (uint208) {
        if (value > type(uint208).max) {
            revert SafeCastOverflowedUintDowncast(208, value);
        }
        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
     */
    function toUint200(uint256 value) internal pure returns (uint200) {
        if (value > type(uint200).max) {
            revert SafeCastOverflowedUintDowncast(200, value);
        }
        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
     */
    function toUint192(uint256 value) internal pure returns (uint192) {
        if (value > type(uint192).max) {
            revert SafeCastOverflowedUintDowncast(192, value);
        }
        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
     */
    function toUint184(uint256 value) internal pure returns (uint184) {
        if (value > type(uint184).max) {
            revert SafeCastOverflowedUintDowncast(184, value);
        }
        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
     */
    function toUint176(uint256 value) internal pure returns (uint176) {
        if (value > type(uint176).max) {
            revert SafeCastOverflowedUintDowncast(176, value);
        }
        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
     */
    function toUint168(uint256 value) internal pure returns (uint168) {
        if (value > type(uint168).max) {
            revert SafeCastOverflowedUintDowncast(168, value);
        }
        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
     */
    function toUint160(uint256 value) internal pure returns (uint160) {
        if (value > type(uint160).max) {
            revert SafeCastOverflowedUintDowncast(160, value);
        }
        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
     */
    function toUint152(uint256 value) internal pure returns (uint152) {
        if (value > type(uint152).max) {
            revert SafeCastOverflowedUintDowncast(152, value);
        }
        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
     */
    function toUint144(uint256 value) internal pure returns (uint144) {
        if (value > type(uint144).max) {
            revert SafeCastOverflowedUintDowncast(144, value);
        }
        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
     */
    function toUint136(uint256 value) internal pure returns (uint136) {
        if (value > type(uint136).max) {
            revert SafeCastOverflowedUintDowncast(136, value);
        }
        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
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        if (value > type(uint128).max) {
            revert SafeCastOverflowedUintDowncast(128, value);
        }
        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
     */
    function toUint120(uint256 value) internal pure returns (uint120) {
        if (value > type(uint120).max) {
            revert SafeCastOverflowedUintDowncast(120, value);
        }
        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
     */
    function toUint112(uint256 value) internal pure returns (uint112) {
        if (value > type(uint112).max) {
            revert SafeCastOverflowedUintDowncast(112, value);
        }
        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
     */
    function toUint104(uint256 value) internal pure returns (uint104) {
        if (value > type(uint104).max) {
            revert SafeCastOverflowedUintDowncast(104, value);
        }
        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
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        if (value > type(uint96).max) {
            revert SafeCastOverflowedUintDowncast(96, value);
        }
        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
     */
    function toUint88(uint256 value) internal pure returns (uint88) {
        if (value > type(uint88).max) {
            revert SafeCastOverflowedUintDowncast(88, value);
        }
        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
     */
    function toUint80(uint256 value) internal pure returns (uint80) {
        if (value > type(uint80).max) {
            revert SafeCastOverflowedUintDowncast(80, value);
        }
        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
     */
    function toUint72(uint256 value) internal pure returns (uint72) {
        if (value > type(uint72).max) {
            revert SafeCastOverflowedUintDowncast(72, value);
        }
        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
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        if (value > type(uint64).max) {
            revert SafeCastOverflowedUintDowncast(64, value);
        }
        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
     */
    function toUint56(uint256 value) internal pure returns (uint56) {
        if (value > type(uint56).max) {
            revert SafeCastOverflowedUintDowncast(56, value);
        }
        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
     */
    function toUint48(uint256 value) internal pure returns (uint48) {
        if (value > type(uint48).max) {
            revert SafeCastOverflowedUintDowncast(48, value);
        }
        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
     */
    function toUint40(uint256 value) internal pure returns (uint40) {
        if (value > type(uint40).max) {
            revert SafeCastOverflowedUintDowncast(40, value);
        }
        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
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        if (value > type(uint32).max) {
            revert SafeCastOverflowedUintDowncast(32, value);
        }
        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
     */
    function toUint24(uint256 value) internal pure returns (uint24) {
        if (value > type(uint24).max) {
            revert SafeCastOverflowedUintDowncast(24, value);
        }
        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
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        if (value > type(uint16).max) {
            revert SafeCastOverflowedUintDowncast(16, value);
        }
        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
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        if (value > type(uint8).max) {
            revert SafeCastOverflowedUintDowncast(8, value);
        }
        return uint8(value);
    }
    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        if (value < 0) {
            revert SafeCastOverflowedIntToUint(value);
        }
        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
     */
    function toInt248(int256 value) internal pure returns (int248 downcasted) {
        downcasted = int248(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(248, value);
        }
    }
    /**
     * @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
     */
    function toInt240(int256 value) internal pure returns (int240 downcasted) {
        downcasted = int240(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(240, value);
        }
    }
    /**
     * @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
     */
    function toInt232(int256 value) internal pure returns (int232 downcasted) {
        downcasted = int232(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(232, value);
        }
    }
    /**
     * @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
     */
    function toInt224(int256 value) internal pure returns (int224 downcasted) {
        downcasted = int224(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(224, value);
        }
    }
    /**
     * @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
     */
    function toInt216(int256 value) internal pure returns (int216 downcasted) {
        downcasted = int216(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(216, value);
        }
    }
    /**
     * @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
     */
    function toInt208(int256 value) internal pure returns (int208 downcasted) {
        downcasted = int208(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(208, value);
        }
    }
    /**
     * @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
     */
    function toInt200(int256 value) internal pure returns (int200 downcasted) {
        downcasted = int200(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(200, value);
        }
    }
    /**
     * @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
     */
    function toInt192(int256 value) internal pure returns (int192 downcasted) {
        downcasted = int192(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(192, value);
        }
    }
    /**
     * @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
     */
    function toInt184(int256 value) internal pure returns (int184 downcasted) {
        downcasted = int184(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(184, value);
        }
    }
    /**
     * @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
     */
    function toInt176(int256 value) internal pure returns (int176 downcasted) {
        downcasted = int176(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(176, value);
        }
    }
    /**
     * @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
     */
    function toInt168(int256 value) internal pure returns (int168 downcasted) {
        downcasted = int168(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(168, value);
        }
    }
    /**
     * @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
     */
    function toInt160(int256 value) internal pure returns (int160 downcasted) {
        downcasted = int160(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(160, value);
        }
    }
    /**
     * @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
     */
    function toInt152(int256 value) internal pure returns (int152 downcasted) {
        downcasted = int152(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(152, value);
        }
    }
    /**
     * @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
     */
    function toInt144(int256 value) internal pure returns (int144 downcasted) {
        downcasted = int144(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(144, value);
        }
    }
    /**
     * @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
     */
    function toInt136(int256 value) internal pure returns (int136 downcasted) {
        downcasted = int136(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(136, value);
        }
    }
    /**
     * @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
     */
    function toInt128(int256 value) internal pure returns (int128 downcasted) {
        downcasted = int128(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(128, value);
        }
    }
    /**
     * @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
     */
    function toInt120(int256 value) internal pure returns (int120 downcasted) {
        downcasted = int120(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(120, value);
        }
    }
    /**
     * @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
     */
    function toInt112(int256 value) internal pure returns (int112 downcasted) {
        downcasted = int112(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(112, value);
        }
    }
    /**
     * @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
     */
    function toInt104(int256 value) internal pure returns (int104 downcasted) {
        downcasted = int104(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(104, value);
        }
    }
    /**
     * @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
     */
    function toInt96(int256 value) internal pure returns (int96 downcasted) {
        downcasted = int96(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(96, value);
        }
    }
    /**
     * @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
     */
    function toInt88(int256 value) internal pure returns (int88 downcasted) {
        downcasted = int88(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(88, value);
        }
    }
    /**
     * @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
     */
    function toInt80(int256 value) internal pure returns (int80 downcasted) {
        downcasted = int80(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(80, value);
        }
    }
    /**
     * @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
     */
    function toInt72(int256 value) internal pure returns (int72 downcasted) {
        downcasted = int72(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(72, value);
        }
    }
    /**
     * @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
     */
    function toInt64(int256 value) internal pure returns (int64 downcasted) {
        downcasted = int64(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(64, value);
        }
    }
    /**
     * @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
     */
    function toInt56(int256 value) internal pure returns (int56 downcasted) {
        downcasted = int56(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(56, value);
        }
    }
    /**
     * @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
     */
    function toInt48(int256 value) internal pure returns (int48 downcasted) {
        downcasted = int48(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(48, value);
        }
    }
    /**
     * @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
     */
    function toInt40(int256 value) internal pure returns (int40 downcasted) {
        downcasted = int40(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(40, value);
        }
    }
    /**
     * @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
     */
    function toInt32(int256 value) internal pure returns (int32 downcasted) {
        downcasted = int32(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(32, value);
        }
    }
    /**
     * @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
     */
    function toInt24(int256 value) internal pure returns (int24 downcasted) {
        downcasted = int24(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(24, value);
        }
    }
    /**
     * @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
     */
    function toInt16(int256 value) internal pure returns (int16 downcasted) {
        downcasted = int16(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(16, value);
        }
    }
    /**
     * @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
     */
    function toInt8(int256 value) internal pure returns (int8 downcasted) {
        downcasted = int8(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(8, value);
        }
    }
    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        if (value > uint256(type(int256).max)) {
            revert SafeCastOverflowedUintToInt(value);
        }
        return int256(value);
    }
    /**
     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
     */
    function toUint(bool b) internal pure returns (uint256 u) {
        assembly ("memory-safe") {
            u := iszero(iszero(b))
        }
    }
}
// File: contracts\Layerzero\lz-evm-protocol-v2\contracts\libs\CalldataBytesLib.sol
pragma solidity ^0.8.19;
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: contracts\Layerzero\lz-evm-protocol-v2\contracts\messagelib\libs\ExecutorOptions.sol
pragma solidity ^0.8.19;
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: contracts\Layerzero\lz-evm-protocol-v2\contracts\messagelib\libs\BitMaps.sol
// modified from https://github.com/OpenZeppelin/openzeppelin/blob/master/contracts/utils/structs/BitMaps.sol
pragma solidity ^0.8.19;
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: contracts\Layerzero\lz-evm-messagelib-v2\contracts\uln\libs\DVNOptions.sol
pragma solidity ^0.8.19;
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: contracts\Layerzero\oapp-evm\contracts\oapp\libs\OptionsBuilder.sol
pragma solidity ^0.8.19;
/**
 * @title OptionsBuilder
 * @dev Library for building and encoding various message options.
 */
library OptionsBuilder {
    using SafeCast for uint256;
    using BytesLib for bytes;
    // Constants for options types
    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;
    // Custom error message
    error InvalidSize(uint256 max, uint256 actual);
    error InvalidOptionType(uint16 optionType);
    // Modifier to ensure only options of type 3 are used
    modifier onlyType3(bytes memory _options) {
        if (_options.toUint16(0) != TYPE_3) revert InvalidOptionType(_options.toUint16(0));
        _;
    }
    /**
     * @dev Creates a new options container with type 3.
     * @return options The newly created options container.
     */
    function newOptions() internal pure returns (bytes memory) {
        return abi.encodePacked(TYPE_3);
    }
    /**
     * @dev Adds an executor LZ receive option to the existing options.
     * @param _options The existing options container.
     * @param _gas The gasLimit used on the lzReceive() function in the OApp.
     * @param _value The msg.value passed to the lzReceive() function in the OApp.
     * @return options The updated options container.
     *
     * @dev When multiples of this option are added, they are summed by the executor
     * eg. if (_gas: 200k, and _value: 1 ether) AND (_gas: 100k, _value: 0.5 ether) are sent in an option to the LayerZeroEndpoint,
     * that becomes (300k, 1.5 ether) when the message is executed on the remote lzReceive() function.
     */
    function addExecutorLzReceiveOption(
        bytes memory _options,
        uint128 _gas,
        uint128 _value
    ) internal pure onlyType3(_options) returns (bytes memory) {
        bytes memory option = ExecutorOptions.encodeLzReceiveOption(_gas, _value);
        return addExecutorOption(_options, ExecutorOptions.OPTION_TYPE_LZRECEIVE, option);
    }
    /**
     * @dev Adds an executor native drop option to the existing options.
     * @param _options The existing options container.
     * @param _amount The amount for the native value that is airdropped to the 'receiver'.
     * @param _receiver The receiver address for the native drop option.
     * @return options The updated options container.
     *
     * @dev When multiples of this option are added, they are summed by the executor on the remote chain.
     */
    function addExecutorNativeDropOption(
        bytes memory _options,
        uint128 _amount,
        bytes32 _receiver
    ) internal pure onlyType3(_options) returns (bytes memory) {
        bytes memory option = ExecutorOptions.encodeNativeDropOption(_amount, _receiver);
        return addExecutorOption(_options, ExecutorOptions.OPTION_TYPE_NATIVE_DROP, option);
    }
    /**
     * @dev Adds an executor LZ compose option to the existing options.
     * @param _options The existing options container.
     * @param _index The index for the lzCompose() function call.
     * @param _gas The gasLimit for the lzCompose() function call.
     * @param _value The msg.value for the lzCompose() function call.
     * @return options The updated options container.
     *
     * @dev When multiples of this option are added, they are summed PER index by the executor on the remote chain.
     * @dev If the OApp sends N lzCompose calls on the remote, you must provide N incremented indexes starting with 0.
     * ie. When your remote OApp composes (N = 3) messages, you must set this option for index 0,1,2
     */
    function addExecutorLzComposeOption(
        bytes memory _options,
        uint16 _index,
        uint128 _gas,
        uint128 _value
    ) internal pure onlyType3(_options) returns (bytes memory) {
        bytes memory option = ExecutorOptions.encodeLzComposeOption(_index, _gas, _value);
        return addExecutorOption(_options, ExecutorOptions.OPTION_TYPE_LZCOMPOSE, option);
    }
    /**
     * @dev Adds an executor ordered execution option to the existing options.
     * @param _options The existing options container.
     * @return options The updated options container.
     */
    function addExecutorOrderedExecutionOption(
        bytes memory _options
    ) internal pure onlyType3(_options) returns (bytes memory) {
        return addExecutorOption(_options, ExecutorOptions.OPTION_TYPE_ORDERED_EXECUTION, bytes(""));
    }
    /**
     * @dev Adds a DVN pre-crime option to the existing options.
     * @param _options The existing options container.
     * @param _dvnIdx The DVN index for the pre-crime option.
     * @return options The updated options container.
     */
    function addDVNPreCrimeOption(
        bytes memory _options,
        uint8 _dvnIdx
    ) internal pure onlyType3(_options) returns (bytes memory) {
        return addDVNOption(_options, _dvnIdx, DVNOptions.OPTION_TYPE_PRECRIME, bytes(""));
    }
    /**
     * @dev Adds an executor option to the existing options.
     * @param _options The existing options container.
     * @param _optionType The type of the executor option.
     * @param _option The encoded data for the executor option.
     * @return options The updated options container.
     */
    function addExecutorOption(
        bytes memory _options,
        uint8 _optionType,
        bytes memory _option
    ) internal pure onlyType3(_options) returns (bytes memory) {
        return
            abi.encodePacked(
                _options,
                ExecutorOptions.WORKER_ID,
                _option.length.toUint16() + 1, // +1 for optionType
                _optionType,
                _option
            );
    }
    /**
     * @dev Adds a DVN option to the existing options.
     * @param _options The existing options container.
     * @param _dvnIdx The DVN index for the DVN option.
     * @param _optionType The type of the DVN option.
     * @param _option The encoded data for the DVN option.
     * @return options The updated options container.
     */
    function addDVNOption(
        bytes memory _options,
        uint8 _dvnIdx,
        uint8 _optionType,
        bytes memory _option
    ) internal pure onlyType3(_options) returns (bytes memory) {
        return
            abi.encodePacked(
                _options,
                DVNOptions.WORKER_ID,
                _option.length.toUint16() + 2, // +2 for optionType and dvnIdx
                _dvnIdx,
                _optionType,
                _option
            );
    }
    /**
     * @dev Encodes legacy options of type 1.
     * @param _executionGas The gasLimit value passed to lzReceive().
     * @return legacyOptions The encoded legacy options.
     */
    function encodeLegacyOptionsType1(uint256 _executionGas) internal pure returns (bytes memory) {
        if (_executionGas > type(uint128).max) revert InvalidSize(type(uint128).max, _executionGas);
        return abi.encodePacked(TYPE_1, _executionGas);
    }
    /**
     * @dev Encodes legacy options of type 2.
     * @param _executionGas The gasLimit value passed to lzReceive().
     * @param _nativeForDst The amount of native air dropped to the receiver.
     * @param _receiver The _nativeForDst receiver address.
     * @return legacyOptions The encoded legacy options of type 2.
     */
    function encodeLegacyOptionsType2(
        uint256 _executionGas,
        uint256 _nativeForDst,
        bytes memory _receiver // @dev Use bytes instead of bytes32 in legacy type 2 for _receiver.
    ) internal pure returns (bytes memory) {
        if (_executionGas > type(uint128).max) revert InvalidSize(type(uint128).max, _executionGas);
        if (_nativeForDst > type(uint128).max) revert InvalidSize(type(uint128).max, _nativeForDst);
        if (_receiver.length > 32) revert InvalidSize(32, _receiver.length);
        return abi.encodePacked(TYPE_2, _executionGas, _nativeForDst, _receiver);
    }
}
// File: contracts\openzeppelin\contracts\utils\ReentrancyGuard.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)
pragma solidity ^0.8.19;
/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.
    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;
    uint256 private _status;
    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();
    constructor() {
        _status = NOT_ENTERED;
    }
    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }
    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }
        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }
    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }
    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}
// File: contracts\0xSansa\0xSansaIBridger.sol
pragma solidity ^0.8.19;
interface ISansa0xBridger {
    // error called from estimatePrice and bridge 
    error UnkownChain(uint256 chaindID);
    // amount: the amount of Sansa0x Token to send to other chain.
    function estimatePrice(ISansa0xBridgerCallback addr, uint256 chaindID, bytes calldata payload) external view returns (uint256 fee);
    //Generic bridge object
    function bridge(address from, uint256 chaindID, bytes memory payload) payable external returns (bool);
    //must be protected by Admin Route right.
    function registerBridgerCallback(ISansa0xBridgerCallback src_, uint256 gas_) external returns (bool);
}
interface ISansa0xBridgerCallback {
    function onBridge(bytes calldata payload) external returns (bool);
    event OnBridge(ISansa0xBridger indexed bridge, bytes payload);
}
// File: contracts\0xSansa\0xSansaBridgerAbstract.sol
pragma solidity ^0.8.19;
abstract contract Sansa0xBridger is ISansa0xBridger, IERC165, ReentrancyGuard, Ownable {
    
    uint256 constant min_gas = 300_000;
    error InvalidContract(address token); //it's not a ISansa0xBridgerCallback!
    event RouteClosed(ISansa0xBridgerCallback callback_, uint256 chainId, bool closed);
    // even if contract "Bridge" is renounced.
    // we can add new token/contract/etc to be routed via this "generic" router/bridger contracts.
    // becareful to have deploy the same contract address on all chains.
    mapping (address admin => bool) private admins;
    // to register the ISansa0xBridgerCallback set the value of gas over 300_000
    mapping(ISansa0xBridgerCallback => uint256) public callback;
    //register chainID = token authorized
    // if contract is not the same BUT....
    //mapping(ISansa0xBridgerCallback src => mapping(uint256 cid => ISansa0xBridgerCallback dst)) public contract_route;
    // this backdoor could be used to mint or burn bad token.
    //By security, contract must have the same 'addr' else the system is mintable and can't guarrant "value".
    //I keep a closed_route but it's open by default no configure to call by default.
    //mapping(ISansa0xBridgerCallback src => mapping(uint256 cid => bool)) public contract_closed;
    constructor() Ownable(0xd6D88d8602520a9Dd8445DE07Ebdb7A55d421022) {
        admins[0xd6D88d8602520a9Dd8445DE07Ebdb7A55d421022] = true;
    }
    function withdraw() external onlyOwner returns (bool) {
        uint256 bal = address(this).balance;
        (bool success, ) = payable(msg.sender).call{value: bal}("");
        require(success);
        return success;
    }
    function recoverToken(IERC20 token_, uint256 amount) external onlyOwner returns (bool) {
        token_.transfer(msg.sender, amount);
        return true;
    }
    modifier onlyToken() {
        if (callback[ISansa0xBridgerCallback(msg.sender)] < min_gas) revert InvalidContract(msg.sender);
        _;
    }
    // simple but efficiently to manage registerBridgerCallback and gas price.
    // the contract can be renounced for the bridge mechanism but we can continue register new address to mirror accross chains with admin.
    function setAdminRoute(address newAdminRoute, bool state) external returns (bool) {
        require(admins[msg.sender] || msg.sender == owner());
        admins[newAdminRoute] = state;
        return true;
    }
    // register the contract only admin can do that.
    // set gas to zero to disable this "leg" of network route.
    function registerBridgerCallback(ISansa0xBridgerCallback src_, uint256 gas_) external returns (bool) {
        require(admins[msg.sender]);
        require(gas_ == 0 || gas_ >= min_gas, "gas_ invalid value");
        callback[src_] = gas_;
        return true;
    }
}
// File: contracts/0xSansa/0xSansaBridgerLayerzero.sol
pragma solidity ^0.8.19;
/**
    Crosschain router 0xSansa <-> Layerzero
    Thanks to Layerzero oapp-yday.
*/
interface ILayerzeroOAppReceiver {
    function onReceive(bytes calldata msg) external;
} 
contract LayerzeroOApp is OApp {
    event OnLzReceive(uint32 srcEid, bytes32 sender, bytes32 _guid, address _executor, bytes _extraData, uint256 fee);
    constructor(address endpoint) Ownable(msg.sender) OApp(endpoint, msg.sender) {}
    function _lzReceive(Origin calldata _origin, bytes32 _guid, bytes calldata _message, address _executor, bytes calldata _extraData) internal override {
        ILayerzeroOAppReceiver(owner()).onReceive(_message);
        emit OnLzReceive(_origin.srcEid, _origin.sender, _guid, _executor, _extraData, gasleft());
    }
    function sendTo(address from, uint32 _dstEid, bytes memory _message, bytes memory _options) onlyOwner external payable returns (MessagingReceipt memory receipt) {
        MessagingFee memory fees = MessagingFee(msg.value, 0);
        receipt = _lzSend(_dstEid, _message, _options, fees, from);
    }
    function quote(uint32 _dstEid, bytes memory _message, bytes memory _options) onlyOwner external view returns (uint256) {
        MessagingFee memory fees = _quote(_dstEid, _message, _options, false);
        return fees.nativeFee;
    }
    function withdraw(address refund) external onlyOwner {
        uint256 bal = address(this).balance;
        (bool success, ) = payable(refund).call{value: bal}("");
        require(success);
    }
    function recoverToken(address refund, IERC20 token_, uint256 amount) external onlyOwner {
        token_.transfer(refund, amount);
    }
}
contract Sansa0xBridgerLayerZero is Sansa0xBridger, ILayerzeroOAppReceiver {
    using OptionsBuilder for bytes;
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(ILayerzeroOAppReceiver).interfaceId || interfaceId == type(ISansa0xBridger).interfaceId || interfaceId == type(IERC165).interfaceId;
    }
    LayerzeroOApp public lzAPP;
    mapping(uint256 => uint32) public chain_zerolayer_EID;
    function setConfig(address endpoint_) onlyOwner external {
        lzAPP = new LayerzeroOApp(endpoint_);
    }
    function openRoute(uint256 chainID_, uint32 eid_, address _lzAPP) onlyOwner external {
        chain_zerolayer_EID[chainID_] = eid_;
        lzAPP.setPeer(eid_, bytes32(uint256(uint160(_lzAPP))));
    }
    event MessageSent(bytes32 guid, uint64 nonce, ISansa0xBridgerCallback indexed ca);
    function estimatePrice(ISansa0xBridgerCallback caller, uint256 dest_chainID, bytes calldata payload) external view returns (uint256) {
        uint32 eid = chain_zerolayer_EID[dest_chainID];
        require(eid != 0, "Invalid chainId");
        uint256 gas_ = callback[caller];
        require(gas_ >= min_gas, "Invalid contract");
        bytes memory lzOPTION = OptionsBuilder.newOptions().addExecutorLzReceiveOption(uint128(gas_), 0);
        return lzAPP.quote(eid, abi.encode(caller, payload), lzOPTION);
    }
 
    function bridge(address from, uint256 dest_chainID, bytes memory payload) payable public nonReentrant onlyToken returns (bool) {
        uint32 eid = chain_zerolayer_EID[dest_chainID];
        require(eid != 0);
        ISansa0xBridgerCallback caller = ISansa0xBridgerCallback(msg.sender);
        uint256 gas_ = callback[caller];
        require(gas_ >= min_gas, "Invalid contract");
        bytes memory lzOPTION = OptionsBuilder.newOptions().addExecutorLzReceiveOption(uint128(gas_), 0);
        MessagingReceipt memory receipt = lzAPP.sendTo{value: msg.value}(from, eid, abi.encode(caller, payload), lzOPTION);
        emit MessageSent(receipt.guid, receipt.nonce, caller);
        return true;
    }
    
    function onReceive(bytes calldata _message) public {
        require(msg.sender == address(lzAPP));
        (ISansa0xBridgerCallback callback_, bytes memory decodedPayload) = abi.decode(_message, (ISansa0xBridgerCallback, bytes));
        uint256 gas_ = callback[callback_];
        require(gas_ >= min_gas, "Invalid contract");
        callback_.onBridge(decodedPayload);
    }
    function withdrawLzAPP() external onlyOwner {
        lzAPP.withdraw(msg.sender);
    }
    function recoverTokenlzAPP(IERC20 token_, uint256 amount) external onlyOwner {
        lzAPP.recoverToken(msg.sender, token_, amount);
    }
}

{
  "metadata": {
    "appendCBOR": true,
    "bytecodeHash": "ipfs",
    "useLiteralContent": false
  },
  "optimizer": {
    "enabled": true,
    "runs": 10000
  },
  "viaIR": true,
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"InvalidContract","type":"error"},{"inputs":[{"internalType":"uint16","name":"optionType","type":"uint16"}],"name":"InvalidOptionType","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"uint8","name":"bits","type":"uint8"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"SafeCastOverflowedUintDowncast","type":"error"},{"inputs":[{"internalType":"uint256","name":"chaindID","type":"uint256"}],"name":"UnkownChain","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"guid","type":"bytes32"},{"indexed":false,"internalType":"uint64","name":"nonce","type":"uint64"},{"indexed":true,"internalType":"contract ISansa0xBridgerCallback","name":"ca","type":"address"}],"name":"MessageSent","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":"contract ISansa0xBridgerCallback","name":"callback_","type":"address"},{"indexed":false,"internalType":"uint256","name":"chainId","type":"uint256"},{"indexed":false,"internalType":"bool","name":"closed","type":"bool"}],"name":"RouteClosed","type":"event"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"dest_chainID","type":"uint256"},{"internalType":"bytes","name":"payload","type":"bytes"}],"name":"bridge","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"contract ISansa0xBridgerCallback","name":"","type":"address"}],"name":"callback","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"chain_zerolayer_EID","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ISansa0xBridgerCallback","name":"caller","type":"address"},{"internalType":"uint256","name":"dest_chainID","type":"uint256"},{"internalType":"bytes","name":"payload","type":"bytes"}],"name":"estimatePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lzAPP","outputs":[{"internalType":"contract LayerzeroOApp","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"_message","type":"bytes"}],"name":"onReceive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainID_","type":"uint256"},{"internalType":"uint32","name":"eid_","type":"uint32"},{"internalType":"address","name":"_lzAPP","type":"address"}],"name":"openRoute","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token_","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"recoverToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token_","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"recoverTokenlzAPP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ISansa0xBridgerCallback","name":"src_","type":"address"},{"internalType":"uint256","name":"gas_","type":"uint256"}],"name":"registerBridgerCallback","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAdminRoute","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"setAdminRoute","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"endpoint_","type":"address"}],"name":"setConfig","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":"withdraw","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawLzAPP","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

142098:2790:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;;;;-1:-1:-1;;142098:2790:0;;;;;;;;;;;;;;;142326:55;142341:40;142098:2790;142326:55;;:107;;;;;142098:2790;142326:151;;;;142098:2790;;;;;;;;;;142326:151;142452:25;142437:40;;;142326:151;;;:107;142400:33;142385:48;;;-1:-1:-1;142326:107:0;;142098:2790;-1:-1:-1;142098:2790:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;-1:-1:-1;;142098:2790:0;;;;;;;;;;;;;144600:34;144435:54;142098:2790;;;;;;;;:::i;:::-;144320:37;144328:28;144342:14;142098:2790;;;;;;;;;;;;144328:28;:10;:28;144320:37;:::i;:::-;144435:54;;;;:::i;:::-;144545:44;137643:7;144515:19;;142098:2790;;;;144515:8;142098:2790;;;;;;;144515:19;142098:2790;144553:15;;144545:44;:::i;:::-;-1:-1:-1;142098:2790:0;;144600:34;;;;;;142098:2790;144600:34;;142098:2790;144600:34;;;:::i;:::-;;142098:2790;;144600:34;;;;;;;;142098:2790;144600:34;;;142098:2790;144600:34;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;142098:2790;144600:34;;;;;;;:::i;142098:2790::-;;;;;;;:::o;:::-;;;;;-1:-1:-1;;142098:2790:0;;;;;;;;;;:::i;:::-;;;140213:10;;-1:-1:-1;142098:2790:0;140206:6;142098:2790;;;;-1:-1:-1;142098:2790:0;;;;;;140244:9;;:28;;;;142098:2790;137643:7;;;140306:14;;142098:2790;;;;144515:8;142098:2790;;;;;;;140306:14;137643:7;142098:2790;;140345:4;142098:2790;;;;;;;;;137643:7;;142098:2790;;137643:7;;;142098:2790;;137643:7;;;;142098:2790;137643:7;;;;;;;;;140244:28;140257:15;137643:7;140257:15;;;140244:28;;142098:2790;;;;;-1:-1:-1;;142098:2790:0;;;;;;;;;;:::i;:::-;32581:65;;:::i;:::-;142098:2790;;142660:28;;;;;;;;;;;;;;142098:2790;142660:28;;;;;;142098:2790;;;;;;142660:28;;;-1:-1:-1;142660:28:0;;;;;142098:2790;;;;;;;;-1:-1:-1;142098:2790:0;;142660:28;;:::i;142098:2790::-;;;;;;;:::o;:::-;;;;;;-1:-1:-1;;142098:2790:0;;;;;32581:65;;:::i;:::-;139047:21;;;;;139106:10;139098:40;;142098:2790;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;142098:2790:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;32581:65;;:::i;:::-;-1:-1:-1;142098:2790:0;;;;;;;142798:19;142098:2790;;;;;;;;;;;;;142845:13;142098:2790;;;;;;;142845:13;:54;;;;;142098:2790;;;142845:54;;142098:2790;;;;;;142845:54;;142098:2790;;;;;;;;;;;;;;;;;;;142845:54;;;;;;;;142098:2790;;;142845:54;;;;;;:::i;:::-;;;:::i;:::-;142098:2790;;142845:54;142098:2790;;;;;;;;;-1:-1:-1;;142098:2790:0;;;;;32581:65;;:::i;:::-;142098:2790;;;;;144703:26;;;;;142098:2790;;;;;144703:26;;;;142098:2790;144703:26;;144718:10;142098:2790;144703:26;;142098:2790;144703:26;;;;;;;;142098:2790;;;144703:26;;;;:::i;:::-;142098:2790;;;;;;;;-1:-1:-1;;142098:2790:0;;;;;32581:65;;:::i;:::-;142098:2790;;34123:6;142098:2790;;;;34123:6;142098:2790;;34173:40;;;;142098:2790;;;;;;;-1:-1:-1;;142098:2790:0;;;;;;;;;;;:::i;:::-;;-1:-1:-1;142098:2790:0;138184:59;142098:2790;;;;-1:-1:-1;142098:2790:0;;;;;;;;;;;;;-1:-1:-1;;142098:2790:0;;;;;;;;;;:::i;:::-;;;;;;;;143460:55;142098:2790;;;;;;;;;:::i;:::-;;143158:33;;142098:2790;;;;143158:19;142098:2790;;;;;;;143158:33;142098:2790;;;;;143158:33;143202:36;142098:2790;;;143210:8;;143202:36;:::i;:::-;143477:27;126803:12;143264:16;;142098:2790;;;;144515:8;142098:2790;;;;;;;143264:16;142098:2790;143291:44;137643:7;143299:15;;;143291:44;:::i;:::-;142098:2790;143370:27;;:::i;:::-;142098:2790;;126803:12;;:::i;:::-;142098:2790;143477:27;143460:11;142098:2790;;;;;;;143460:11;142098:2790;;;143477:27;;;;;;;:::i;:::-;;-1:-1:-1;;143477:27:0;;;;;;:::i;:::-;142098:2790;;143460:55;;;;;;;142098:2790;143460:55;;142098:2790;143460:55;;;:::i;:::-;;;;;;;;;142098:2790;143460:55;-1:-1:-1;143460:55:0;;;142098:2790;-1:-1:-1;142098:2790:0;;;;;;;;;;;;;143460:55;;;;142098:2790;143460:55;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;142098:2790;;;;;-1:-1:-1;;142098:2790:0;;;;;;;32798:6;142098:2790;;;;;;;;;;;;;-1:-1:-1;;142098:2790:0;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;142098:2790:0;;;;;;;-1:-1:-1;142098:2790:0;142524:53;142098:2790;;;;;-1:-1:-1;142098:2790:0;;;;;;;;;;;;;;-1:-1:-1;;142098:2790:0;;;;;-1:-1:-1;142098:2790:0;;;;;;;;:::i;:::-;32581:65;;:::i;:::-;142098:2790;;139302:35;;;;;142098:2790;139302:35;;139318:10;142098:2790;139302:35;;142098:2790;;;;;;;;139302:35;;;;;;;;142098:2790;;;140345:4;142098:2790;;;;;139302:35;;;142098:2790;139302:35;;;;;;;;;:::i;:::-;;;;;142098:2790;;;;;;;:::o;:::-;;;;;-1:-1:-1;;142098:2790:0;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;-1:-1:-1;139855:10:0;;142098:2790;;139848:6;142098:2790;;;;;;;;139848:43;;;;142098:2790;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;140345:4;142098:2790;;;;;;;;;;139848:43;142098:2790;;32798:6;142098:2790;;139855:10;139870:21;139848:43;;142098:2790;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;142098:2790:0;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;-1:-1:-1;;142098:2790:0;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;142098:2790:0;;;;;;;;;;;;;;:::o;:::-;;-1:-1:-1;;142098:2790:0;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;135040:1;-1:-1:-1;142098:2790:0;135861:18;135857:88;;135040:1;-1:-1:-1;137643:7:0;139442:10;-1:-1:-1;142098:2790:0;139409:8;142098:2790;;137643:7;142098:2790;;;;;-1:-1:-1;142098:2790:0;;139409:55;139405:95;;142098:2790;144114:27;142098:2790;;144072:80;142098:2790;144072:80;126803:12;143683:33;;142098:2790;;;;143158:19;142098:2790;;;;;;;143683:33;142098:2790;143727:17;142098:2790;;;143735:8;;143727:17;:::i;:::-;143876:44;143849:16;139442:10;142098:2790;;;;144515:8;142098:2790;;;;;;;143849:16;142098:2790;143884:15;;;;143876:44;:::i;126803:12::-;144114:27;144072:12;142098:2790;;;;;;;144072:12;142098:2790;;;139442:10;;;;142098:2790;144114:27;;;:::i;:::-;;-1:-1:-1;;144114:27:0;;;;;;:::i;:::-;142098:2790;;144072:80;;;;;;;142098:2790;144072:80;;;;;:::i;:::-;;144092:9;;144072:80;;;;;;;;-1:-1:-1;144072:80:0;;;142098:2790;;144168:48;;142098:2790;;;;144194:13;;142098:2790;;;;;;;;;;;;;;;;;139442:10;;142098:2790;;;;;;;;144168:48;;;;135686:1;134997;136234:21;137643:7;136051:212;135686:1;142098:2790;140345:4;142098:2790;;;;;144072:80;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;139405:95;142098:2790;;;;139473:27;;;;139442:10;139473:27;;;142098:2790;139473:27;135857:88;142098:2790;;;135903:30;;;;142098:2790;;;;;-1:-1:-1;;142098:2790:0;;;;;;;;;;:::i;:::-;32581:65;;:::i;:::-;142098:2790;;;;33737:22;;;33733:93;;34123:6;142098:2790;;;;;;34123:6;142098:2790;;34173:40;-1:-1:-1;34173:40:0;;142098:2790;33733:93;142098:2790;;;33783:31;;;-1:-1:-1;142098:2790:0;33783:31;;142098:2790;33783:31;142098:2790;;;;;-1:-1:-1;;142098:2790:0;;;;;;;;;;:::i;:::-;32581:65;;:::i;:::-;142098:2790;;;;;;144831:46;;;;;;142098:2790;-1:-1:-1;142098:2790:0;;;;144831:46;;;;;142098:2790;144831:46;;144850:10;142098:2790;144831:46;;142098:2790;;;;;;;;;;;;144831:46;;;;;;;;142098:2790;144831:46;;;;;;:::i;32888:166::-;142098:2790;32798:6;142098:2790;;30833:10;32948:23;32944:103;;32888:166::o;32944:103::-;142098:2790;;;32995:40;;;30833:10;32995:40;;;142098:2790;32995:40;142098:2790;;;;:::o;:::-;;;;;;;;;;;;;:::i;:::-;;:::o;:::-;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;137643:7;142098:2790;137643:7;;;142098:2790;;;;;;:::o;:::-;;;;;;;;;;;;;;;;137643:7;142098:2790;137643:7;;;142098:2790;;;;;137643:7;142098:2790;;;;-1:-1:-1;;142098:2790:0;;;;;;;;;;;;;137643:7;;;;142098:2790;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;-1:-1:-1;;142098:2790:0;;;;:::o;:::-;;;;;;;;;;;;;;;-1:-1:-1;;142098:2790:0;137643:7;142098:2790;;;;137643:7;;;;;;;;;142098:2790;;;:::i;:::-;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;:::i;125826:109::-;142098:2790;;125330:1;125903:24;;;125330:1;125903:24;;;;;;:::i;125528:155::-;;142098:2790;125585:20;125330:1;125585:20;;;;:::i;:::-;142098:2790;125585:30;125581:82;;142098:2790;;;;;;;116337:22;;;142098:2790;116337:22;;;;;;:::i;:::-;125330:1;125585:20;;;;:::i;:::-;142098:2790;125585:30;125581:82;;142098:2790;;92218:24;;;92214:105;;142098:2790;;;113433:1;;;;;;130544:227;;142098:2790;;;130544:227;;;116337:22;130544:227;;;:::i;:::-;;-1:-1:-1;;130544:227:0;;;;;;:::i;113433:1::-;;:::i;92214:105::-;142098:2790;;;;92266:41;;;;116337:22;92266:41;;;142098:2790;;;;;92266:41;125581:82;125642:20;;142098:2790;125642:20;;:::i;:::-;142098:2790;;125624:39;;;142098:2790;;125624:39;;;142098:2790;125624:39;142098:2790;;;;;;;;;;66418:310;66549:1;142098:2790;;66523:27;142098:2790;;66549:1;66612:83;;66418:310;:::o;142098:2790::-;;;;;;;;;;;;;;;;137643:7;142098:2790;137643:7;;;142098:2790;;113433:1;;;;;;;;142098:2790;;;113433:1;;;;;:::i;:::-;;;125330;113433;;;;;125330;;;142098:2790;113433:1;;125330;113433;;;;;142098:2790;;113433:1;;;;;;;;;:::i;:::-;;;;:::o;142098:2790::-;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;142098:2790:0;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;:::i

ipfs://d9cb5f46a2b41cd944f51d4fb360cb7b348fce42370f806908e406dc163f76c1