Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

import "../abstract/EeseeAssetSpokeBase.sol";
import "../abstract/AxelarCallerEeseeMessageInterface.sol";

contract EeseeAssetSpokeAxelar is EeseeAssetSpokeBase, AxelarCallerEeseeMessageInterface {
    constructor(
        IEeseeAccessManager _accessManager,
        bytes memory _currentChainSelector,
        AddressWithChain memory _eeseeAssetHub,
        IRoyaltyEngineV1 _royaltyEngine,

        IAxelarGateway _gateway,
        IAxelarGasService _gasService,

        address trustedForwarder
    ) EeseeAssetSpokeBase(_accessManager, _currentChainSelector, _eeseeAssetHub, _royaltyEngine, trustedForwarder) AxelarGatewayBase(_gateway, _gasService) {}
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IUpgradable } from '../interfaces/IUpgradable.sol';

/**
 * @title IAxelarGasService Interface
 * @notice This is an interface for the AxelarGasService contract which manages gas payments
 * and refunds for cross-chain communication on the Axelar network.
 * @dev This interface inherits IUpgradable
 */
interface IAxelarGasService is IUpgradable {
    error NothingReceived();
    error InvalidAddress();
    error NotCollector();
    error InvalidAmounts();

    event GasPaidForContractCall(
        address indexed sourceAddress,
        string destinationChain,
        string destinationAddress,
        bytes32 indexed payloadHash,
        address gasToken,
        uint256 gasFeeAmount,
        address refundAddress
    );

    event GasPaidForContractCallWithToken(
        address indexed sourceAddress,
        string destinationChain,
        string destinationAddress,
        bytes32 indexed payloadHash,
        string symbol,
        uint256 amount,
        address gasToken,
        uint256 gasFeeAmount,
        address refundAddress
    );

    event NativeGasPaidForContractCall(
        address indexed sourceAddress,
        string destinationChain,
        string destinationAddress,
        bytes32 indexed payloadHash,
        uint256 gasFeeAmount,
        address refundAddress
    );

    event NativeGasPaidForContractCallWithToken(
        address indexed sourceAddress,
        string destinationChain,
        string destinationAddress,
        bytes32 indexed payloadHash,
        string symbol,
        uint256 amount,
        uint256 gasFeeAmount,
        address refundAddress
    );

    event GasPaidForExpressCall(
        address indexed sourceAddress,
        string destinationChain,
        string destinationAddress,
        bytes32 indexed payloadHash,
        address gasToken,
        uint256 gasFeeAmount,
        address refundAddress
    );

    event GasPaidForExpressCallWithToken(
        address indexed sourceAddress,
        string destinationChain,
        string destinationAddress,
        bytes32 indexed payloadHash,
        string symbol,
        uint256 amount,
        address gasToken,
        uint256 gasFeeAmount,
        address refundAddress
    );

    event NativeGasPaidForExpressCall(
        address indexed sourceAddress,
        string destinationChain,
        string destinationAddress,
        bytes32 indexed payloadHash,
        uint256 gasFeeAmount,
        address refundAddress
    );

    event NativeGasPaidForExpressCallWithToken(
        address indexed sourceAddress,
        string destinationChain,
        string destinationAddress,
        bytes32 indexed payloadHash,
        string symbol,
        uint256 amount,
        uint256 gasFeeAmount,
        address refundAddress
    );

    event GasAdded(
        bytes32 indexed txHash,
        uint256 indexed logIndex,
        address gasToken,
        uint256 gasFeeAmount,
        address refundAddress
    );

    event NativeGasAdded(bytes32 indexed txHash, uint256 indexed logIndex, uint256 gasFeeAmount, address refundAddress);

    event ExpressGasAdded(
        bytes32 indexed txHash,
        uint256 indexed logIndex,
        address gasToken,
        uint256 gasFeeAmount,
        address refundAddress
    );

    event NativeExpressGasAdded(
        bytes32 indexed txHash,
        uint256 indexed logIndex,
        uint256 gasFeeAmount,
        address refundAddress
    );

    event Refunded(
        bytes32 indexed txHash,
        uint256 indexed logIndex,
        address payable receiver,
        address token,
        uint256 amount
    );

    /**
     * @notice Pay for gas using ERC20 tokens for a contract call on a destination chain.
     * @dev This function is called on the source chain before calling the gateway to execute a remote contract.
     * @param sender The address making the payment
     * @param destinationChain The target chain where the contract call will be made
     * @param destinationAddress The target address on the destination chain
     * @param payload Data payload for the contract call
     * @param gasToken The address of the ERC20 token used to pay for gas
     * @param gasFeeAmount The amount of tokens to pay for gas
     * @param refundAddress The address where refunds, if any, should be sent
     */
    function payGasForContractCall(
        address sender,
        string calldata destinationChain,
        string calldata destinationAddress,
        bytes calldata payload,
        address gasToken,
        uint256 gasFeeAmount,
        address refundAddress
    ) external;

    /**
     * @notice Pay for gas using ERC20 tokens for a contract call with tokens on a destination chain.
     * @dev This function is called on the source chain before calling the gateway to execute a remote contract.
     * @param sender The address making the payment
     * @param destinationChain The target chain where the contract call with tokens will be made
     * @param destinationAddress The target address on the destination chain
     * @param payload Data payload for the contract call with tokens
     * @param symbol The symbol of the token to be sent with the call
     * @param amount The amount of tokens to be sent with the call
     * @param gasToken The address of the ERC20 token used to pay for gas
     * @param gasFeeAmount The amount of tokens to pay for gas
     * @param refundAddress The address where refunds, if any, should be sent
     */
    function payGasForContractCallWithToken(
        address sender,
        string calldata destinationChain,
        string calldata destinationAddress,
        bytes calldata payload,
        string calldata symbol,
        uint256 amount,
        address gasToken,
        uint256 gasFeeAmount,
        address refundAddress
    ) external;

    /**
     * @notice Pay for gas using native currency for a contract call on a destination chain.
     * @dev This function is called on the source chain before calling the gateway to execute a remote contract.
     * @param sender The address making the payment
     * @param destinationChain The target chain where the contract call will be made
     * @param destinationAddress The target address on the destination chain
     * @param payload Data payload for the contract call
     * @param refundAddress The address where refunds, if any, should be sent
     */
    function payNativeGasForContractCall(
        address sender,
        string calldata destinationChain,
        string calldata destinationAddress,
        bytes calldata payload,
        address refundAddress
    ) external payable;

    /**
     * @notice Pay for gas using native currency for a contract call with tokens on a destination chain.
     * @dev This function is called on the source chain before calling the gateway to execute a remote contract.
     * @param sender The address making the payment
     * @param destinationChain The target chain where the contract call with tokens will be made
     * @param destinationAddress The target address on the destination chain
     * @param payload Data payload for the contract call with tokens
     * @param symbol The symbol of the token to be sent with the call
     * @param amount The amount of tokens to be sent with the call
     * @param refundAddress The address where refunds, if any, should be sent
     */
    function payNativeGasForContractCallWithToken(
        address sender,
        string calldata destinationChain,
        string calldata destinationAddress,
        bytes calldata payload,
        string calldata symbol,
        uint256 amount,
        address refundAddress
    ) external payable;

    /**
     * @notice Pay for gas using ERC20 tokens for an express contract call on a destination chain.
     * @dev This function is called on the source chain before calling the gateway to express execute a remote contract.
     * @param sender The address making the payment
     * @param destinationChain The target chain where the contract call will be made
     * @param destinationAddress The target address on the destination chain
     * @param payload Data payload for the contract call
     * @param gasToken The address of the ERC20 token used to pay for gas
     * @param gasFeeAmount The amount of tokens to pay for gas
     * @param refundAddress The address where refunds, if any, should be sent
     */
    function payGasForExpressCall(
        address sender,
        string calldata destinationChain,
        string calldata destinationAddress,
        bytes calldata payload,
        address gasToken,
        uint256 gasFeeAmount,
        address refundAddress
    ) external;

    /**
     * @notice Pay for gas using ERC20 tokens for an express contract call with tokens on a destination chain.
     * @dev This function is called on the source chain before calling the gateway to express execute a remote contract.
     * @param sender The address making the payment
     * @param destinationChain The target chain where the contract call with tokens will be made
     * @param destinationAddress The target address on the destination chain
     * @param payload Data payload for the contract call with tokens
     * @param symbol The symbol of the token to be sent with the call
     * @param amount The amount of tokens to be sent with the call
     * @param gasToken The address of the ERC20 token used to pay for gas
     * @param gasFeeAmount The amount of tokens to pay for gas
     * @param refundAddress The address where refunds, if any, should be sent
     */
    function payGasForExpressCallWithToken(
        address sender,
        string calldata destinationChain,
        string calldata destinationAddress,
        bytes calldata payload,
        string calldata symbol,
        uint256 amount,
        address gasToken,
        uint256 gasFeeAmount,
        address refundAddress
    ) external;

    /**
     * @notice Pay for gas using native currency for an express contract call on a destination chain.
     * @dev This function is called on the source chain before calling the gateway to express execute a remote contract.
     * @param sender The address making the payment
     * @param destinationChain The target chain where the contract call will be made
     * @param destinationAddress The target address on the destination chain
     * @param payload Data payload for the contract call
     * @param refundAddress The address where refunds, if any, should be sent
     */
    function payNativeGasForExpressCall(
        address sender,
        string calldata destinationChain,
        string calldata destinationAddress,
        bytes calldata payload,
        address refundAddress
    ) external payable;

    /**
     * @notice Pay for gas using native currency for an express contract call with tokens on a destination chain.
     * @dev This function is called on the source chain before calling the gateway to express execute a remote contract.
     * @param sender The address making the payment
     * @param destinationChain The target chain where the contract call with tokens will be made
     * @param destinationAddress The target address on the destination chain
     * @param payload Data payload for the contract call with tokens
     * @param symbol The symbol of the token to be sent with the call
     * @param amount The amount of tokens to be sent with the call
     * @param refundAddress The address where refunds, if any, should be sent
     */
    function payNativeGasForExpressCallWithToken(
        address sender,
        string calldata destinationChain,
        string calldata destinationAddress,
        bytes calldata payload,
        string calldata symbol,
        uint256 amount,
        address refundAddress
    ) external payable;

    /**
     * @notice Add additional gas payment using ERC20 tokens after initiating a cross-chain call.
     * @dev This function can be called on the source chain after calling the gateway to execute a remote contract.
     * @param txHash The transaction hash of the cross-chain call
     * @param logIndex The log index for the cross-chain call
     * @param gasToken The ERC20 token address used to add gas
     * @param gasFeeAmount The amount of tokens to add as gas
     * @param refundAddress The address where refunds, if any, should be sent
     */
    function addGas(
        bytes32 txHash,
        uint256 logIndex,
        address gasToken,
        uint256 gasFeeAmount,
        address refundAddress
    ) external;

    /**
     * @notice Add additional gas payment using native currency after initiating a cross-chain call.
     * @dev This function can be called on the source chain after calling the gateway to execute a remote contract.
     * @param txHash The transaction hash of the cross-chain call
     * @param logIndex The log index for the cross-chain call
     * @param refundAddress The address where refunds, if any, should be sent
     */
    function addNativeGas(
        bytes32 txHash,
        uint256 logIndex,
        address refundAddress
    ) external payable;

    /**
     * @notice Add additional gas payment using ERC20 tokens after initiating an express cross-chain call.
     * @dev This function can be called on the source chain after calling the gateway to express execute a remote contract.
     * @param txHash The transaction hash of the cross-chain call
     * @param logIndex The log index for the cross-chain call
     * @param gasToken The ERC20 token address used to add gas
     * @param gasFeeAmount The amount of tokens to add as gas
     * @param refundAddress The address where refunds, if any, should be sent
     */
    function addExpressGas(
        bytes32 txHash,
        uint256 logIndex,
        address gasToken,
        uint256 gasFeeAmount,
        address refundAddress
    ) external;

