Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./interfaces/ISilo.sol";
import "./interfaces/IAction.sol";
import "./interfaces/ITierManager.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "./interfaces/ISiloManagerFactory.sol";
import {Statuses} from "./interfaces/ISilo.sol";
import "./interfaces/ISiloSubFactory.sol";
import "./interfaces/ISiloReferral.sol";
import {IWrappedNativeToken} from "./interfaces/IWrappedNativeToken.sol";

contract SiloFactoryV2 is Ownable, ERC721Enumerable {
    mapping(uint256 => address) public siloMap;
    mapping(address => uint256) public siloToId;

    address public tierManager;
    address public uiHelper;
    address public subFactory;
    address public referral;
    uint256 public currentStrategyId = 1;
    uint256 public strategyMaxGas = 3500000;
    uint256 public maxSilosPerUser = 9999;

    mapping(address => bool) public highRiskActions;

    mapping(uint256 => string[]) public catalogue;

    //Preset Silo Strategies
    mapping(uint256 => address[5]) public strategyInputs;
    mapping(uint256 => bytes[]) public strategyConfigurationData;
    mapping(uint256 => address[]) public strategyActions;
    mapping(string => uint256) public strategyName;
    mapping(uint256 => bool) public strategyValid;
    mapping(string => uint256) public mainActions;

    //Action fee information
    mapping(address => uint256[4]) public feeList; //how much of a fee to charge
    mapping(address => address) public feeRecipient; //where fees are sent for that action
    mapping(address => bool) public useCustom;

    uint256[4] public defaultFeeList = [300, 200, 100, 50];
    address public defaultRecipient =
        0x3bC36E3A99Ae2e1e6f3911019cb503076CbD9495; //fee manager

    address public managerFactory;

    uint256 public siloCount;
    string public siloURI;

    address public creator;

    IWrappedNativeToken public immutable WRAPPED_NATIVE_TOKEN;

    //Security with transfers and actions
    bool public enforceBeforeTransfer = true;
    mapping(address => bool) public actionValid; //must be set by team to make sure action is valid, users can opt to not listen to this

    uint256 public minBalance = 1 gwei;

    mapping(uint256 => uint256) public siloBurnTimeLimit;
    uint256 public defaultTimeLimit = 600; //10 min

    event SiloCreate(
        address owner,
        address newSilo,
        string name,
        string strategyName,
        bytes32 code,
        uint256 siloID
    );

    event SiloUpdateStrategy(
        address owner,
        uint256 siloID,
        uint256 index,
        bytes configurationData,
        address implementation
    );

    event SiloBurn(uint256 siloID);

    event SiloDeposit(uint256 siloID, uint256[5] amount);

    event SiloManualHarvest(uint256 siloID);

    event SiloRemoveAsset(uint256 siloID, address[] tokens);

    event SiloRemoveAllAsset(uint256 siloID);

    event SiloExit(uint256 siloID, uint256 amount, uint256 exitType);

    event NewStackStrategy(string _strategyName, uint256 strategyType);

    event UpdateStackStrategy(string _strategyName);

    modifier isOwner(uint256 siloID) {
        require(
            ownerOf(siloID) == msg.sender,
            "Caller does not own this silo!"
        );
        _;
    }

    constructor(
        address _tierManager,
        address _wrappedNativeToken
    ) ERC721("Gravity Finance Silo", "gSILO") Ownable(msg.sender) {
        tierManager = _tierManager;
        WRAPPED_NATIVE_TOKEN = IWrappedNativeToken(_wrappedNativeToken);
    }

    /***************************************external onlyOwner *************************************/

    function setDefaultTimeLimit(uint256 _limit) external onlyOwner {
        defaultTimeLimit = _limit;
    }

    function setUIHelper(address _helper) external onlyOwner {
        uiHelper = _helper;
    }

    function setSubFactory(address _subFactory) external onlyOwner {
        subFactory = _subFactory;
    }

    function setReferral(address _referral) external onlyOwner {
        referral = _referral;
    }

    function setActionValid(address _action, bool _state) external onlyOwner {
        actionValid[_action] = _state;
    }

    function setStrategyValid(
        uint256 _strategyId,
        bool _state
    ) external onlyOwner {
        strategyValid[_strategyId] = _state;
    }

    function setStrategyValidWithName(
        string memory _strategyName,
        bool _state
    ) external onlyOwner {
        strategyValid[strategyName[_strategyName]] = _state;
    }

    function changeBeforeTransferChecks(bool _state) external onlyOwner {
        enforceBeforeTransfer = _state;
    }

    function adjustMaxSilosPerUser(uint256 _max) external onlyOwner {
        maxSilosPerUser = _max;
    }

    function adjustIgnoreBalance(uint256 _minBalance) external onlyOwner {
        minBalance = _minBalance;
    }

    function setSiloManagerFactory(address _managerFactory) external onlyOwner {
        managerFactory = _managerFactory;
    }

    function setTierManager(address _tierManager) external onlyOwner {
        tierManager = _tierManager;
    }

    function addActionStack(
        string memory _strategyName,
        uint256 strategyType,
        address[5] memory _inputs,
        address[] memory _actions,
        bytes[] memory _configurationData,
        uint256 main
    ) external onlyOwner {
        uint256 id = strategyName[_strategyName];
        require(id == 0, "name already");
        strategyName[_strategyName] = currentStrategyId;
        currentStrategyId += 1;
        id = strategyName[_strategyName];
        strategyInputs[id] = _inputs;
        strategyActions[id] = _actions;
        strategyConfigurationData[id] = _configurationData;
        catalogue[strategyType].push(_strategyName);

        mainActions[_strategyName] = main;

        emit NewStackStrategy(_strategyName, strategyType);
    }

    function editActionStack(
        string memory _strategyName,
        address[5] memory _inputs,
        address[] memory _actions,
        bytes[] memory _configurationData,
        uint256 main
    ) external onlyOwner {
        uint256 id = strategyName[_strategyName];
        require(id != 0, "unknown name");
        strategyInputs[id] = _inputs;
        strategyActions[id] = _actions;
        strategyConfigurationData[id] = _configurationData;

        mainActions[_strategyName] = main;

        emit UpdateStackStrategy(_strategyName);
    }

    function adjustDefaultFeeList(
        uint256[4] memory _feeList
    ) external onlyOwner {
        defaultFeeList = _feeList;
    }

    function adjustDefaultRecipient(address _recipient) external onlyOwner {
        defaultRecipient = _recipient;
    }

    function adjustFeeList(
        uint256[4] memory _feeList,
        address _action
    ) external onlyOwner {
        feeList[_action] = _feeList;
    }

    function adjustRecipient(
        address _recipient,
        address _action
    ) external onlyOwner {
        feeRecipient[_action] = _recipient;
    }

    function adjustUseCustom(bool _state, address _action) external onlyOwner {
        useCustom[_action] = _state;
    }

    function setStrategyMaxGas(uint256 _maxGas) external onlyOwner {
        strategyMaxGas = _maxGas;
    }

    function changeURI(string memory _uri) external onlyOwner {
        siloURI = _uri;
    }

    function adjustHighRiskActions(
        address _action,
        bool _state
    ) external onlyOwner {
        highRiskActions[_action] = _state;
    }

    /***************************************external state mutative *************************************/

    function setupSiloBurn(uint256 _siloId) external isOwner(_siloId) {
        siloBurnTimeLimit[_siloId] = block.timestamp + defaultTimeLimit;
    }

    function burnSilo(uint256 _siloId) external isOwner(_siloId) {
        require(
            siloBurnTimeLimit[_siloId] > block.timestamp,
            "Call setupSiloBurn first"
        );
        _burn(_siloId);
        emit SiloBurn(_siloId);
    }

    function enterSiloStrategy(
        uint256[5] memory amount,
        uint256 siloID
    ) external payable isOwner(siloID) {
        ISilo silo = ISilo(siloMap[siloID]);
        address[5] memory depositTokens = abi.decode(
            silo.getConfig(),
            (address[5])
        );

        for (uint256 i; i < 5; ) {
            if (depositTokens[i] != address(0) && amount[i] > 0) {
                SafeERC20.safeTransferFrom(
                    IERC20(depositTokens[i]),
                    msg.sender,
                    address(silo),
                    amount[i]
                );
            }
            unchecked {
                i++;
            }
        }

        if (msg.value != 0) {
            WRAPPED_NATIVE_TOKEN.deposit{value: msg.value}();
            SafeERC20.safeTransfer(
                WRAPPED_NATIVE_TOKEN,
                address(silo),
                WRAPPED_NATIVE_TOKEN.balanceOf(address(this))
            );
        }

        if (silo.getStatus() == Statuses.MANAGED) {
            //only deposit funds into strategy if Silo's status is MANAGED
            silo.deposit();
            emit SiloDeposit(siloID, amount);
        }
    }

    function manualHarvest(uint256 siloID) external isOwner(siloID) {
        ISilo silo = ISilo(siloMap[siloID]);

        bool deposited = silo.deposited();

        require(deposited, "no funds");

        silo.deposit();

        emit SiloManualHarvest(siloID);
    }

    function removeFundsFromSilo(uint256 siloID) external isOwner(siloID) {
        ISilo silo = ISilo(siloMap[siloID]);
        silo.exitSilo(msg.sender);
        emit SiloRemoveAllAsset(siloID);
    }

    function withdrawTokensFromSilo(
        uint256 siloID,
        address[] memory tokens
    ) external isOwner(siloID) {
        ISilo silo = ISilo(siloMap[siloID]);
        for (uint256 i; i < tokens.length; ) {
            silo.withdrawToken(tokens[i], msg.sender);
            unchecked {
                i++;
            }
        }
        emit SiloRemoveAsset(siloID, tokens);
    }

    function exitSiloStrategy(
        uint256 siloID,
        uint256 _requestedOut
    ) external isOwner(siloID) {
        ISilo silo = ISilo(siloMap[siloID]);
        silo.withdraw(_requestedOut);
        emit SiloExit(siloID, _requestedOut, 0);
    }

    function exitStrategyAndWithdraw(
        uint256 siloID,
        uint256 _requestedOut
    ) external isOwner(siloID) {
        ISilo silo = ISilo(siloMap[siloID]);
        silo.withdraw(_requestedOut);
        silo.exitSilo(msg.sender);
        emit SiloExit(siloID, _requestedOut, 1);
    }

    function adminCallToSilo(
        uint256 siloID,
        address target,
        bytes memory data
    ) external isOwner(siloID) {
        ISilo silo = ISilo(siloMap[siloID]);
        silo.adminCall(target, data);
    }

    function adjustSiloStrategy(
        uint256 siloID,
        uint256 _index,
        bytes memory _configurationData,
        address _implementation
    ) external isOwner(siloID) {
        ISiloSubFactory(subFactory).checkActionLogicValid(
            msg.sender,
            _implementation,
            _configurationData
        );

        ISilo silo = ISilo(siloMap[siloID]);
        silo.adjustStrategy(_index, _configurationData, _implementation);

        emit SiloUpdateStrategy(
            msg.sender,
            siloID,
            _index,
            _configurationData,
            _implementation
        );
    }

    function setCreator(address _creator) external onlyOwner {
        creator = _creator;
    }

    /**
     * @dev creates a new silo, and loads a strategy into it
     */
    function deploySiloAndSetStrategy(
        string memory _name,
        string memory _strategyName,
        uint256 _category,
        uint256 _delay,
        address[5] memory _inputs,
        address[] memory _actions,
        bytes[] memory _configurationData,
        bytes32 _code
    ) external payable {
        ISiloSubFactory(subFactory).checkActionsLogicValid(
            msg.sender,
            _actions,
            _configurationData
        );

        uint256 siloId = siloCount + 1;

        require(creator != address(0), "wrong creator");

        bytes memory inputData = abi.encode(siloId, mainActions[_strategyName]);

        (bool success, bytes memory data) = payable(creator).call{
            value: msg.value
        }(abi.encodeWithSignature("createSilo(bytes)", inputData));

        require(success, "error create manager");

        address _silo = abi.decode(data, (address));

        siloMap[siloId] = _silo;
        siloToId[_silo] = siloId;
        siloCount += 1;

        _setActionStack(
            siloId,
            _strategyName,
            _category,
            _inputs,
            _actions,
            _configurationData
        );

        ISilo(_silo).setName(_name);
        ISilo(_silo).adjustSiloDelay(_delay);

        _mint(msg.sender, siloId);

        try ISiloReferral(referral).setSiloReferrer(_silo, _code) {} catch (
            bytes memory
        ) {}

        emit SiloCreate(msg.sender, _silo, _name, _strategyName, _code, siloId);
    }

    /***************************************external view *************************************/

    function getFeeInfo(
        address _action
    ) external view returns (uint256 fee, address recipient) {
        uint256 tier;

        if (tierManager != address(0)) {
            tier = ITierManager(tierManager).checkTier(
                ownerOf(siloToId[msg.sender])
            );
        }
        //getTier(msg.sender);
        //uint tier = 0;
        if (useCustom[_action]) {
            if (feeRecipient[_action] == address(0)) {
                return (feeList[_action][tier], defaultRecipient);
            } else {
                return (feeList[_action][tier], feeRecipient[_action]);
            }
        } else {
            return (defaultFeeList[tier], defaultRecipient);
        }
    }

    function getFeeInfoNoTier(
        address _action
    ) external view returns (uint256[4] memory) {
        if (useCustom[_action]) {
            return feeList[_action];
        } else {
            return defaultFeeList;
        }
    }

    function isSilo(address _silo) external view returns (bool) {
        return (siloMap[siloToId[_silo]] == _silo);
    }

    function isSiloManager(
        address _silo,
        address _manager
    ) external view returns (bool) {
        bool checkSilo = siloMap[siloToId[_silo]] == _silo;

        if (checkSilo) {
            address siloOwner = ownerOf(siloToId[_silo]);
            ISiloManagerFactory factory = ISiloManagerFactory(managerFactory);
            address manager = factory.userToManager(siloOwner);
            return (manager == _manager);
        }
        return false;
    }

    function setActionStack(
        uint256 siloID,
        string memory _strategyName,
        uint256 _category,
        address[5] memory _inputs,
        address[] memory _actions,
        bytes[] memory _configurationData
    ) public isOwner(siloID) {
        ISiloSubFactory(subFactory).checkActionsLogicValid(
            msg.sender,
            _actions,
            _configurationData
        );
        _setActionStack(
            siloID,
            _strategyName,
            _category,
            _inputs,
            _actions,
            _configurationData
        );
    }

    /***************************************public view *************************************/
    // function getTier(address silo) public view returns(uint){
    //     return ITierManager(tierManager).checkTier(ownerOf(siloToId[silo]));
    // }

    function getCatalogue(uint256 _type) public view returns (string[] memory) {
        return catalogue[_type];
    }

    function getStrategyInputs(
        uint256 _id
    ) public view returns (address[5] memory) {
        return strategyInputs[_id];
    }

    function getStrategyActions(
        uint256 _id
    ) public view returns (address[] memory) {
        return strategyActions[_id];
    }

    function getStrategyConfigurationData(
        uint256 _id
    ) public view returns (bytes[] memory) {
        return strategyConfigurationData[_id];
    }

    // function getFeeList(address _action) public view returns(uint[4] memory){
    //     return feeList[_action];
    // }

    /***************************************internal mutative *************************************/
    function _setActionStack(
        uint256 siloID,
        string memory _strategyName,
        uint256 _category,
        address[5] memory _inputs,
        address[] memory _actions,
        bytes[] memory _configurationData
    ) internal {
        ISiloManagerFactory factory = ISiloManagerFactory(managerFactory);

        ISilo silo = ISilo(siloMap[siloID]);

        AutoStatus status = factory.getAutoStatus(msg.sender);

        require(status > AutoStatus.PENDING, "Gravity: no approved manager");

        silo.setStrategy(_inputs, _configurationData, _actions);
        silo.setStrategyCategory(_category);
        silo.setStrategyName(_strategyName);
    }

    /**
     * @dev require that to address has an active manager
     * @dev require that to address does not excede maxSilosPerUser
     * @dev require that to address has chosen to accept silos from from
     * @dev if transfering a silo running a high risk strategy, make sure to address's manager has sufficient funding
     */
    function _update(
        address to,
        uint256 tokenId,
        address auth
    ) internal override returns (address) {
        // super._beforeTokenTransfer(from, to, tokenId, batchSize);

        address previousOwner = super._update(to, tokenId, address(0));
        if (
            enforceBeforeTransfer &&
            to != address(0) &&
            previousOwner != address(0)
        ) {
            //if we aren't burning

            if (previousOwner != address(0)) {
                //only check this if not minting
                require(
                    ISiloSubFactory(subFactory).acceptTransfersFrom(
                        to,
                        previousOwner
                    ),
                    "not approved to receive silo"
                );
            }

            ISiloManagerFactory factory = ISiloManagerFactory(managerFactory);
            // ISilo silo = ISilo(siloMap[tokenId]);
            AutoStatus status = factory.getAutoStatus(to);

            require(
                status > AutoStatus.PENDING,
                "Gravity: no approved manager"
            );

            require(balanceOf(to) < maxSilosPerUser, "Gravity: over max silos");
        }

        return previousOwner;
    }

    /*************************************** internal view *************************************/
    function _baseURI() internal view override returns (string memory) {
        return siloURI;
    }

    function tokenURI(
        uint256 tokenId
    ) public view virtual override(ERC721) returns (string memory) {
        // require(_exists(tokenId), "URI query for nonexistent token");
        require(
            _ownerOf(tokenId) != address(0),
            "URI query for nonexistent token"
        );

        return siloURI;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

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

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

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

pragma solidity ^0.8.20;

/**
 * @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 v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

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

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../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 An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

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

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

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

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

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

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

    /**
     * @dev 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);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that 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(token).code.length > 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.20;

import {IERC721} from "./IERC721.sol";
import {IERC721Receiver} from "./IERC721Receiver.sol";
import {IERC721Metadata} from "./extensions/IERC721Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {Strings} from "../../utils/Strings.sol";
import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol";
import {IERC721Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    mapping(uint256 tokenId => address) private _owners;

    mapping(address owner => uint256) private _balances;

    mapping(uint256 tokenId => address) private _tokenApprovals;

    mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual returns (uint256) {
        if (owner == address(0)) {
            revert ERC721InvalidOwner(address(0));
        }
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual returns (address) {
        return _requireOwned(tokenId);
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
        _requireOwned(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual {
        _approve(to, tokenId, _msgSender());
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual returns (address) {
        _requireOwned(tokenId);

        return _getApproved(tokenId);
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        address previousOwner = _update(to, tokenId, _msgSender());
        if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {
        transferFrom(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     *
     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the
     * core ERC721 logic MUST be matched with the use of {_increaseBalance} to keep balances
     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by
     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.
     */
    function _getApproved(uint256 tokenId) internal view virtual returns (address) {
        return _tokenApprovals[tokenId];
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in
     * particular (ignoring whether it is owned by `owner`).
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {
        return
            spender != address(0) &&
            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);
    }

    /**
     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.
     * Reverts if `spender` does not have approval from the provided `owner` for the given token or for all its assets
     * the `spender` for the specific `tokenId`.
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {
        if (!_isAuthorized(owner, spender, tokenId)) {
            if (owner == address(0)) {
                revert ERC721NonexistentToken(tokenId);
            } else {
                revert ERC721InsufficientApproval(spender, tokenId);
            }
        }
    }

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that
     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.
     *
     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the
     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership
     * remain consistent with one another.
     */
    function _increaseBalance(address account, uint128 value) internal virtual {
        unchecked {
            _balances[account] += value;
        }
    }

    /**
     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner
     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that
     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).
     *
     * Emits a {Transfer} event.
     *
     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.
     */
    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {
        address from = _ownerOf(tokenId);

        // Perform (optional) operator check
        if (auth != address(0)) {
            _checkAuthorized(from, auth, tokenId);
        }

        // Execute the update
        if (from != address(0)) {
            // Clear approval. No need to re-authorize or emit the Approval event
            _approve(address(0), tokenId, address(0), false);

            unchecked {
                _balances[from] -= 1;
            }
        }

        if (to != address(0)) {
            unchecked {
                _balances[to] += 1;
            }
        }

        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        return from;
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner != address(0)) {
            revert ERC721InvalidSender(address(0));
        }
    }

    /**
     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
        _mint(to, tokenId);
        _checkOnERC721Received(address(0), to, tokenId, data);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal {
        address previousOwner = _update(address(0), tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        } else if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients
     * are aware of the ERC721 standard to prevent tokens from being forever locked.
     *
     * `data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is like {safeTransferFrom} in the sense that it invokes
     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `tokenId` token must exist and be owned by `from`.
     * - `to` cannot be the zero address.
     * - `from` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId) internal {
        _safeTransfer(from, to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
        _transfer(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is
     * either the owner of the token, or approved to operate on all tokens held by this owner.
     *
     * Emits an {Approval} event.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address to, uint256 tokenId, address auth) internal {
        _approve(to, tokenId, auth, true);
    }

    /**
     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not
     * emitted in the context of transfers.
     */
    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {
        // Avoid reading the owner unless necessary
        if (emitEvent || auth != address(0)) {
            address owner = _requireOwned(tokenId);

            // We do not use _isAuthorized because single-token approvals should not be able to call approve
            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {
                revert ERC721InvalidApprover(auth);
            }

            if (emitEvent) {
                emit Approval(owner, to, tokenId);
            }
        }

        _tokenApprovals[tokenId] = to;
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Requirements:
     * - operator can't be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        if (operator == address(0)) {
            revert ERC721InvalidOperator(operator);
        }
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).
     * Returns the owner.
     *
     * Overrides to ownership logic should be done to {_ownerOf}.
     */
    function _requireOwned(uint256 tokenId) internal view returns (address) {
        address owner = _ownerOf(tokenId);
        if (owner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
        return owner;
    }

    /**
     * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target address. This will revert if the
     * recipient doesn't accept the token transfer. The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param data bytes optional data to send along with the call
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private {
        if (to.code.length > 0) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                if (retval != IERC721Receiver.onERC721Received.selector) {
                    revert ERC721InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert ERC721InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/ERC721Enumerable.sol)

pragma solidity ^0.8.20;

import {ERC721} from "../ERC721.sol";
import {IERC721Enumerable} from "./IERC721Enumerable.sol";
import {IERC165} from "../../../utils/introspection/ERC165.sol";

/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds enumerability
 * of all the token ids in the contract as well as all token ids owned by each account.
 *
 * CAUTION: `ERC721` extensions that implement custom `balanceOf` logic, such as `ERC721Consecutive`,
 * interfere with enumerability and should not be used together with `ERC721Enumerable`.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    mapping(address owner => mapping(uint256 index => uint256)) private _ownedTokens;
    mapping(uint256 tokenId => uint256) private _ownedTokensIndex;

    uint256[] private _allTokens;
    mapping(uint256 tokenId => uint256) private _allTokensIndex;

    /**
     * @dev An `owner`'s token query was out of bounds for `index`.
     *
     * NOTE: The owner being `address(0)` indicates a global out of bounds index.
     */
    error ERC721OutOfBoundsIndex(address owner, uint256 index);

    /**
     * @dev Batch mint is not allowed.
     */
    error ERC721EnumerableForbiddenBatchMint();

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
        return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual returns (uint256) {
        if (index >= balanceOf(owner)) {
            revert ERC721OutOfBoundsIndex(owner, index);
        }
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual returns (uint256) {
        if (index >= totalSupply()) {
            revert ERC721OutOfBoundsIndex(address(0), index);
        }
        return _allTokens[index];
    }

    /**
     * @dev See {ERC721-_update}.
     */
    function _update(address to, uint256 tokenId, address auth) internal virtual override returns (address) {
        address previousOwner = super._update(to, tokenId, auth);

        if (previousOwner == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (previousOwner != to) {
            _removeTokenFromOwnerEnumeration(previousOwner, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (previousOwner != to) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }

        return previousOwner;
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = balanceOf(to) - 1;
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = balanceOf(from);
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }

    /**
     * See {ERC721-_increaseBalance}. We need that to account tokens that were minted in batch
     */
    function _increaseBalance(address account, uint128 amount) internal virtual override {
        if (amount > 0) {
            revert ERC721EnumerableForbiddenBatchMint();
        }
        super._increaseBalance(account, amount);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.20;

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

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.20;

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

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

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

pragma solidity ^0.8.20;

import {IERC165} from "../../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 address zero.
     *
     * 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 v5.0.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.20;

/**
 * @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 v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

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

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

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

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

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

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

pragma solidity ^0.8.20;

/**
 * @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 (last updated v5.0.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

import {IERC165} from "./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);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @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 v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @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 towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (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 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                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.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 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.

            uint256 twos = denominator & (0 - denominator);
            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 (unsignedRoundsUp(rounding) && 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
     * towards zero.
     *
     * 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 + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * 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 + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * 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 + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * 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 + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

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

pragma solidity ^0.8.20;

/**
 * @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 v5.0.0) (utils/Strings.sol)

pragma solidity ^0.8.20;

import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";

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

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @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), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(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) {
        uint256 localValue = value;
        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] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        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 bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

struct ActionBalance {
    uint256 collateral;
    uint256 debt;
    address collateralToken;
    address debtToken;
    uint256 collateralConverted;
    address collateralConvertedToken;
    string lpUnderlyingBalances;
    string lpUnderlyingTokens;
}

interface IAction {
    function getConfig() external view returns (bytes memory config);

    function checkMaintain(
        bytes memory configuration
    ) external view returns (bool, uint256);

    function checkUpkeep(
        bytes memory configuration
    ) external view returns (bool);

    function extraInfo(
        bytes memory configuration
    ) external view returns (uint256[4] memory info);

    function validateConfig(
        bytes memory configData
    ) external view returns (bool);

    function getMetaData() external view returns (string memory);

    function feeName() external view returns (string memory);

    function name() external view returns (string memory);

    function usesTakeFee() external view returns (bool);

    function showBalances(
        address _silo,
        bytes memory _configurationData
    ) external view returns (ActionBalance memory);

    function showDust(
        address _silo,
        bytes memory _configurationData
    ) external view returns (address[] memory, uint256[] memory);

    function vaultInfo(
        address _silo,
        bytes memory configuration
    ) external view returns (uint256, uint256, uint256, uint256, uint256);

    function actionValid(
        bytes memory _configurationData
    ) external view returns (bool);

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

struct PriceOracle {
    address oracle;
    uint256 actionPrice;
}

enum Statuses {
    PAUSED,
    DORMANT,
    MANAGED,
    UNWIND
}

interface ISilo {
    function deposit() external;

    function withdraw(uint256 _requestedOut) external;

    function maintain() external;

    function exitSilo(address caller) external;

    function adminCall(address target, bytes memory data) external;

    function setStrategy(
        address[5] memory input,
        bytes[] memory _configurationData,
        address[] memory _implementations
    ) external;

    function getConfig() external view returns (bytes memory config);

    function withdrawToken(address token, address recipient) external;

    function adjustSiloDelay(uint256 _newDelay) external;

    function SILO_ID() external view returns (uint256);

    function siloDelay() external view returns (uint256);

    function name() external view returns (string memory);

    function lastTimeMaintained() external view returns (uint256);

    function factory() external view returns (address);

    function setName(string memory name) external;

    function deposited() external view returns (bool);

    function isNew() external view returns (bool);

    function status() external view returns (Statuses);

    function setStrategyName(string memory _strategyName) external;

    function setStrategyCategory(uint256 _strategyCategory) external;

    function strategyName() external view returns (string memory);

    function tokenMinimum(address token) external view returns (uint256);

    function strategyCategory() external view returns (uint256);

    // function main() external view returns (uint256);

    // function lastPid() external view returns (uint256);

    function adjustStrategy(
        uint256 _index,
        bytes memory _configurationData,
        address _implementation
    ) external;

    function viewStrategy()
        external
        view
        returns (address[] memory actions, bytes[] memory configData);

    function highRiskAction() external view returns (bool);

    function showActionStackValidity() external view returns (bool, bool);

    function getInputTokens() external view returns (address[5] memory);

    function getStatus() external view returns (Statuses);

    function pause() external;

    function unpause() external;

    function setActive() external;

    function possibleReinvestSilo() external view returns (bool possible);

    function getExtraSiloInfo()
        external
        view
        returns (
            uint256 strategyType,
            uint256 currentBalance,
            uint256 possibleWithdraw,
            uint256 availableBlock,
            uint256 pendingReward,
            uint256 lastPid
        );
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

enum AutoStatus {
    NOT,
    PENDING,
    APPROVED,
    MANUAL,
    LOW,
    NORMAL,
    HIGH
}

interface ISiloManager {
    function owner() external view returns (address);

    function taskId() external view returns (bytes32);

    function getBalance() external view returns (uint96);

    function depositFunds() external payable;

    function cancelAutomate() external;

    function withdrawFunds() external;

    function topupThreshold() external view returns (uint256);

    function topupAmount() external view returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

import {AutoStatus} from "./ISiloManager.sol";

struct ManagerInfo {
    address manager;
    bytes32 taskId;
    uint256 currentBalance;
    uint256 topupThreshold;
    uint256 minFunds;
}

interface ISiloManagerFactory {
    function checkManager(
        address _owner,
        address _manager
    ) external view returns (bool);

    function userToManager(address _user) external view returns (address);

    function isManager(address) external view returns (bool);

    function managerCount() external view returns (uint256);

    function siloFactory() external view returns (address);

    function getAutoStatus(address _user) external view returns (AutoStatus);

    function topupThreshold() external view returns (uint256);

    function minFunds() external view returns (uint256);

    function topupAmount() external view returns (uint256);

    function getAutomatorInfo(
        address _manager
    ) external view returns (ManagerInfo memory info);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface ISiloReferral {
    function setSiloReferrer(address _silo, bytes32 _code) external;

    function siloReferralInfo(address _silo) external view returns(uint256,address);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface ISiloSubFactory {
    function acceptTransfersFrom(address to, address from)
        external
        view
        returns (bool);

    function skipActionValidTeamCheck(address user)
        external
        view
        returns (bool);

    function skipActionValidLogicCheck(address user)
        external
        view
        returns (bool);

    function checkActionsLogicValid(
        address user,
        address[] memory _actions,
        bytes[] memory _configurationData
    ) external view returns (bool);

    function checkActionLogicValid(
        address user,
        address _implementation,
        bytes memory _configurationData
    ) external view returns(bool);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;


interface ITierManager {
    function checkTier(address caller) external view returns(uint);
    function checkTierIncludeSnapshot(address caller) external view returns(uint);
    function viewIDOTier(address caller) external view returns(uint);
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0;


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

interface IWrappedNativeToken is IERC20 {
    function deposit() external payable;
    function withdraw(uint256 amount) external;
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_tierManager","type":"address"},{"internalType":"address","name":"_wrappedNativeToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"ERC721EnumerableForbiddenBatchMint","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721IncorrectOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721InsufficientApproval","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC721InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC721InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721InvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC721InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC721InvalidSender","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721NonexistentToken","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"ERC721OutOfBoundsIndex","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"_strategyName","type":"string"},{"indexed":false,"internalType":"uint256","name":"strategyType","type":"uint256"}],"name":"NewStackStrategy","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"siloID","type":"uint256"}],"name":"SiloBurn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"address","name":"newSilo","type":"address"},{"indexed":false,"internalType":"string","name":"name","type":"string"},{"indexed":false,"internalType":"string","name":"strategyName","type":"string"},{"indexed":false,"internalType":"bytes32","name":"code","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"siloID","type":"uint256"}],"name":"SiloCreate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"siloID","type":"uint256"},{"indexed":false,"internalType":"uint256[5]","name":"amount","type":"uint256[5]"}],"name":"SiloDeposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"siloID","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"exitType","type":"uint256"}],"name":"SiloExit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"siloID","type":"uint256"}],"name":"SiloManualHarvest","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"siloID","type":"uint256"}],"name":"SiloRemoveAllAsset","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"siloID","type":"uint256"},{"indexed":false,"internalType":"address[]","name":"tokens","type":"address[]"}],"name":"SiloRemoveAsset","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"siloID","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"configurationData","type":"bytes"},{"indexed":false,"internalType":"address","name":"implementation","type":"address"}],"name":"SiloUpdateStrategy","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"_strategyName","type":"string"}],"name":"UpdateStackStrategy","type":"event"},{"inputs":[],"name":"WRAPPED_NATIVE_TOKEN","outputs":[{"internalType":"contract IWrappedNativeToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"actionValid","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_strategyName","type":"string"},{"internalType":"uint256","name":"strategyType","type":"uint256"},{"internalType":"address[5]","name":"_inputs","type":"address[5]"},{"internalType":"address[]","name":"_actions","type":"address[]"},{"internalType":"bytes[]","name":"_configurationData","type":"bytes[]"},{"internalType":"uint256","name":"main","type":"uint256"}],"name":"addActionStack","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[4]","name":"_feeList","type":"uint256[4]"}],"name":"adjustDefaultFeeList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"}],"name":"adjustDefaultRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[4]","name":"_feeList","type":"uint256[4]"},{"internalType":"address","name":"_action","type":"address"}],"name":"adjustFeeList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_action","type":"address"},{"internalType":"bool","name":"_state","type":"bool"}],"name":"adjustHighRiskActions","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minBalance","type":"uint256"}],"name":"adjustIgnoreBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_max","type":"uint256"}],"name":"adjustMaxSilosPerUser","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"address","name":"_action","type":"address"}],"name":"adjustRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"siloID","type":"uint256"},{"internalType":"uint256","name":"_index","type":"uint256"},{"internalType":"bytes","name":"_configurationData","type":"bytes"},{"internalType":"address","name":"_implementation","type":"address"}],"name":"adjustSiloStrategy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"},{"internalType":"address","name":"_action","type":"address"}],"name":"adjustUseCustom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"siloID","type":"uint256"},{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"adminCallToSilo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_siloId","type":"uint256"}],"name":"burnSilo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"catalogue","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"changeBeforeTransferChecks","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uri","type":"string"}],"name":"changeURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"creator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentStrategyId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"defaultFeeList","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"defaultRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"defaultTimeLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_strategyName","type":"string"},{"internalType":"uint256","name":"_category","type":"uint256"},{"internalType":"uint256","name":"_delay","type":"uint256"},{"internalType":"address[5]","name":"_inputs","type":"address[5]"},{"internalType":"address[]","name":"_actions","type":"address[]"},{"internalType":"bytes[]","name":"_configurationData","type":"bytes[]"},{"internalType":"bytes32","name":"_code","type":"bytes32"}],"name":"deploySiloAndSetStrategy","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"string","name":"_strategyName","type":"string"},{"internalType":"address[5]","name":"_inputs","type":"address[5]"},{"internalType":"address[]","name":"_actions","type":"address[]"},{"internalType":"bytes[]","name":"_configurationData","type":"bytes[]"},{"internalType":"uint256","name":"main","type":"uint256"}],"name":"editActionStack","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"enforceBeforeTransfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[5]","name":"amount","type":"uint256[5]"},{"internalType":"uint256","name":"siloID","type":"uint256"}],"name":"enterSiloStrategy","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"siloID","type":"uint256"},{"internalType":"uint256","name":"_requestedOut","type":"uint256"}],"name":"exitSiloStrategy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"siloID","type":"uint256"},{"internalType":"uint256","name":"_requestedOut","type":"uint256"}],"name":"exitStrategyAndWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"feeList","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"feeRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_type","type":"uint256"}],"name":"getCatalogue","outputs":[{"internalType":"string[]","name":"","type":"string[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_action","type":"address"}],"name":"getFeeInfo","outputs":[{"internalType":"uint256","name":"fee","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_action","type":"address"}],"name":"getFeeInfoNoTier","outputs":[{"internalType":"uint256[4]","name":"","type":"uint256[4]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"getStrategyActions","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"getStrategyConfigurationData","outputs":[{"internalType":"bytes[]","name":"","type":"bytes[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"getStrategyInputs","outputs":[{"internalType":"address[5]","name":"","type":"address[5]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"highRiskActions","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_silo","type":"address"}],"name":"isSilo","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_silo","type":"address"},{"internalType":"address","name":"_manager","type":"address"}],"name":"isSiloManager","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"","type":"string"}],"name":"mainActions","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"managerFactory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"siloID","type":"uint256"}],"name":"manualHarvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxSilosPerUser","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"referral","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"siloID","type":"uint256"}],"name":"removeFundsFromSilo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"siloID","type":"uint256"},{"internalType":"string","name":"_strategyName","type":"string"},{"internalType":"uint256","name":"_category","type":"uint256"},{"internalType":"address[5]","name":"_inputs","type":"address[5]"},{"internalType":"address[]","name":"_actions","type":"address[]"},{"internalType":"bytes[]","name":"_configurationData","type":"bytes[]"}],"name":"setActionStack","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_action","type":"address"},{"internalType":"bool","name":"_state","type":"bool"}],"name":"setActionValid","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_creator","type":"address"}],"name":"setCreator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_limit","type":"uint256"}],"name":"setDefaultTimeLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_referral","type":"address"}],"name":"setReferral","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_managerFactory","type":"address"}],"name":"setSiloManagerFactory","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxGas","type":"uint256"}],"name":"setStrategyMaxGas","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_strategyId","type":"uint256"},{"internalType":"bool","name":"_state","type":"bool"}],"name":"setStrategyValid","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_strategyName","type":"string"},{"internalType":"bool","name":"_state","type":"bool"}],"name":"setStrategyValidWithName","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_subFactory","type":"address"}],"name":"setSubFactory","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_tierManager","type":"address"}],"name":"setTierManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_helper","type":"address"}],"name":"setUIHelper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_siloId","type":"uint256"}],"name":"setupSiloBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"siloBurnTimeLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"siloCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"siloMap","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"siloToId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"siloURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"strategyActions","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"strategyConfigurationData","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"strategyInputs","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"strategyMaxGas","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"","type":"string"}],"name":"strategyName","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"strategyValid","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"subFactory","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tierManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uiHelper","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"useCustom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"siloID","type":"uint256"},{"internalType":"address[]","name":"tokens","type":"address[]"}],"name":"withdrawTokensFromSilo","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000039e2fb66102314ce7b64ce5ce3e5183bc94ad38

-----Decoded View---------------
Arg [0] : _tierManager (address): 0x0000000000000000000000000000000000000000
Arg [1] : _wrappedNativeToken (address): 0x039e2fB66102314Ce7b64Ce5Ce3E5183bc94aD38

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [1] : 000000000000000000000000039e2fb66102314ce7b64ce5ce3e5183bc94ad38