    /**
     * @notice Add additional gas payment using native currency after initiating an express cross-chain call.
     * @dev This function can be called on the source chain after calling the gateway to express execute a remote contract.
     * @param txHash The transaction hash of the cross-chain call
     * @param logIndex The log index for the cross-chain call
     * @param refundAddress The address where refunds, if any, should be sent
     */
    function addNativeExpressGas(
        bytes32 txHash,
        uint256 logIndex,
        address refundAddress
    ) external payable;

    /**
     * @notice Allows the gasCollector to collect accumulated fees from the contract.
     * @dev Use address(0) as the token address for native currency.
     * @param receiver The address to receive the collected fees
     * @param tokens Array of token addresses to be collected
     * @param amounts Array of amounts to be collected for each respective token address
     */
    function collectFees(
        address payable receiver,
        address[] calldata tokens,
        uint256[] calldata amounts
    ) external;

    /**
     * @notice Refunds gas payment to the receiver in relation to a specific cross-chain transaction.
     * @dev Only callable by the gasCollector.
     * @dev Use address(0) as the token address to refund native currency.
     * @param txHash The transaction hash of the cross-chain call
     * @param logIndex The log index for the cross-chain call
     * @param receiver The address to receive the refund
     * @param token The token address to be refunded
     * @param amount The amount to refund
     */
    function refund(
        bytes32 txHash,
        uint256 logIndex,
        address payable receiver,
        address token,
        uint256 amount
    ) external;

    /**
     * @notice Returns the address of the designated gas collector.
     * @return address of the gas collector
     */
    function gasCollector() external returns (address);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IGovernable } from './IGovernable.sol';
import { IImplementation } from './IImplementation.sol';

interface IAxelarGateway is IImplementation, IGovernable {
    /**********\
    |* Errors *|
    \**********/

    error NotSelf();
    error InvalidCodeHash();
    error SetupFailed();
    error InvalidAuthModule();
    error InvalidTokenDeployer();
    error InvalidAmount();
    error InvalidChainId();
    error InvalidCommands();
    error TokenDoesNotExist(string symbol);
    error TokenAlreadyExists(string symbol);
    error TokenDeployFailed(string symbol);
    error TokenContractDoesNotExist(address token);
    error BurnFailed(string symbol);
    error MintFailed(string symbol);
    error InvalidSetMintLimitsParams();
    error ExceedMintLimit(string symbol);

    /**********\
    |* Events *|
    \**********/

    event TokenSent(
        address indexed sender,
        string destinationChain,
        string destinationAddress,
        string symbol,
        uint256 amount
    );

    event ContractCall(
        address indexed sender,
        string destinationChain,
        string destinationContractAddress,
        bytes32 indexed payloadHash,
        bytes payload
    );

    event ContractCallWithToken(
        address indexed sender,
        string destinationChain,
        string destinationContractAddress,
        bytes32 indexed payloadHash,
        bytes payload,
        string symbol,
        uint256 amount
    );

    event Executed(bytes32 indexed commandId);

    event TokenDeployed(string symbol, address tokenAddresses);

    event ContractCallApproved(
        bytes32 indexed commandId,
        string sourceChain,
        string sourceAddress,
        address indexed contractAddress,
        bytes32 indexed payloadHash,
        bytes32 sourceTxHash,
        uint256 sourceEventIndex
    );

    event ContractCallApprovedWithMint(
        bytes32 indexed commandId,
        string sourceChain,
        string sourceAddress,
        address indexed contractAddress,
        bytes32 indexed payloadHash,
        string symbol,
        uint256 amount,
        bytes32 sourceTxHash,
        uint256 sourceEventIndex
    );

    event ContractCallExecuted(bytes32 indexed commandId);

    event TokenMintLimitUpdated(string symbol, uint256 limit);

    event OperatorshipTransferred(bytes newOperatorsData);

    event Upgraded(address indexed implementation);

    /********************\
    |* Public Functions *|
    \********************/

    function sendToken(
        string calldata destinationChain,
        string calldata destinationAddress,
        string calldata symbol,
        uint256 amount
    ) external;

    function callContract(
        string calldata destinationChain,
        string calldata contractAddress,
        bytes calldata payload
    ) external;

    function callContractWithToken(
        string calldata destinationChain,
        string calldata contractAddress,
        bytes calldata payload,
        string calldata symbol,
        uint256 amount
    ) external;

    function isContractCallApproved(
        bytes32 commandId,
        string calldata sourceChain,
        string calldata sourceAddress,
        address contractAddress,
        bytes32 payloadHash
    ) external view returns (bool);

    function isContractCallAndMintApproved(
        bytes32 commandId,
        string calldata sourceChain,
        string calldata sourceAddress,
        address contractAddress,
        bytes32 payloadHash,
        string calldata symbol,
        uint256 amount
    ) external view returns (bool);

    function validateContractCall(
        bytes32 commandId,
        string calldata sourceChain,
        string calldata sourceAddress,
        bytes32 payloadHash
    ) external returns (bool);

    function validateContractCallAndMint(
        bytes32 commandId,
        string calldata sourceChain,
        string calldata sourceAddress,
        bytes32 payloadHash,
        string calldata symbol,
        uint256 amount
    ) external returns (bool);

    /***********\
    |* Getters *|
    \***********/

    function authModule() external view returns (address);

    function tokenDeployer() external view returns (address);

    function tokenMintLimit(string memory symbol) external view returns (uint256);

    function tokenMintAmount(string memory symbol) external view returns (uint256);

    function allTokensFrozen() external view returns (bool);

    function implementation() external view returns (address);

    function tokenAddresses(string memory symbol) external view returns (address);

    function tokenFrozen(string memory symbol) external view returns (bool);

    function isCommandExecuted(bytes32 commandId) external view returns (bool);

    /************************\
    |* Governance Functions *|
    \************************/

    function setTokenMintLimits(string[] calldata symbols, uint256[] calldata limits) external;

    function upgrade(
        address newImplementation,
        bytes32 newImplementationCodeHash,
        bytes calldata setupParams
    ) external;

    /**********************\
    |* External Functions *|
    \**********************/

    function execute(bytes calldata input) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// General interface for upgradable contracts
interface IContractIdentifier {
    /**
     * @notice Returns the contract ID. It can be used as a check during upgrades.
     * @dev Meant to be overridden in derived contracts.
     * @return bytes32 The contract ID
     */
    function contractId() external pure returns (bytes32);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title IGovernable Interface
 * @notice This is an interface used by the AxelarGateway contract to manage governance and mint limiter roles.
 */
interface IGovernable {
    error NotGovernance();
    error NotMintLimiter();
    error InvalidGovernance();
    error InvalidMintLimiter();

    event GovernanceTransferred(address indexed previousGovernance, address indexed newGovernance);
    event MintLimiterTransferred(address indexed previousGovernance, address indexed newGovernance);

    /**
     * @notice Returns the governance address.
     * @return address of the governance
     */
    function governance() external view returns (address);

    /**
     * @notice Returns the mint limiter address.
     * @return address of the mint limiter
     */
    function mintLimiter() external view returns (address);

    /**
     * @notice Transfer the governance role to another address.
     * @param newGovernance The new governance address
     */
    function transferGovernance(address newGovernance) external;

    /**
     * @notice Transfer the mint limiter role to another address.
     * @param newGovernance The new mint limiter address
     */
    function transferMintLimiter(address newGovernance) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IContractIdentifier } from './IContractIdentifier.sol';

interface IImplementation is IContractIdentifier {
    error NotProxy();

    function setup(bytes calldata data) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title IOwnable Interface
 * @notice IOwnable is an interface that abstracts the implementation of a
 * contract with ownership control features. It's commonly used in upgradable
 * contracts and includes the functionality to get current owner, transfer
 * ownership, and propose and accept ownership.
 */
interface IOwnable {
    error NotOwner();
    error InvalidOwner();
    error InvalidOwnerAddress();

    event OwnershipTransferStarted(address indexed newOwner);
    event OwnershipTransferred(address indexed newOwner);

    /**
     * @notice Returns the current owner of the contract.
     * @return address The address of the current owner
     */
    function owner() external view returns (address);

    /**
     * @notice Returns the address of the pending owner of the contract.
     * @return address The address of the pending owner
     */
    function pendingOwner() external view returns (address);

    /**
     * @notice Transfers ownership of the contract to a new address
     * @param newOwner The address to transfer ownership to
     */
    function transferOwnership(address newOwner) external;

    /**
     * @notice Proposes to transfer the contract's ownership to a new address.
     * The new owner needs to accept the ownership explicitly.
     * @param newOwner The address to transfer ownership to
     */
    function proposeOwnership(address newOwner) external;

    /**
     * @notice Transfers ownership to the pending owner.
     * @dev Can only be called by the pending owner
     */
    function acceptOwnership() external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IOwnable } from './IOwnable.sol';
import { IImplementation } from './IImplementation.sol';

// General interface for upgradable contracts
interface IUpgradable is IOwnable, IImplementation {
    error InvalidCodeHash();
    error InvalidImplementation();
    error SetupFailed();

    event Upgraded(address indexed newImplementation);

    function implementation() external view returns (address);

    function upgrade(
        address newImplementation,
        bytes32 newImplementationCodeHash,
        bytes calldata params
    ) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

library StringToAddress {
    error InvalidAddressString();

    function toAddress(string memory addressString) internal pure returns (address) {
        bytes memory stringBytes = bytes(addressString);
        uint160 addressNumber = 0;
        uint8 stringByte;

        if (stringBytes.length != 42 || stringBytes[0] != '0' || stringBytes[1] != 'x') revert InvalidAddressString();

        for (uint256 i = 2; i < 42; ++i) {
            stringByte = uint8(stringBytes[i]);

            if ((stringByte >= 97) && (stringByte <= 102)) stringByte -= 87;
            else if ((stringByte >= 65) && (stringByte <= 70)) stringByte -= 55;
            else if ((stringByte >= 48) && (stringByte <= 57)) stringByte -= 48;
            else revert InvalidAddressString();

            addressNumber |= uint160(uint256(stringByte) << ((41 - i) << 2));
        }

        return address(addressNumber);
    }
}

library AddressToString {
    function toString(address address_) internal pure returns (string memory) {
        bytes memory addressBytes = abi.encodePacked(address_);
        bytes memory characters = '0123456789abcdef';
        bytes memory stringBytes = new bytes(42);

        stringBytes[0] = '0';
        stringBytes[1] = 'x';

        for (uint256 i; i < 20; ++i) {
            stringBytes[2 + i * 2] = characters[uint8(addressBytes[i] >> 4)];
            stringBytes[3 + i * 2] = characters[uint8(addressBytes[i] & 0x0f)];
        }

        return string(stringBytes);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (metatx/ERC2771Context.sol)

pragma solidity ^0.8.9;

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

/**
 * @dev Context variant with ERC2771 support.
 *
 * WARNING: The usage of `delegatecall` in this contract is dangerous and may result in context corruption.
 * Any forwarded request to this contract triggering a `delegatecall` to itself will result in an invalid {_msgSender}
 * recovery.
 */
abstract contract ERC2771Context is Context {
    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
    address private immutable _trustedForwarder;

    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor(address trustedForwarder) {
        _trustedForwarder = trustedForwarder;
    }

    function isTrustedForwarder(address forwarder) public view virtual returns (bool) {
        return forwarder == _trustedForwarder;
    }

    function _msgSender() internal view virtual override returns (address) {
        uint256 calldataLength = msg.data.length;
        uint256 contextSuffixLength = _contextSuffixLength();
        if (isTrustedForwarder(msg.sender) && calldataLength >= contextSuffixLength) {
            return address(bytes20(msg.data[calldataLength - contextSuffixLength:]));
        } else {
            return super._msgSender();
        }
    }

    function _msgData() internal view virtual override returns (bytes calldata) {
        uint256 calldataLength = msg.data.length;
        uint256 contextSuffixLength = _contextSuffixLength();
        if (isTrustedForwarder(msg.sender) && calldataLength >= contextSuffixLength) {
            return msg.data[:calldataLength - contextSuffixLength];
        } else {
            return super._msgData();
        }
    }

    /**
     * @dev ERC-2771 specifies the context as being a single address (20 bytes).
     */
    function _contextSuffixLength() internal view virtual override returns (uint256) {
        return 20;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;

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

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] calldata accounts,
        uint256[] calldata ids
    ) external view returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/utils/ERC1155Holder.sol)

pragma solidity ^0.8.0;

import "./ERC1155Receiver.sol";

/**
 * Simple implementation of `ERC1155Receiver` that will allow a contract to hold ERC1155 tokens.
 *
 * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be
 * stuck.
 *
 * @dev _Available since v3.1._
 */
contract ERC1155Holder is ERC1155Receiver {
    function onERC1155Received(
        address,
        address,
        uint256,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155Received.selector;
    }

    function onERC1155BatchReceived(
        address,
        address,
        uint256[] memory,
        uint256[] memory,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155BatchReceived.selector;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/utils/ERC1155Receiver.sol)

pragma solidity ^0.8.0;

import "../IERC1155Receiver.sol";
import "../../../utils/introspection/ERC165.sol";

/**
 * @dev _Available since v3.1._
 */
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
    }
}

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

pragma solidity ^0.8.0;

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/utils/ERC721Holder.sol)

pragma solidity ^0.8.0;

import "../IERC721Receiver.sol";

/**
 * @dev Implementation of the {IERC721Receiver} interface.
 *
 * Accepts all token transfers.
 * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or {IERC721-setApprovalForAll}.
 */
contract ERC721Holder is IERC721Receiver {
    /**
     * @dev See {IERC721Receiver-onERC721Received}.
     *
     * Always returns `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(address, address, uint256, bytes memory) public virtual override returns (bytes4) {
        return this.onERC721Received.selector;
    }
}

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

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

pragma solidity ^0.8.0;

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./math/Math.sol";
import "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

import { IAxelarGateway } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGateway.sol';
import { StringToAddress } from "@axelar-network/axelar-gmp-sdk-solidity/contracts/libs/AddressString.sol";
import { IAxelarGasService } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGasService.sol';
import "@openzeppelin/contracts/utils/Strings.sol";
import "../../types/AddressWithChain.sol";
import "../../interfaces/ICallerBase.sol";
import "./AxelarGatewayBase.sol";

abstract contract AxelarCaller is AxelarGatewayBase, ICallerBase {
    using Strings for address;
    using StringToAddress for string;

    bytes32 constant public AXELAR_CALLER_IDENTIFIER = keccak256("AXELAR_CALLER");

    // ============ Internal Write Functions ============

    function _sendAxelarMessage(
        AddressWithChain memory destination,
        bytes memory payload,
        uint256 gas,
        address gasRefundRecipient
    ) internal {
        string memory destinationString = destination._address.toHexString();
        string memory chainSelector = abi.decode(destination.chainSelector, (string));

        gasService.payNativeGasForContractCall{value: gas}(
            address(this),
            chainSelector,
            destinationString,
            payload,
            gasRefundRecipient
        );
        gateway.callContract(
            chainSelector, 
            destinationString, 
            payload
        );

        emit CrosschainSend(AXELAR_CALLER_IDENTIFIER, destination, abi.encode(gas));
    }

    function execute(
        bytes32 commandId,
        string calldata sourceChain,
        string calldata sourceAddress,
        bytes calldata payload
    ) external {
        bytes32 payloadHash = keccak256(payload);
        if (!gateway.validateContractCall(commandId, sourceChain, sourceAddress, payloadHash))
            revert NotApprovedByGateway();

        AddressWithChain memory source = AddressWithChain({
            chainSelector: abi.encode(sourceChain),
            _address: sourceAddress.toAddress()
        });
        _execute(source, payload);

        emit CrosschainReceive(AXELAR_CALLER_IDENTIFIER, source, "");
    }

    function _execute(
        AddressWithChain memory source,
        bytes calldata payload
    ) internal virtual;
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

import { IAxelarGateway } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGateway.sol';
import { IAxelarGasService } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGasService.sol';

abstract contract AxelarGatewayBase {
    /// @dev Axelar gateway.
    IAxelarGateway public immutable gateway;
    /// @dev Gas service for Axelar.
    IAxelarGasService immutable public gasService;

    error InvalidGasService();
    error InvalidGateway();
    error NotApprovedByGateway();

    constructor(IAxelarGateway _gateway, IAxelarGasService _gasService) {
        if(address(_gateway) == address(0)) revert InvalidGateway();
        if(address(_gasService) == address(0)) revert InvalidGasService();

        gateway = _gateway;
        gasService = _gasService;
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

import "@openzeppelin/contracts/security/Pausable.sol";
import "./EeseeRoleHandler.sol";

abstract contract EeseePausable is Pausable, EeseeRoleHandler {
    ///@dev Pauser role in {accessManager}.
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");

    modifier onlyPauser(){
        _validateRole(PAUSER_ROLE, _msgSender());
        _;
    }

    // ============ Admin Methods ============

    /**
    * @dev Called by the PAUSER_ROLE to pause, triggers stopped state.
    */
    function pause() onlyPauser external virtual {
        _pause();
    }

    /**
     * @dev Called by the PAUSER_ROLE to unpause, returns to normal state.
     */
    function unpause() onlyPauser external virtual {
        _unpause();
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

import "@openzeppelin/contracts/utils/Context.sol";
import "../../interfaces/IEeseeAccessManager.sol";

abstract contract EeseeRoleHandler is Context {
    ///@dev Access manager for Eesee contract ecosystem.
    IEeseeAccessManager public immutable accessManager;

    error CallerNotAuthorized();
    error InvalidAccessManager();

    constructor(IEeseeAccessManager _accessManager) {
        if(address(_accessManager) == address(0)) revert InvalidAccessManager();
        accessManager = _accessManager;
    }

    modifier onlyRole(bytes32 role){
        _validateRole(role, _msgSender());
        _;
    }

    function _hasRole(bytes32 role, address _addr) internal view virtual returns (bool) {
        return accessManager.hasRole(role, _addr);
    }

    function _validateRole(bytes32 role, address _addr) internal view {
        if(!_hasRole(role, _addr)) revert CallerNotAuthorized();
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

error InvalidToken();
error InvalidAmount();
error InsufficientValue();

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../types/AddressWithChain.sol";

interface ICallerBase {
    event CrosschainSend(bytes32 indexed projectIdentifier, AddressWithChain destination, bytes additionalData);
    event CrosschainReceive(bytes32 indexed projectIdentifier, AddressWithChain source, bytes additionalData);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

interface IEeseeAccessManager {
    event RoleGranted(bytes32 indexed role, address indexed account);
    event RoleRevoked(bytes32 indexed role, address indexed account);

    error CallerNotAdmin();

    function hasRole(bytes32 role, address account) external view returns (bool);
    function ADMIN_ROLE() external view returns (bytes32);

    function grantRole(bytes32 role, address account) external;
    function revokeRole(bytes32 role, address account) external;
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

import "../types/Call.sol";
import "../types/AddressWithChain.sol";

interface IEeseeAssetSpoke {  
    function eeseeAssetHub() external view returns (bytes memory chainSelector, address _address);

    function assetsStorage(bytes32) external view returns (
        address token,
        uint256 tokenID,
        uint256 amount,
        AssetType assetType,
        bytes memory data
    );

    event Wrap(
        Asset asset,
        bytes32 indexed assetHash,
        address indexed sender
    );
    event Unwrap(
        Asset asset,
        bytes32 indexed assetHash,
        address indexed recipient
    );

    function wrap(
        Asset[] calldata assets, 
        Call[] calldata crosschainCalls,
        address fallbackRecipient,
        bytes calldata additionalData
    ) external payable returns(uint256 gasPaid);
    function unstuck(bytes32 stuckAssetHash, address recipient) external returns(Asset memory asset);

    function getTokenIdL2(Asset calldata asset) external view returns (uint256);
    function getTokenIdL2(bytes32 assetHash) external view returns (uint256);
    function getAssetHash(Asset calldata asset) external pure returns (bytes32);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;

/// @author: manifold.xyz

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

/**
 * @dev Lookup engine interface
 */
interface IRoyaltyEngineV1 is IERC165 {
    /**
     * Get the royalty for a given token (address, id) and value amount.  Does not cache the bps/amounts.  Caches the spec for a given token address
     *
     * @param tokenAddress - The address of the token
     * @param tokenId      - The id of the token
     * @param value        - The value you wish to get the royalty of
     *
     * returns Two arrays of equal length, royalty recipients and the corresponding amount each recipient should get
     */
    function getRoyalty(address tokenAddress, uint256 tokenId, uint256 value)
        external
        returns (address payable[] memory recipients, uint256[] memory amounts);

    /**
     * View only version of getRoyalty
     *
     * @param tokenAddress - The address of the token
     * @param tokenId      - The id of the token
     * @param value        - The value you wish to get the royalty of
     *
     * returns Two arrays of equal length, royalty recipients and the corresponding amount each recipient should get
     */
    function getRoyaltyView(address tokenAddress, uint256 tokenId, uint256 value)
        external
        view
        returns (address payable[] memory recipients, uint256[] memory amounts);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

import "../types/AddressWithChain.sol";
import "./CompareBytes.sol";
    
error InvalidDestination();

library CompareAddressWithChain {
    using CompareBytes for bytes;

    function eq(AddressWithChain memory a, AddressWithChain memory b) internal pure returns (bool){
        return (a._address == b._address) && a.chainSelector.eq(b.chainSelector);
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;
    
library CompareBytes {
    function eq(bytes memory a, bytes memory b) internal pure returns (bool){
        return (a.length == b.length) && (keccak256(a) == keccak256(b));
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

import "../../../abstract/crosschain/AxelarCaller.sol";
import "../../../libraries/CompareAddressWithChain.sol";
import "./EeseeMessageInterface.sol";

abstract contract AxelarCallerEeseeMessageInterface is AxelarCaller, EeseeMessageInterface {  
    
    // ============ Internal Write Functions ============

    function _sendMessage(
        address /*msgSender*/,
        AddressWithChain memory destination, 
        bytes memory payload,
        uint256 gas,
        bytes calldata additionalData
    ) internal override {
        address gasRefundRecipient = abi.decode(additionalData, (address));
        _sendAxelarMessage(destination, payload, gas, gasRefundRecipient);
    }

    function _execute(AddressWithChain memory source, bytes calldata data) internal override {
        _receiveMessage(source, data);
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/metatx/ERC2771Context.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "../../../libraries/CompareAddressWithChain.sol";
import "../../../types/Call.sol";
import "../../../types/Asset.sol";
import "../../../interfaces/IEeseeAssetSpoke.sol";
import "../../../interfaces/IRoyaltyEngineV1.sol";
import "../../../abstract/roles/EeseePausable.sol";
import "./EeseeMessageInterface.sol";
import "../../../errors/EeseeErrors.sol";

/// @dev Crosschain contract that allows users to wrap their assets and send them to a different chain.
abstract contract EeseeAssetSpokeBase is IEeseeAssetSpoke, ERC2771Context, ERC721Holder, ERC1155Holder, EeseePausable, EeseeMessageInterface {
    using SafeERC20 for IERC20;
    using CompareAddressWithChain for AddressWithChain;
    
    /// @dev AddressWithChain struct for the current contract.
    AddressWithChain public eeseeSpoke;
    /// @dev AddressWithChain struct for EeseeAssetHub contract.
    AddressWithChain public eeseeAssetHub;

    ///@dev The Royalty Engine is a contract that provides an easy way for any marketplace to look up royalties for any given token contract.
    IRoyaltyEngineV1 immutable private royaltyEngine;

    /// @dev Maps asset hash to the asset itself.
    mapping(bytes32 => Asset) public assetsStorage;
    /// @dev Amount of assets stuck for a given account.
    mapping(address => mapping(bytes32 => uint256)) public stuckAmount;

    event Stuck(
        Asset asset,
        bytes32 indexed assetHash,
        address indexed recipient,
        bytes err
    );
    event Unstuck(
        Asset asset,
        bytes32 indexed assetHash,
        address indexed sender, 
        address indexed recipient
    );

    error InvalidConstructor();
    error InvalidSender();
    error InvalidInterface();
    error InvalidTokenID();
    error InvalidAsset();
    error InvalidRecipient();
    error OnlySelf();
    error NoAssetsStuck();
    error TransferNotSuccessful();
    error InvalidAssetsLength();

    modifier onlySelf() {
        if (msg.sender != address(this)) revert OnlySelf();
        _;
    }

    constructor(
        IEeseeAccessManager _accessManager,
        bytes memory _currentChainSelector,
        AddressWithChain memory _eeseeAssetHub,

        IRoyaltyEngineV1 _royaltyEngine,
        address trustedForwarder
    ) ERC2771Context(trustedForwarder) EeseeRoleHandler(_accessManager) {
        if(
            _eeseeAssetHub._address == address(0) ||
            address(_royaltyEngine) == address(0)
        ) revert InvalidConstructor();

        eeseeSpoke = AddressWithChain({chainSelector: _currentChainSelector, _address: address(this)});
        eeseeAssetHub = _eeseeAssetHub;

        royaltyEngine = _royaltyEngine;
    }

    // ============ External Write Functions ============
    
    /**
     * @dev Wraps specified assets and sends them to {recipient} in the form of ERC1155 tokens.
     * @param assets - Assets to wrap.
     * @param crosschainCalls - Calls to make on destination chain. 
     * @param fallbackRecipient - Address to transfer leftover tokens after crosschainCalls. 
     * @param additionalData - Additional information to pass to crosschain protocol. 
     
     * @return gasPaid - Gas paid for the crosschain call.
     */
    function wrap(
        Asset[] calldata assets, 
        Call[] calldata crosschainCalls,
        address fallbackRecipient,
        bytes calldata additionalData
    ) whenNotPaused external payable returns(uint256 gasPaid){
        if(assets.length == 0) revert InvalidAssetsLength();
        if(fallbackRecipient == address(0)) revert InvalidRecipient();
        address msgSender = _msgSender();

        bytes32[] memory assetHashes; uint256[] memory amounts; bytes[] memory royaltyData;
        (assetHashes, amounts, royaltyData, gasPaid) = _wrap(assets, msgSender);
        _sendMessage(
            msgSender,
            eeseeAssetHub,
            abi.encode(assetHashes, amounts, royaltyData, crosschainCalls, fallbackRecipient),
            gasPaid,
            additionalData
        ); 
    }

    /**
     * @dev Reclaim assets that might have been stuck after _unwrap. Emits Unstuck event.
     * Note: Must be called from asset recipient address that had their asset stuck.
     * @param stuckAssetHash - Hash of the asset that got stuck.
     * @param recipient - Address to transfer asset to.
     
     * @return asset - Asset sent to {recipient}.
     */
    function unstuck(bytes32 stuckAssetHash, address recipient) external returns(Asset memory asset){
        if(recipient == address(0)) revert InvalidRecipient();

        address msgSender = _msgSender();
        uint256 _stuckAmount = stuckAmount[msgSender][stuckAssetHash];
        if(_stuckAmount == 0) revert NoAssetsStuck();

        delete stuckAmount[msgSender][stuckAssetHash];
        asset = this._transferAssetTo(stuckAssetHash, _stuckAmount, recipient);
        emit Unstuck(asset, stuckAssetHash, msgSender, recipient);
    }

    // ============ External View Functions ============

    /**
     * @dev Allows calculating token ID on L2 chain before wrapping.
     * @param asset - Asset to calculate token Id for.
     
     * @return uint256 - Calculated token Id for wrapped asset on L2 chain.
     */
    function getTokenIdL2(Asset calldata asset) external view returns (uint256) {
        return getTokenIdL2(getAssetHash(asset));
    }

    // ============ Public View Functions ============

    /**
     * @dev Allows calculating token ID on L2 chain before wrapping.
     * @param assetHash - Asset hash to calculate token Id for.
     
     * @return uint256 - Calculated token Id for wrapped asset on L2 chain.
     */
    function getTokenIdL2(bytes32 assetHash) public view returns (uint256) {
        AssetHashWithSource memory assetHashWithSource = AssetHashWithSource(eeseeSpoke, assetHash);
        return uint256(keccak256(abi.encode(assetHashWithSource)));
    }

    /**
     * @dev Calculates asset hash.
     * @param asset - Asset to calculate asset hash for.
     */
    function getAssetHash(Asset calldata asset) public pure returns (bytes32) {
        return keccak256(abi.encode(asset.token, asset.tokenID, asset.assetType));
    }

    // ============ Internal Write Functions ============

    function _receiveMessage(AddressWithChain memory source, bytes memory data) internal override {
        if(!source.eq(eeseeAssetHub)) revert InvalidSender();

        (bytes32[] memory assetHashes, uint256[] memory amounts, address recipient) = abi.decode(data, (bytes32[], uint256[], address));
        for(uint256 i; i < assetHashes.length;){
            try this._transferAssetTo(assetHashes[i], amounts[i], recipient) returns (Asset memory asset) {
                emit Unwrap(asset, assetHashes[i], recipient);
            } catch (bytes memory err) {
                Asset memory asset = assetsStorage[assetHashes[i]];
                asset.amount = amounts[i];

                stuckAmount[recipient][assetHashes[i]] += amounts[i];
                emit Stuck(asset, assetHashes[i], recipient, err);
            }

            unchecked{ ++i; }
        }
    }

    function _transferAssetTo(bytes32 assetHash, uint256 amount, address to) external onlySelf returns(Asset memory asset){
        asset = assetsStorage[assetHash];
        if(asset.amount < amount) revert InvalidAmount();
        assetsStorage[assetHash].amount = asset.amount - amount;
        asset.amount = amount;

        if (asset.assetType == AssetType.ERC721) {
            IERC721(asset.token).safeTransferFrom(address(this), to, asset.tokenID);
        } else if (asset.assetType == AssetType.ERC1155) {
            IERC1155(asset.token).safeTransferFrom(address(this), to, asset.tokenID, amount, "");
        } else if (asset.assetType == AssetType.ERC20) {
            IERC20(asset.token).safeTransfer(to, amount);
        } else {
            // This is Native asset
            (bool success,) = to.call{value: amount}("");
            if(!success) revert TransferNotSuccessful(); 
        }
    }

    // ============ Internal View Functions =============
    
    function _msgSender() internal view override(Context, ERC2771Context) returns (address) {
        return ERC2771Context._msgSender();
    }

    function _msgData() internal view override(Context, ERC2771Context) returns (bytes calldata) {
        return ERC2771Context._msgData();
    }

    function _contextSuffixLength() internal view override(Context, ERC2771Context) returns (uint256) {
        return ERC2771Context._contextSuffixLength();
    }

    // ============ Private Write Functions =============

    function _wrap(
        Asset[] calldata assets,
        address msgSender
    ) private returns (bytes32[] memory assetHashes, uint256[] memory amounts, bytes[] memory royaltyData, uint256 valueLeft){
        assetHashes = new bytes32[](assets.length);
        amounts = new uint256[](assets.length);
        royaltyData = new bytes[](assets.length);

        valueLeft = msg.value;
        for(uint256 i; i < assets.length;){
            (assetHashes[i], royaltyData[i], amounts[i], valueLeft) = _transferAssetFrom(assets[i], msgSender, valueLeft);
            unchecked{ ++i; }
        }
    }

    function _transferAssetFrom(
        Asset calldata asset, 
        address msgSender, 
        uint256 availableValue
    ) private returns(bytes32 assetHash, bytes memory royaltyData, uint256 amount, uint256 valueLeft){
        valueLeft = availableValue;
        if (asset.assetType == AssetType.ERC721) {
            if(asset.amount != 1) revert InvalidAmount();
            { // Scope to avoid Stack too Deep
            (bool success, bytes memory res) = asset.token.staticcall(abi.encodeWithSelector(IERC165.supportsInterface.selector, type(IERC721).interfaceId));
            if(!success || abi.decode(res, (bool)) == false) revert InvalidInterface();

            (address payable[] memory royaltyRecipients, uint256[] memory royaltyAmounts) = royaltyEngine.getRoyalty(asset.token, asset.tokenID, 10000);
            royaltyData = abi.encode(royaltyRecipients, royaltyAmounts);
            }

            amount = 1;
            IERC721(asset.token).safeTransferFrom(msgSender, address(this), asset.tokenID);
        } else if (asset.assetType == AssetType.ERC1155) {
            if(asset.amount == 0) revert InvalidAmount();
            { // Scope to avoid Stack too Deep
            (bool success, bytes memory res) = asset.token.staticcall(abi.encodeWithSelector(IERC165.supportsInterface.selector, type(IERC1155).interfaceId));
            if(!success || abi.decode(res, (bool)) == false) revert InvalidInterface();

            (address payable[] memory royaltyRecipients, uint256[] memory royaltyAmounts) = royaltyEngine.getRoyalty(asset.token, asset.tokenID, 10000);
            royaltyData = abi.encode(royaltyRecipients, royaltyAmounts);
            }

            amount = asset.amount;
            IERC1155(asset.token).safeTransferFrom(msgSender, address(this), asset.tokenID, asset.amount, "");
        } else if (asset.assetType == AssetType.ERC20) {
            // Most ERC-20 tokens do not implement supportsInterface, so we check against IERC721 to ensure we are not calling ERC721 contract.
            // ERC1155 will revert anyway because of different safeTransferFrom scheme.
            (bool success, bytes memory res) = asset.token.staticcall(abi.encodeWithSelector(IERC165.supportsInterface.selector, type(IERC721).interfaceId));
            if(success && abi.decode(res, (bool)) == true) revert InvalidInterface();
            if(asset.tokenID != 0) revert InvalidTokenID();

            uint256 balanceBefore = IERC20(asset.token).balanceOf(address(this));
            IERC20(asset.token).safeTransferFrom(msgSender, address(this), asset.amount);
            uint256 balanceAfter = IERC20(asset.token).balanceOf(address(this));
            
            // For fee on transfer tokens we compare balances.
            amount = balanceAfter - balanceBefore;
            if(amount == 0) revert InvalidAmount();
        } else if (asset.assetType == AssetType.Native) {
            if(asset.amount == 0) revert InvalidAmount();
            if(availableValue < asset.amount) revert InsufficientValue();
            if(asset.token != address(0)) revert InvalidToken();
            if(asset.tokenID != 0) revert InvalidTokenID();

            unchecked{ valueLeft -= asset.amount; }
            amount = asset.amount;
        } else revert InvalidAsset();

        Asset memory newAsset = Asset({
            token: asset.token,
            tokenID: asset.tokenID,
            amount: amount,
            assetType: asset.assetType,
            data: ""
        });
        assetHash = getAssetHash(asset);
        emit Wrap(newAsset, assetHash, msgSender);

        newAsset.amount += assetsStorage[assetHash].amount;
        assetsStorage[assetHash] = newAsset;
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

import "../../../types/AddressWithChain.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

abstract contract EeseeMessageInterface {
    function _sendMessage(
        address msgSender,
        AddressWithChain memory destination, 
        bytes memory payload,
        uint256 gas,
        bytes calldata additionalData
    ) internal virtual;

    function _receiveMessage(AddressWithChain memory source, bytes memory data) internal virtual;
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

import "./Asset.sol";

struct AddressWithChain{
    bytes chainSelector;
    address _address;
}

struct AssetHashWithSource {
    AddressWithChain source;
    bytes32 assetHash;
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

enum AssetType {
    ERC721,
    ERC1155,
    ERC20,
    Native,
    ESE,
    ERC721LazyMint
}
/**
 * @dev Asset:
 * {token} - Token contract address.
 * {tokenID} - Token ID. 
 * {amount} - Amount of tokens transfered. 
 * {assetType} - Asset interface type. 
 * {data} - Additional data included with the asset. 
 */
struct Asset {
    address token;
    uint256 tokenID;
    uint256 amount;
    AssetType assetType;
    bytes data;
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

struct Call {
    address target;
    bytes callData;
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IEeseeAccessManager","name":"_accessManager","type":"address"},{"internalType":"bytes","name":"_currentChainSelector","type":"bytes"},{"components":[{"internalType":"bytes","name":"chainSelector","type":"bytes"},{"internalType":"address","name":"_address","type":"address"}],"internalType":"struct AddressWithChain","name":"_eeseeAssetHub","type":"tuple"},{"internalType":"contract IRoyaltyEngineV1","name":"_royaltyEngine","type":"address"},{"internalType":"contract IAxelarGateway","name":"_gateway","type":"address"},{"internalType":"contract IAxelarGasService","name":"_gasService","type":"address"},{"internalType":"address","name":"trustedForwarder","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"CallerNotAuthorized","type":"error"},{"inputs":[],"name":"InsufficientValue","type":"error"},{"inputs":[],"name":"InvalidAccessManager","type":"error"},{"inputs":[],"name":"InvalidAddressString","type":"error"},{"inputs":[],"name":"InvalidAmount","type":"error"},{"inputs":[],"name":"InvalidAsset","type":"error"},{"inputs":[],"name":"InvalidAssetsLength","type":"error"},{"inputs":[],"name":"InvalidConstructor","type":"error"},{"inputs":[],"name":"InvalidGasService","type":"error"},{"inputs":[],"name":"InvalidGateway","type":"error"},{"inputs":[],"name":"InvalidInterface","type":"error"},{"inputs":[],"name":"InvalidRecipient","type":"error"},{"inputs":[],"name":"InvalidSender","type":"error"},{"inputs":[],"name":"InvalidToken","type":"error"},{"inputs":[],"name":"InvalidTokenID","type":"error"},{"inputs":[],"name":"NoAssetsStuck","type":"error"},{"inputs":[],"name":"NotApprovedByGateway","type":"error"},{"inputs":[],"name":"OnlySelf","type":"error"},{"inputs":[],"name":"TransferNotSuccessful","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"projectIdentifier","type":"bytes32"},{"components":[{"internalType":"bytes","name":"chainSelector","type":"bytes"},{"internalType":"address","name":"_address","type":"address"}],"indexed":false,"internalType":"struct AddressWithChain","name":"source","type":"tuple"},{"indexed":false,"internalType":"bytes","name":"additionalData","type":"bytes"}],"name":"CrosschainReceive","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"projectIdentifier","type":"bytes32"},{"components":[{"internalType":"bytes","name":"chainSelector","type":"bytes"},{"internalType":"address","name":"_address","type":"address"}],"indexed":false,"internalType":"struct AddressWithChain","name":"destination","type":"tuple"},{"indexed":false,"internalType":"bytes","name":"additionalData","type":"bytes"}],"name":"CrosschainSend","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"tokenID","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"enum AssetType","name":"assetType","type":"uint8"},{"internalType":"bytes","name":"data","type":"bytes"}],"indexed":false,"internalType":"struct Asset","name":"asset","type":"tuple"},{"indexed":true,"internalType":"bytes32","name":"assetHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"bytes","name":"err","type":"bytes"}],"name":"Stuck","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"tokenID","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"enum AssetType","name":"assetType","type":"uint8"},{"internalType":"bytes","name":"data","type":"bytes"}],"indexed":false,"internalType":"struct Asset","name":"asset","type":"tuple"},{"indexed":true,"internalType":"bytes32","name":"assetHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"}],"name":"Unstuck","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"tokenID","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"enum AssetType","name":"assetType","type":"uint8"},{"internalType":"bytes","name":"data","type":"bytes"}],"indexed":false,"internalType":"struct Asset","name":"asset","type":"tuple"},{"indexed":true,"internalType":"bytes32","name":"assetHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"}],"name":"Unwrap","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"tokenID","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"enum AssetType","name":"assetType","type":"uint8"},{"internalType":"bytes","name":"data","type":"bytes"}],"indexed":false,"internalType":"struct Asset","name":"asset","type":"tuple"},{"indexed":true,"internalType":"bytes32","name":"assetHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"Wrap","type":"event"},{"inputs":[],"name":"AXELAR_CALLER_IDENTIFIER","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAUSER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"assetHash","type":"bytes32"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"_transferAssetTo","outputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"tokenID","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"enum AssetType","name":"assetType","type":"uint8"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct Asset","name":"asset","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"accessManager","outputs":[{"internalType":"contract IEeseeAccessManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"assetsStorage","outputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"tokenID","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"enum AssetType","name":"assetType","type":"uint8"},{"internalType":"bytes","name":"data","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"eeseeAssetHub","outputs":[{"internalType":"bytes","name":"chainSelector","type":"bytes"},{"internalType":"address","name":"_address","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"eeseeSpoke","outputs":[{"internalType":"bytes","name":"chainSelector","type":"bytes"},{"internalType":"address","name":"_address","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"commandId","type":"bytes32"},{"internalType":"string","name":"sourceChain","type":"string"},{"internalType":"string","name":"sourceAddress","type":"string"},{"internalType":"bytes","name":"payload","type":"bytes"}],"name":"execute","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"gasService","outputs":[{"internalType":"contract IAxelarGasService","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gateway","outputs":[{"internalType":"contract IAxelarGateway","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"tokenID","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"enum AssetType","name":"assetType","type":"uint8"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct Asset","name":"asset","type":"tuple"}],"name":"getAssetHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes32","name":"assetHash","type":"bytes32"}],"name":"getTokenIdL2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"tokenID","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"enum AssetType","name":"assetType","type":"uint8"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct Asset","name":"asset","type":"tuple"}],"name":"getTokenIdL2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"forwarder","type":"address"}],"name":"isTrustedForwarder","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"stuckAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"stuckAssetHash","type":"bytes32"},{"internalType":"address","name":"recipient","type":"address"}],"name":"unstuck","outputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"tokenID","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"enum AssetType","name":"assetType","type":"uint8"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct Asset","name":"asset","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"tokenID","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"enum AssetType","name":"assetType","type":"uint8"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct Asset[]","name":"assets","type":"tuple[]"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Call[]","name":"crosschainCalls","type":"tuple[]"},{"internalType":"address","name":"fallbackRecipient","type":"address"},{"internalType":"bytes","name":"additionalData","type":"bytes"}],"name":"wrap","outputs":[{"internalType":"uint256","name":"gasPaid","type":"uint256"}],"stateMutability":"payable","type":"function"}]

61012060405234801562000011575f80fd5b5060405162005031380380620050318339810160408190526200003491620002e3565b6001600160a01b038082166080525f805460ff191690558790879087908790859088908890879081166200007b576040516354c0aa7160e11b815260040160405180910390fd5b6001600160a01b0390811660a0528216620000a95760405163fc9dfe8560e01b815260040160405180910390fd5b6001600160a01b038116620000d1576040516304459e0d60e01b815260040160405180910390fd5b6001600160a01b0391821660c052811660e0526020840151161580620000fe57506001600160a01b038216155b156200011d576040516312c1701b60e01b815260040160405180910390fd5b604080518082019091528481523060208201526001806200013f87826200047b565b5060209190910151600190910180546001600160a01b0319166001600160a01b039092169190911790558251839060039081906200017e90826200047b565b5060209190910151600190910180546001600160a01b0319166001600160a01b03928316179055919091166101005250620005439950505050505050505050565b6001600160a01b0381168114620001d4575f80fd5b50565b634e487b7160e01b5f52604160045260245ffd5b604080519081016001600160401b0381118282101715620002105762000210620001d7565b60405290565b604051601f8201601f191681016001600160401b0381118282101715620002415762000241620001d7565b604052919050565b5f82601f83011262000259575f80fd5b81516001600160401b03811115620002755762000275620001d7565b60206200028b601f8301601f1916820162000216565b82815285828487010111156200029f575f80fd5b5f5b83811015620002be578581018301518282018401528201620002a1565b505f928101909101919091529392505050565b8051620002de81620001bf565b919050565b5f805f805f805f60e0888a031215620002fa575f80fd5b87516200030781620001bf565b60208901519097506001600160401b038082111562000324575f80fd5b620003328b838c0162000249565b975060408a015191508082111562000348575f80fd5b908901906040828c0312156200035c575f80fd5b62000366620001eb565b82518281111562000375575f80fd5b620003838d82860162000249565b825250602083015192506200039883620001bf565b6020810192909252509450620003b160608901620002d1565b9350620003c160808901620002d1565b9250620003d160a08901620002d1565b9150620003e160c08901620002d1565b905092959891949750929550565b600181811c908216806200040457607f821691505b6020821081036200042357634e487b7160e01b5f52602260045260245ffd5b50919050565b601f82111562000476575f81815260208120601f850160051c81016020861015620004515750805b601f850160051c820191505b8181101562000472578281556001016200045d565b5050505b505050565b81516001600160401b03811115620004975762000497620001d7565b620004af81620004a88454620003ef565b8462000429565b602080601f831160018114620004e5575f8415620004cd5750858301515b5f19600386901b1c1916600185901b17855562000472565b5f85815260208120601f198616915b828110156200051557888601518255948401946001909101908401620004f4565b50858210156200053357878501515f19600388901b60f8161c191681555b5050505050600190811b01905550565b60805160a05160c05160e05161010051614a86620005ab5f395f8181612302015261267901525f81816103c60152612f0f01525f81816101cc01528181610a440152612fd701525f81816105b20152611b4201525f81816103620152611a900152614a865ff3fe608060405260043610610183575f3560e01c80637a067255116100d1578063bc197c811161007c578063e63ab1e911610057578063e63ab1e91461052a578063f23a6e611461055d578063fdcb6068146105a1575f80fd5b8063bc197c8114610497578063d3ab67ba146104db578063dcc043fc146104fa575f80fd5b8063930da04f116100ac578063930da04f14610423578063b1d8a71314610459578063b91e1f9c14610478575f80fd5b80637a067255146103e85780638456cb59146103fc5780638a6c5ceb14610410575f80fd5b80633c29d28011610131578063572b6c051161010c578063572b6c05146103465780635c975abb1461039f5780636a22d8cc146103b5575f80fd5b80633c29d280146102ef5780633f4ba83a146103115780634916065814610327575f80fd5b8063189a271011610161578063189a2710146102635780632e4e4c93146102a4578063304459df146102d0575f80fd5b806301ffc9a714610187578063116191b6146101bb578063150b7a0214610213575b5f80fd5b348015610192575f80fd5b506101a66101a1366004613703565b6105d4565b60405190151581526020015b60405180910390f35b3480156101c6575f80fd5b506101ee7f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020016101b2565b34801561021e575f80fd5b5061023261022d366004613866565b61066c565b6040517fffffffff0000000000000000000000000000000000000000000000000000000090911681526020016101b2565b34801561026e575f80fd5b506102967f9704e740724167f66f8683fc2859adcb322555b4cfad4e7e226cba25a757642681565b6040519081526020016101b2565b3480156102af575f80fd5b506102c36102be3660046138ce565b610696565b6040516101b29190613a0a565b3480156102db575f80fd5b506102966102ea366004613a1c565b6108b5565b3480156102fa575f80fd5b50610303610907565b6040516101b2929190613a53565b34801561031c575f80fd5b506103256109b3565b005b348015610332575f80fd5b50610325610341366004613acf565b6109ee565b348015610351575f80fd5b506101a6610360366004613b6b565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff90811691161490565b3480156103aa575f80fd5b505f5460ff166101a6565b3480156103c0575f80fd5b506101ee7f000000000000000000000000000000000000000000000000000000000000000081565b3480156103f3575f80fd5b50610303610bee565b348015610407575f80fd5b50610325610bfd565b61029661041e366004613bc7565b610c31565b34801561042e575f80fd5b5061029661043d366004613c4e565b600660209081525f928352604080842090915290825290205481565b348015610464575f80fd5b50610296610473366004613c78565b610e22565b348015610483575f80fd5b50610296610492366004613a1c565b610f27565b3480156104a2575f80fd5b506102326104b1366004613d15565b7fbc197c810000000000000000000000000000000000000000000000000000000095945050505050565b3480156104e6575f80fd5b506102c36104f5366004613dbc565b610f34565b348015610505575f80fd5b50610519610514366004613c78565b611349565b6040516101b2959493929190613df2565b348015610535575f80fd5b506102967f65d7a28e3265b37a6474929f336521b332c1681b933f6cb9f3376673440d862a81565b348015610568575f80fd5b50610232610577366004613e39565b7ff23a6e610000000000000000000000000000000000000000000000000000000095945050505050565b3480156105ac575f80fd5b506101ee7f000000000000000000000000000000000000000000000000000000000000000081565b5f7fffffffff0000000000000000000000000000000000000000000000000000000082167f4e2312e000000000000000000000000000000000000000000000000000000000148061066657507f01ffc9a7000000000000000000000000000000000000000000000000000000007fffffffff000000000000000000000000000000000000000000000000000000008316145b92915050565b7f150b7a02000000000000000000000000000000000000000000000000000000005b949350505050565b6106c76040805160a0810182525f808252602082018190529181018290529060608201908152602001606081525090565b73ffffffffffffffffffffffffffffffffffffffff8216610714576040517f9c8d2cd200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f61071d61141a565b73ffffffffffffffffffffffffffffffffffffffff81165f908152600660209081526040808320888452909152812054919250819003610789576040517f7bf3eb0400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff8281165f90815260066020908152604080832089845290915280822091909155517fd3ab67ba00000000000000000000000000000000000000000000000000000000815260048101879052602481018390529085166044820152309063d3ab67ba906064015f604051808303815f875af115801561081e573d5f803e3d5ffd5b505050506040513d5f823e601f3d908101601f191682016040526108459190810190613ed7565b92508373ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16867f2445a7a5b1a7edc6a2c39f91c4f267c5ec90ac3f57903cf878d5d54ed66a41d9866040516108a59190613a0a565b60405180910390a4505092915050565b5f6108c36020830183613b6b565b60208301356108d86080850160608601613f91565b6040516020016108ea93929190613fac565b604051602081830303815290604052805190602001209050919050565b60038054819061091690613fdd565b80601f016020809104026020016040519081016040528092919081815260200182805461094290613fdd565b801561098d5780601f106109645761010080835404028352916020019161098d565b820191905f5260205f20905b81548152906001019060200180831161097057829003601f168201915b5050506001909301549192505073ffffffffffffffffffffffffffffffffffffffff1682565b6109e47f65d7a28e3265b37a6474929f336521b332c1681b933f6cb9f3376673440d862a6109df61141a565b611428565b6109ec61146c565b565b5f82826040516109ff92919061402e565b6040519081900381207f5f6970c3000000000000000000000000000000000000000000000000000000008252915073ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001690635f6970c390610a83908b908b908b908b908b908990600401614066565b6020604051808303815f875af1158015610a9f573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610ac391906140a6565b610af9576040517f500c44b400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b604080518082019091525f9080610b148a8a606084016140c5565b6040516020818303038152906040528152602001610b6688888080601f0160208091040260200160405190810160405280939291908181526020018383808284375f920191909152506114ee92505050565b73ffffffffffffffffffffffffffffffffffffffff1690529050610b8b818585611704565b7f9704e740724167f66f8683fc2859adcb322555b4cfad4e7e226cba25a75764267f3817f0838f4d3a072ca097714c1f963bb23ed356cdcd47eaf7d0aae157d869a382604051610bdb9190614116565b60405180910390a2505050505050505050565b60018054819061091690613fdd565b610c297f65d7a28e3265b37a6474929f336521b332c1681b933f6cb9f3376673440d862a6109df61141a565b6109ec611748565b5f610c3a6117a3565b5f879003610c74576040517fb6ea7e2700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff8416610cc1576040517f9c8d2cd200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f610cca61141a565b90506060806060610cdc8c8c86611814565b80985081945082955083965050505050610e138460036040518060400160405290815f82018054610d0c90613fdd565b80601f0160208091040260200160405190810160405280929190818152602001828054610d3890613fdd565b8015610d835780601f10610d5a57610100808354040283529160200191610d83565b820191905f5260205f20905b815481529060010190602001808311610d6657829003601f168201915b50505050508152602001600182015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815250508585858f8f8f604051602001610dfc96959493929190614287565b604051602081830303815290604052888b8b61199a565b50505050979650505050505050565b5f80604051806040016040528060016040518060400160405290815f82018054610e4b90613fdd565b80601f0160208091040260200160405190810160405280929190818152602001828054610e7790613fdd565b8015610ec25780601f10610e9957610100808354040283529160200191610ec2565b820191905f5260205f20905b815481529060010190602001808311610ea557829003601f168201915b50505091835250506001919091015473ffffffffffffffffffffffffffffffffffffffff16602091820152908252908101859052604051919250610f0891839101614361565b60408051601f1981840301815291905280516020909101209392505050565b5f610666610473836108b5565b610f656040805160a0810182525f808252602082018190529181018290529060608201908152602001606081525090565b333014610f9e576040517f14d4a4e800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f84815260056020818152604092839020835160a081018552815473ffffffffffffffffffffffffffffffffffffffff1681526001820154928101929092526002810154938201939093526003830154909291606084019160ff1690811115611009576110096138fc565b600581111561101a5761101a6138fc565b815260200160048201805461102e90613fdd565b80601f016020809104026020016040519081016040528092919081815260200182805461105a90613fdd565b80156110a55780601f1061107c576101008083540402835291602001916110a5565b820191905f5260205f20905b81548152906001019060200180831161108857829003601f168201915b505050505081525050905082816040015110156110ee576040517f2c5211c600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8281604001516110fe91906143bf565b5f85815260056020526040808220600201929092559082018490528160600151600581111561112f5761112f6138fc565b036111cb57805160208201516040517f42842e0e00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff858116602483015260448201929092529116906342842e0e906064015b5f604051808303815f87803b1580156111b0575f80fd5b505af11580156111c2573d5f803e3d5ffd5b50505050611342565b6001816060015160058111156111e3576111e36138fc565b0361126557805160208201516040517ff242432a00000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff858116602483015260448201929092526064810186905260a060848201525f60a482015291169063f242432a9060c401611199565b60028160600151600581111561127d5761127d6138fc565b036112aa5780516112a59073ffffffffffffffffffffffffffffffffffffffff1683856119be565b611342565b5f8273ffffffffffffffffffffffffffffffffffffffff16846040515f6040518083038185875af1925050503d805f8114611300576040519150601f19603f3d011682016040523d82523d5f602084013e611305565b606091505b5050905080611340576040517fa392ef7800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b505b9392505050565b60056020525f90815260409020805460018201546002830154600384015460048501805473ffffffffffffffffffffffffffffffffffffffff909516959394929360ff9092169261139990613fdd565b80601f01602080910402602001604051908101604052809291908181526020018280546113c590613fdd565b80156114105780601f106113e757610100808354040283529160200191611410565b820191905f5260205f20905b8154815290600101906020018083116113f357829003601f168201915b5050505050905085565b5f611423611a74565b905090565b6114328282611af4565b611468576040517fc183bcef00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5050565b611474611bad565b5f80547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001690557f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa6114c461141a565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390a1565b5f808290505f808251602a14158061155f5750825f81518110611513576115136143d2565b6020910101517fff00000000000000000000000000000000000000000000000000000000000000167f300000000000000000000000000000000000000000000000000000000000000014155b806115c4575082600181518110611578576115786143d2565b6020910101517fff00000000000000000000000000000000000000000000000000000000000000167f780000000000000000000000000000000000000000000000000000000000000014155b156115fb576040517fdf48f19e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60025b602a8110156116fa57838181518110611619576116196143d2565b016020015160f81c915060618210801590611638575060668260ff1611155b1561164f576116486057836143ff565b91506116d1565b60418260ff1610158015611667575060468260ff1611155b15611677576116486037836143ff565b60308260ff161015801561168f575060398260ff1611155b1561169f576116486030836143ff565b6040517fdf48f19e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60026116de8260296143bf565b60ff8416911b1b92909217916116f381614418565b90506115fe565b5090949350505050565b6117438383838080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250611c1892505050565b505050565b6117506117a3565b5f80547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001660011790557f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a2586114c461141a565b5f5460ff16156109ec576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601060248201527f5061757361626c653a207061757365640000000000000000000000000000000060448201526064015b60405180910390fd5b606080805f8567ffffffffffffffff81111561183257611832613766565b60405190808252806020026020018201604052801561185b578160200160208202803683370190505b5093508567ffffffffffffffff81111561187757611877613766565b6040519080825280602002602001820160405280156118a0578160200160208202803683370190505b5092508567ffffffffffffffff8111156118bc576118bc613766565b6040519080825280602002602001820160405280156118ef57816020015b60608152602001906001900390816118da5790505b5091503490505f5b868110156119905761192d888883818110611914576119146143d2565b9050602002810190611926919061444f565b878461212c565b88858151811061193f5761193f6143d2565b60200260200101878681518110611958576119586143d2565b60200260200101898781518110611971576119716143d2565b60209081029190910101939093529290915291905291506001016118f7565b5093509350935093565b5f6119a782840184613b6b565b90506119b586868684612ecd565b50505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff83166024820152604481018290526117439084907fa9059cbb00000000000000000000000000000000000000000000000000000000906064015b60408051601f198184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff00000000000000000000000000000000000000000000000000000000909316929092179091526130c1565b5f3660143373ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000016148015611abd5750808210155b15611aec575f36611ace83856143bf565b611ad992829061448b565b611ae2916144b2565b60601c9250505090565b339250505090565b6040517f91d148540000000000000000000000000000000000000000000000000000000081526004810183905273ffffffffffffffffffffffffffffffffffffffff82811660248301525f917f0000000000000000000000000000000000000000000000000000000000000000909116906391d1485490604401602060405180830381865afa158015611b89573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061134291906140a6565b5f5460ff166109ec576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601460248201527f5061757361626c653a206e6f7420706175736564000000000000000000000000604482015260640161180b565b611ce060036040518060400160405290815f82018054611c3790613fdd565b80601f0160208091040260200160405190810160405280929190818152602001828054611c6390613fdd565b8015611cae5780601f10611c8557610100808354040283529160200191611cae565b820191905f5260205f20905b815481529060010190602001808311611c9157829003601f168201915b50505091835250506001919091015473ffffffffffffffffffffffffffffffffffffffff1660209091015283906131ce565b611d16576040517fddb5de5e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f805f83806020019051810190611d2d9190614562565b9250925092505f5b8351811015612124573073ffffffffffffffffffffffffffffffffffffffff1663d3ab67ba858381518110611d6c57611d6c6143d2565b6020026020010151858481518110611d8657611d866143d2565b60209081029190910101516040517fffffffff0000000000000000000000000000000000000000000000000000000060e085901b1681526004810192909252602482015273ffffffffffffffffffffffffffffffffffffffff851660448201526064015f604051808303815f875af1925050508015611e2657506040513d5f823e601f3d908101601f19168201604052611e239190810190613ed7565b60015b6120b2573d808015611e53576040519150601f19603f3d011682016040523d82523d5f602084013e611e58565b606091505b505f60055f878581518110611e6f57611e6f6143d2565b60209081029190910181015182528181019290925260409081015f20815160a081018352815473ffffffffffffffffffffffffffffffffffffffff1681526001820154938101939093526002810154918301919091526003810154606083019060ff166005811115611ee357611ee36138fc565b6005811115611ef457611ef46138fc565b8152602001600482018054611f0890613fdd565b80601f0160208091040260200160405190810160405280929190818152602001828054611f3490613fdd565b8015611f7f5780601f10611f5657610100808354040283529160200191611f7f565b820191905f5260205f20905b815481529060010190602001808311611f6257829003601f168201915b5050505050815250509050848381518110611f9c57611f9c6143d2565b6020026020010151816040018181525050848381518110611fbf57611fbf6143d2565b602002602001015160065f8673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f888681518110612017576120176143d2565b602002602001015181526020019081526020015f205f82825461203a9190614627565b925050819055508373ffffffffffffffffffffffffffffffffffffffff1686848151811061206a5761206a6143d2565b60200260200101517f9c5213ceb3db848b993648ea1ab0ca13546ba1324f4449896c19e1364aa6a86d83856040516120a392919061463a565b60405180910390a3505061211c565b8273ffffffffffffffffffffffffffffffffffffffff168583815181106120db576120db6143d2565b60200260200101517fc6a2afadf1ebfd54446c8605e86fcfe42de70be298016f8daa5eacedd303c55e836040516121129190613a0a565b60405180910390a3505b600101611d35565b505050505050565b5f60608183816121426080890160608a01613f91565b6005811115612153576121536138fc565b036124a8578660400135600114612196576040517f2c5211c600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f806121a560208a018a613b6b565b604080517f80ac58cd0000000000000000000000000000000000000000000000000000000060248083019190915282518083039091018152604490910182526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f01ffc9a700000000000000000000000000000000000000000000000000000000179052905173ffffffffffffffffffffffffffffffffffffffff92909216916122529190614667565b5f60405180830381855afa9150503d805f811461228a576040519150601f19603f3d011682016040523d82523d5f602084013e61228f565b606091505b50915091508115806122b25750808060200190518101906122b091906140a6565b155b156122e9576040517f82542ee100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f8073ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001663f533b80261233460208e018e613b6b565b6040517fffffffff0000000000000000000000000000000000000000000000000000000060e084901b16815273ffffffffffffffffffffffffffffffffffffffff909116600482015260208e0135602482015261271060448201526064015f604051808303815f875af11580156123ad573d5f803e3d5ffd5b505050506040513d5f823e601f3d908101601f191682016040526123d49190810190614678565b9150915081816040516020016123eb929190614737565b60408051601f198184030181529190529650600195506124149350505060208901905088613b6b565b6040517f42842e0e00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff888116600483015230602483015260208a0135604483015291909116906342842e0e906064015b5f604051808303815f87803b15801561248d575f80fd5b505af115801561249f573d5f803e3d5ffd5b50505050612cf4565b60016124ba6080890160608a01613f91565b60058111156124cb576124cb6138fc565b036128085786604001355f0361250d576040517f2c5211c600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f8061251c60208a018a613b6b565b604080517fd9b67a260000000000000000000000000000000000000000000000000000000060248083019190915282518083039091018152604490910182526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f01ffc9a700000000000000000000000000000000000000000000000000000000179052905173ffffffffffffffffffffffffffffffffffffffff92909216916125c99190614667565b5f60405180830381855afa9150503d805f8114612601576040519150601f19603f3d011682016040523d82523d5f602084013e612606565b606091505b509150915081158061262957508080602001905181019061262791906140a6565b155b15612660576040517f82542ee100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f8073ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001663f533b8026126ab60208e018e613b6b565b6040517fffffffff0000000000000000000000000000000000000000000000000000000060e084901b16815273ffffffffffffffffffffffffffffffffffffffff909116600482015260208e0135602482015261271060448201526064015f604051808303815f875af1158015612724573d5f803e3d5ffd5b505050506040513d5f823e601f3d908101601f1916820160405261274b9190810190614678565b915091508181604051602001612762929190614737565b60408051601f198184030181529181529097508b0135955061278d9350505060208901905088613b6b565b604080517ff242432a00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff898116600483015230602483015260208b01356044830152918a0135606482015260a060848201525f60a482015291169063f242432a9060c401612476565b600261281a6080890160608a01613f91565b600581111561282b5761282b6138fc565b03612b79575f8061283f60208a018a613b6b565b604080517f80ac58cd0000000000000000000000000000000000000000000000000000000060248083019190915282518083039091018152604490910182526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f01ffc9a700000000000000000000000000000000000000000000000000000000179052905173ffffffffffffffffffffffffffffffffffffffff92909216916128ec9190614667565b5f60405180830381855afa9150503d805f8114612924576040519150601f19603f3d011682016040523d82523d5f602084013e612929565b606091505b509150915081801561295057508080602001905181019061294a91906140a6565b15156001145b15612987576040517f82542ee100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6020890135156129c3576040517f6aa2a93700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f6129d160208b018b613b6b565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff91909116906370a0823190602401602060405180830381865afa158015612a3b573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190612a5f91906147a3565b9050612a96893060408d0135612a7860208f018f613b6b565b73ffffffffffffffffffffffffffffffffffffffff1692919061321a565b5f612aa460208c018c613b6b565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff91909116906370a0823190602401602060405180830381865afa158015612b0e573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190612b3291906147a3565b9050612b3e82826143bf565b9550855f0361249f576040517f2c5211c600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6003612b8b6080890160608a01613f91565b6005811115612b9c57612b9c6138fc565b03612cc25786604001355f03612bde576040517f2c5211c600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8660400135851015612c1c576040517f1101129400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f612c2a6020890189613b6b565b73ffffffffffffffffffffffffffffffffffffffff1614612c77576040517fc1ab6dc100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b602087013515612cb3576040517f6aa2a93700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60408701359150819003612cf4565b6040517fc891add200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040805160a081019091525f9080612d0f60208b018b613b6b565b73ffffffffffffffffffffffffffffffffffffffff16815260200189602001358152602001848152602001896060016020810190612d4d9190613f91565b6005811115612d5e57612d5e6138fc565b81526040805160208181019092525f81529101529050612d7d886108b5565b94508673ffffffffffffffffffffffffffffffffffffffff16857f9a61202d4571e4f9eeba5727678308b886cced3316e6b8c51852296225baaca983604051612dc69190613a0a565b60405180910390a35f8581526005602052604090819020600201549082018051612df1908390614627565b9052505f85815260056020818152604092839020845181547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff90911617815590840151600180830191909155928401516002820155606084015160038201805486959394929391927fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0090911691908490811115612ea657612ea66138fc565b021790555060808201516004820190612ebf90826147ff565b509050505093509350935093565b5f612ef1856020015173ffffffffffffffffffffffffffffffffffffffff1661327e565b90505f855f0151806020019051810190612f0b91906148f9565b90507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16630c93e3bb853084868a896040518763ffffffff1660e01b8152600401612f6f95949392919061493e565b5f604051808303818588803b158015612f86575f80fd5b505af1158015612f98573d5f803e3d5ffd5b50506040517f1c92115f00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000169350631c92115f92506130139150849086908a906004016149a9565b5f604051808303815f87803b15801561302a575f80fd5b505af115801561303c573d5f803e3d5ffd5b505050507f9704e740724167f66f8683fc2859adcb322555b4cfad4e7e226cba25a75764267f729807e38d6280bb962b54ecdd4ccee50dcea58fe3a707d5855d0eb67a45a277878660405160200161309691815260200190565b60408051601f19818403018152908290526130b192916149e1565b60405180910390a2505050505050565b5f613122826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166132a19092919063ffffffff16565b905080515f148061314257508080602001905181019061314291906140a6565b611743576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f74207375636365656400000000000000000000000000000000000000000000606482015260840161180b565b5f816020015173ffffffffffffffffffffffffffffffffffffffff16836020015173ffffffffffffffffffffffffffffffffffffffff16148015611342575081518351611342916132af565b60405173ffffffffffffffffffffffffffffffffffffffff808516602483015283166044820152606481018290526132789085907f23b872dd0000000000000000000000000000000000000000000000000000000090608401611a10565b50505050565b606061066673ffffffffffffffffffffffffffffffffffffffff831660146132d3565b606061068e84845f85613510565b5f815183511480156113425750508051602091820120825192909101919091201490565b60605f6132e18360026149f3565b6132ec906002614627565b67ffffffffffffffff81111561330457613304613766565b6040519080825280601f01601f19166020018201604052801561332e576020820181803683370190505b5090507f3000000000000000000000000000000000000000000000000000000000000000815f81518110613364576133646143d2565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff191690815f1a9053507f7800000000000000000000000000000000000000000000000000000000000000816001815181106133c6576133c66143d2565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff191690815f1a9053505f6134008460026149f3565b61340b906001614627565b90505b60018111156134a7577f303132333435363738396162636465660000000000000000000000000000000085600f166010811061344c5761344c6143d2565b1a60f81b828281518110613462576134626143d2565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff191690815f1a90535060049490941c936134a081614a0a565b905061340e565b508315611342576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f537472696e67733a20686578206c656e67746820696e73756666696369656e74604482015260640161180b565b6060824710156135a2576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c0000000000000000000000000000000000000000000000000000606482015260840161180b565b5f808673ffffffffffffffffffffffffffffffffffffffff1685876040516135ca9190614667565b5f6040518083038185875af1925050503d805f8114613604576040519150601f19603f3d011682016040523d82523d5f602084013e613609565b606091505b509150915061361a87838387613625565b979650505050505050565b606083156136ba5782515f036136b35773ffffffffffffffffffffffffffffffffffffffff85163b6136b3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640161180b565b508161068e565b61068e83838151156136cf5781518083602001fd5b806040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161180b9190614a3e565b5f60208284031215613713575f80fd5b81357fffffffff0000000000000000000000000000000000000000000000000000000081168114611342575f80fd5b73ffffffffffffffffffffffffffffffffffffffff81168114613763575f80fd5b50565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b60405160a0810167ffffffffffffffff811182821017156137b6576137b6613766565b60405290565b604051601f8201601f1916810167ffffffffffffffff811182821017156137e5576137e5613766565b604052919050565b5f67ffffffffffffffff82111561380657613806613766565b50601f01601f191660200190565b5f82601f830112613823575f80fd5b8135613836613831826137ed565b6137bc565b81815284602083860101111561384a575f80fd5b816020850160208301375f918101602001919091529392505050565b5f805f8060808587031215613879575f80fd5b843561388481613742565b9350602085013561389481613742565b925060408501359150606085013567ffffffffffffffff8111156138b6575f80fd5b6138c287828801613814565b91505092959194509250565b5f80604083850312156138df575f80fd5b8235915060208301356138f181613742565b809150509250929050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602160045260245ffd5b6006811061395e577f4e487b71000000000000000000000000000000000000000000000000000000005f52602160045260245ffd5b9052565b5f5b8381101561397c578181015183820152602001613964565b50505f910152565b5f815180845261399b816020860160208601613962565b601f01601f19169290920160200192915050565b73ffffffffffffffffffffffffffffffffffffffff815116825260208101516020830152604081015160408301525f60608201516139f06060850182613929565b50608082015160a0608085015261068e60a0850182613984565b602081525f61134260208301846139af565b5f60208284031215613a2c575f80fd5b813567ffffffffffffffff811115613a42575f80fd5b820160a08185031215611342575f80fd5b604081525f613a656040830185613984565b905073ffffffffffffffffffffffffffffffffffffffff831660208301529392505050565b5f8083601f840112613a9a575f80fd5b50813567ffffffffffffffff811115613ab1575f80fd5b602083019150836020828501011115613ac8575f80fd5b9250929050565b5f805f805f805f6080888a031215613ae5575f80fd5b87359650602088013567ffffffffffffffff80821115613b03575f80fd5b613b0f8b838c01613a8a565b909850965060408a0135915080821115613b27575f80fd5b613b338b838c01613a8a565b909650945060608a0135915080821115613b4b575f80fd5b50613b588a828b01613a8a565b989b979a50959850939692959293505050565b5f60208284031215613b7b575f80fd5b813561134281613742565b5f8083601f840112613b96575f80fd5b50813567ffffffffffffffff811115613bad575f80fd5b6020830191508360208260051b8501011115613ac8575f80fd5b5f805f805f805f6080888a031215613bdd575f80fd5b873567ffffffffffffffff80821115613bf4575f80fd5b613c008b838c01613b86565b909950975060208a0135915080821115613c18575f80fd5b613c248b838c01613b86565b909750955060408a01359150613c3982613742565b90935060608901359080821115613b4b575f80fd5b5f8060408385031215613c5f575f80fd5b8235613c6a81613742565b946020939093013593505050565b5f60208284031215613c88575f80fd5b5035919050565b5f67ffffffffffffffff821115613ca857613ca8613766565b5060051b60200190565b5f82601f830112613cc1575f80fd5b81356020613cd161383183613c8f565b82815260059290921b84018101918181019086841115613cef575f80fd5b8286015b84811015613d0a5780358352918301918301613cf3565b509695505050505050565b5f805f805f60a08688031215613d29575f80fd5b8535613d3481613742565b94506020860135613d4481613742565b9350604086013567ffffffffffffffff80821115613d60575f80fd5b613d6c89838a01613cb2565b94506060880135915080821115613d81575f80fd5b613d8d89838a01613cb2565b93506080880135915080821115613da2575f80fd5b50613daf88828901613814565b9150509295509295909350565b5f805f60608486031215613dce575f80fd5b83359250602084013591506040840135613de781613742565b809150509250925092565b73ffffffffffffffffffffffffffffffffffffffff86168152846020820152836040820152613e246060820184613929565b60a060808201525f61361a60a0830184613984565b5f805f805f60a08688031215613e4d575f80fd5b8535613e5881613742565b94506020860135613e6881613742565b93506040860135925060608601359150608086013567ffffffffffffffff811115613e91575f80fd5b613daf88828901613814565b60068110613763575f80fd5b5f613eb6613831846137ed565b9050828152838383011115613ec9575f80fd5b611342836020830184613962565b5f60208284031215613ee7575f80fd5b815167ffffffffffffffff80821115613efe575f80fd5b9083019060a08286031215613f11575f80fd5b613f19613793565b8251613f2481613742565b8082525060208301516020820152604083015160408201526060830151613f4a81613e9d565b6060820152608083015182811115613f60575f80fd5b80840193505085601f840112613f74575f80fd5b613f8386845160208601613ea9565b608082015295945050505050565b5f60208284031215613fa1575f80fd5b813561134281613e9d565b73ffffffffffffffffffffffffffffffffffffffff84168152602081018390526060810161068e6040830184613929565b600181811c90821680613ff157607f821691505b602082108103614028577f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b50919050565b818382375f9101908152919050565b81835281816020850137505f602082840101525f6020601f19601f840116840101905092915050565b868152608060208201525f61407f60808301878961403d565b828103604084015261409281868861403d565b915050826060830152979650505050505050565b5f602082840312156140b6575f80fd5b81518015158114611342575f80fd5b602081525f61068e60208301848661403d565b5f8151604084526140ec6040850182613984565b60209384015173ffffffffffffffffffffffffffffffffffffffff16949093019390935250919050565b604081525f61412860408301846140d8565b8281036020938401525f81529190910192915050565b5f8151808452602080850194508084015f5b8381101561416c57815187529582019590820190600101614150565b509495945050505050565b8183525f6020808501808196508560051b81019150845f5b8781101561427a57828403895281357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc18836030181126141cd575f80fd5b8701604081356141dc81613742565b73ffffffffffffffffffffffffffffffffffffffff16865281870135368390037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1018112614228575f80fd5b90910186810191903567ffffffffffffffff811115614245575f80fd5b803603831315614253575f80fd5b8188880152614265828801828561403d565b9b88019b96505050918501915060010161418f565b5091979650505050505050565b60a080825287519082018190525f9060209060c0840190828b01845b828110156142bf578151845292840192908401906001016142a3565b505050838103828501526142d3818a61413e565b905083810360408501528088518083528383019150838160051b840101848b015f5b8381101561432357601f19868403018552614311838351613984565b948701949250908601906001016142f5565b50508681036060880152614338818a8c614177565b9550505050505061361a608083018473ffffffffffffffffffffffffffffffffffffffff169052565b602081525f82516040602084015261437c60608401826140d8565b9050602084015160408401528091505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b8181038181111561066657610666614392565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b60ff828116828216039081111561066657610666614392565b5f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff820361444857614448614392565b5060010190565b5f82357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff61833603018112614481575f80fd5b9190910192915050565b5f8085851115614499575f80fd5b838611156144a5575f80fd5b5050820193919092039150565b7fffffffffffffffffffffffffffffffffffffffff00000000000000000000000081358181169160148510156144f25780818660140360031b1b83161692505b505092915050565b5f82601f830112614509575f80fd5b8151602061451961383183613c8f565b82815260059290921b84018101918181019086841115614537575f80fd5b8286015b84811015613d0a578051835291830191830161453b565b805161455d81613742565b919050565b5f805f60608486031215614574575f80fd5b835167ffffffffffffffff8082111561458b575f80fd5b818601915086601f83011261459e575f80fd5b815160206145ae61383183613c8f565b82815260059290921b8401810191818101908a8411156145cc575f80fd5b948201945b838610156145ea578551825294820194908201906145d1565b91890151919750909350505080821115614602575f80fd5b5061460f868287016144fa565b92505061461e60408501614552565b90509250925092565b8082018082111561066657610666614392565b604081525f61464c60408301856139af565b828103602084015261465e8185613984565b95945050505050565b5f8251614481818460208701613962565b5f8060408385031215614689575f80fd5b825167ffffffffffffffff808211156146a0575f80fd5b818501915085601f8301126146b3575f80fd5b815160206146c361383183613c8f565b82815260059290921b840181019181810190898411156146e1575f80fd5b948201945b838610156147085785516146f981613742565b825294820194908201906146e6565b91880151919650909350505080821115614720575f80fd5b5061472d858286016144fa565b9150509250929050565b604080825283519082018190525f906020906060840190828701845b8281101561478557815173ffffffffffffffffffffffffffffffffffffffff1684529284019290840190600101614753565b50505083810382850152614799818661413e565b9695505050505050565b5f602082840312156147b3575f80fd5b5051919050565b601f821115611743575f81815260208120601f850160051c810160208610156147e05750805b601f850160051c820191505b81811015612124578281556001016147ec565b815167ffffffffffffffff81111561481957614819613766565b61482d816148278454613fdd565b846147ba565b602080601f83116001811461487f575f84156148495750858301515b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600386901b1c1916600185901b178555612124565b5f85815260208120601f198616915b828110156148ad5788860151825594840194600190910190840161488e565b50858210156148e957878501517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600388901b60f8161c191681555b5050505050600190811b01905550565b5f60208284031215614909575f80fd5b815167ffffffffffffffff81111561491f575f80fd5b8201601f8101841361492f575f80fd5b61068e84825160208401613ea9565b5f73ffffffffffffffffffffffffffffffffffffffff808816835260a0602084015261496d60a0840188613984565b838103604085015261497f8188613984565b905083810360608501526149938187613984565b9250508084166080840152509695505050505050565b606081525f6149bb6060830186613984565b82810360208401526149cd8186613984565b905082810360408401526147998185613984565b604081525f61464c60408301856140d8565b808202811582820484141761066657610666614392565b5f81614a1857614a18614392565b507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0190565b602081525f611342602083018461398456fea2646970667358221220ac122251ea93e9a7299e5df0ed34e072af4be98079d9c78e0035473d7ad1acf764736f6c63430008150033000000000000000000000000af753cc76156ab0f2c9f316049cc3df267f78e1a00000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001600000000000000000000000000385603ab55642cb4dd5de3ae9e306809991804f0000000000000000000000004f4495243837681061c4743b74b3eedf548d56a50000000000000000000000002d5d7d31f671f86c782533cc367f14109a082712000000000000000000000000b2b5841dbef766d4b521221732f9b618fcf34a87000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000008457468657265756d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000bad3aa36734ebce4379c1839f68a8b1dcd60c4f5000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000005626c617374000000000000000000000000000000000000000000000000000000

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

000000000000000000000000af753cc76156ab0f2c9f316049cc3df267f78e1a00000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001600000000000000000000000000385603ab55642cb4dd5de3ae9e306809991804f0000000000000000000000004f4495243837681061c4743b74b3eedf548d56a50000000000000000000000002d5d7d31f671f86c782533cc367f14109a082712000000000000000000000000b2b5841dbef766d4b521221732f9b618fcf34a87000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000008457468657265756d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000bad3aa36734ebce4379c1839f68a8b1dcd60c4f5000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000005626c617374000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _accessManager (address): 0xAf753cc76156Ab0f2C9f316049Cc3df267f78e1a
Arg [1] : _currentChainSelector (bytes): 0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000008457468657265756d000000000000000000000000000000000000000000000000
Arg [2] : _eeseeAssetHub (tuple): System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput]
Arg [3] : _royaltyEngine (address): 0x0385603ab55642cb4Dd5De3aE9e306809991804f
Arg [4] : _gateway (address): 0x4F4495243837681061C4743b74B3eEdf548D56A5
Arg [5] : _gasService (address): 0x2d5d7d31F671F86C782533cc367F14109a082712
Arg [6] : trustedForwarder (address): 0xB2b5841DBeF766d4b521221732F9B618fCf34A87

-----Encoded View---------------
17 Constructor Arguments found :
Arg [0] : 000000000000000000000000af753cc76156ab0f2c9f316049cc3df267f78e1a
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000160
Arg [3] : 0000000000000000000000000385603ab55642cb4dd5de3ae9e306809991804f
Arg [4] : 0000000000000000000000004f4495243837681061c4743b74b3eedf548d56a5
Arg [5] : 0000000000000000000000002d5d7d31f671f86c782533cc367f14109a082712
Arg [6] : 000000000000000000000000b2b5841dbef766d4b521221732f9b618fcf34a87
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [10] : 457468657265756d000000000000000000000000000000000000000000000000
Arg [11] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [12] : 000000000000000000000000bad3aa36734ebce4379c1839f68a8b1dcd60c4f5
Arg [13] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [14] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [15] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [16] : 626c617374000000000000000000000000000000000000000000000000000000