{"file_path":"contracts/MinterContract.sol","creation_status":"success","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.26;\n\nimport \"contracts/Common.sol\";\nimport \"contracts/MintUtil.sol\";\nimport \"contracts/interfaces/IMinterContract.sol\";\n\ncontract MinterContract is Common, IMinterContract {\n    uint256 public constant SECONDS_PER_DAY = 24 hours;\n    uint256 public constant DECIMALS = 8;\n\n    uint256 public minMintAmount = 1 * 10 ** DECIMALS;\n    uint256 public maxMintAmount = 100 * 10 ** DECIMALS;\n    uint256 public maxMintPerDay = 500 * 10 ** DECIMALS;\n\n    address public immutable tokenContract;\n    uint256 public dailyMintTotal;\n    uint256 public lastMintTimestamp;\n\n    constructor(address _owner, address _operator, address _tokenContract, address _safe, address _initialCaller)\n        Common(_owner, _operator, _safe, _initialCaller)\n    {\n        if (_tokenContract == address(0)) {\n            revert ZeroAddressNotAllowed();\n        }\n        tokenContract = _tokenContract;\n    }\n\n    function mint(uint256 amount) external onlyCaller whenNotPaused {\n        if (amount <= 0) {\n            revert InvalidMintAmount();\n        }\n\n        if (amount < minMintAmount) {\n            revert MintAmountTooSmall();\n        }\n\n        if (amount > maxMintAmount) {\n            revert MintAmountTooLarge();\n        }\n\n        _updateDailyLimit();\n\n        if (dailyMintTotal + amount > maxMintPerDay) {\n            revert DailyMintLimitExceeded();\n        }\n\n        dailyMintTotal += amount;\n        lastMintTimestamp = block.timestamp;\n\n        MintUtil.safeMint(amount, tokenContract);\n    }\n\n    function updateMintAmountParams(uint256 _minMintAmount, uint256 _maxMintAmount, uint256 _maxMintPerDay)\n        external\n        onlyOwner\n        whenNotPaused\n    {\n        if (_minMintAmount == 0 || _maxMintAmount == 0 || _maxMintPerDay == 0) {\n            revert MintAmountCanNotBeZero();\n        }\n\n        if (_minMintAmount >= _maxMintAmount) {\n            revert InvalidMintAmountRange();\n        }\n\n        if (_maxMintAmount > _maxMintPerDay) {\n            revert InvalidMintAmountLimit();\n        }\n\n        uint256 oldMinMint = minMintAmount;\n        uint256 oldMaxMint = maxMintAmount;\n        uint256 oldMaxDaily = maxMintPerDay;\n\n        minMintAmount = _minMintAmount;\n        maxMintAmount = _maxMintAmount;\n        maxMintPerDay = _maxMintPerDay;\n        emit MintParamsUpdated(oldMinMint, minMintAmount, oldMaxMint, maxMintAmount, oldMaxDaily, maxMintPerDay);\n    }\n\n    function _updateDailyLimit() private {\n        if (block.timestamp >= lastMintTimestamp + SECONDS_PER_DAY) {\n            dailyMintTotal = 0;\n        }\n    }\n\n    function getCurrentDailyMintTotal() external view returns (uint256 total) {\n        total = block.timestamp >= lastMintTimestamp + SECONDS_PER_DAY ? 0 : dailyMintTotal;\n    }\n}\n","deployed_bytecode":"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","optimization_enabled":true,"verified_twin_address_hash":null,"is_verified":true,"compiler_settings":{"evmVersion":"paris","libraries":{},"optimizer":{"enabled":true,"runs":10000},"outputSelection":{"*":{"":["*"],"*":["*"]}}},"optimization_runs":10000,"sourcify_repo_url":null,"decoded_constructor_args":[["0x3DF3c01b72dC5d63565Af0bCB20d847227c2201A",{"internalType":"address","name":"_owner","type":"address"}],["0x5Db8606F2927e7173b3Cab5a4c512d9f00BBF193",{"internalType":"address","name":"_operator","type":"address"}],["0x0520930F21b14Cafac7a27b102487beE7138a017",{"internalType":"address","name":"_tokenContract","type":"address"}],["0x9287B8E84d972DD02f618BBEd45b9A6d7ed16384",{"internalType":"address","name":"_safe","type":"address"}],["0x69C46c049502Aeb0d9c6a01432e1d2C2c8384993",{"internalType":"address","name":"_initialCaller","type":"address"}]],"compiler_version":"v0.8.26+commit.8a97fa7a","is_verified_via_verifier_alliance":false,"verified_at":"2026-07-08T09:14:46.157212Z","implementations":[],"proxy_type":null,"external_libraries":[],"creation_bytecode":"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","name":"MinterContract","is_blueprint":false,"license_type":"none","is_fully_verified":true,"is_verified_via_eth_bytecode_db":true,"language":"solidity","evm_version":"paris","can_be_visualized_via_sol2uml":true,"is_verified_via_sourcify":false,"additional_sources":[{"file_path":"@openzeppelin/contracts/access/Ownable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * The initial owner is set to the address provided by the deployer. This can\n * later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    constructor(address initialOwner) {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/access/Ownable2Step.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (access/Ownable2Step.sol)\n\npragma solidity ^0.8.20;\n\nimport {Ownable} from \"./Ownable.sol\";\n\n/**\n * @dev Contract module which provides access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * This extension of the {Ownable} contract includes a two-step mechanism to transfer\n * ownership, where the new owner must call {acceptOwnership} in order to replace the\n * old one. This can help prevent common mistakes, such as transfers of ownership to\n * incorrect accounts, or to contracts that are unable to interact with the\n * permission system.\n *\n * The initial owner is specified at deployment time in the constructor for `Ownable`. This\n * can later be changed with {transferOwnership} and {acceptOwnership}.\n *\n * This module is used through inheritance. It will make available all functions\n * from parent (Ownable).\n */\nabstract contract Ownable2Step is Ownable {\n    address private _pendingOwner;\n\n    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Returns the address of the pending owner.\n     */\n    function pendingOwner() public view virtual returns (address) {\n        return _pendingOwner;\n    }\n\n    /**\n     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\n     * Can only be called by the current owner.\n     *\n     * Setting `newOwner` to the zero address is allowed; this can be used to cancel an initiated ownership transfer.\n     */\n    function transferOwnership(address newOwner) public virtual override onlyOwner {\n        _pendingOwner = newOwner;\n        emit OwnershipTransferStarted(owner(), newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual override {\n        delete _pendingOwner;\n        super._transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev The new owner accepts the ownership transfer.\n     */\n    function acceptOwnership() public virtual {\n        address sender = _msgSender();\n        if (pendingOwner() != sender) {\n            revert OwnableUnauthorizedAccount(sender);\n        }\n        _transferOwnership(sender);\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/interfaces/IERC1363.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @title IERC1363\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\n *\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\n */\ninterface IERC1363 is IERC20, IERC165 {\n    /*\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\n     * 0xb0202a11 ===\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\n     */\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @param data Additional data with no specified format, sent in call to `spender`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\n}\n"},{"file_path":"@openzeppelin/contracts/interfaces/IERC165.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"../utils/introspection/IERC165.sol\";\n"},{"file_path":"@openzeppelin/contracts/interfaces/IERC20.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../token/ERC20/IERC20.sol\";\n"},{"file_path":"@openzeppelin/contracts/token/ERC20/IERC20.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},{"file_path":"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\nimport {IERC1363} from \"../../../interfaces/IERC1363.sol\";\nimport {Address} from \"../../../utils/Address.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    /**\n     * @dev An operation with an ERC-20 token failed.\n     */\n    error SafeERC20FailedOperation(address token);\n\n    /**\n     * @dev Indicates a failed `decreaseAllowance` request.\n     */\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        forceApprove(token, spender, oldAllowance + value);\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\n     * value, non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\n        unchecked {\n            uint256 currentAllowance = token.allowance(address(this), spender);\n            if (currentAllowance < requestedDecrease) {\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\n            }\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     *\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\n     * only sets the \"standard\" allowance. Any temporary allowance will remain active, in addition to the value being\n     * set here.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\n\n        if (!_callOptionalReturnBool(token, approvalCall)) {\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\n            _callOptionalReturn(token, approvalCall);\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            safeTransfer(token, to, value);\n        } else if (!token.transferAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferFromAndCallRelaxed(\n        IERC1363 token,\n        address from,\n        address to,\n        uint256 value,\n        bytes memory data\n    ) internal {\n        if (to.code.length == 0) {\n            safeTransferFrom(token, from, to, value);\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\n     * once without retrying, and relies on the returned value to be true.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            forceApprove(token, to, value);\n        } else if (!token.approveAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     *\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\n     */\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\n        uint256 returnSize;\n        uint256 returnValue;\n        assembly (\"memory-safe\") {\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\n            // bubble errors\n            if iszero(success) {\n                let ptr := mload(0x40)\n                returndatacopy(ptr, 0, returndatasize())\n                revert(ptr, returndatasize())\n            }\n            returnSize := returndatasize()\n            returnValue := mload(0)\n        }\n\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     *\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\n     */\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\n        bool success;\n        uint256 returnSize;\n        uint256 returnValue;\n        assembly (\"memory-safe\") {\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\n            returnSize := returndatasize()\n            returnValue := mload(0)\n        }\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/utils/Address.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Address.sol)\n\npragma solidity ^0.8.20;\n\nimport {Errors} from \"./Errors.sol\";\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev There's no code at `target` (it is not a contract).\n     */\n    error AddressEmptyCode(address target);\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        if (address(this).balance < amount) {\n            revert Errors.InsufficientBalance(address(this).balance, amount);\n        }\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        if (!success) {\n            revert Errors.FailedCall();\n        }\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason or custom error, it is bubbled\n     * up by this function (like regular Solidity function calls). However, if\n     * the call reverted with no returned reason, this function reverts with a\n     * {Errors.FailedCall} error.\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        if (address(this).balance < value) {\n            revert Errors.InsufficientBalance(address(this).balance, value);\n        }\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\n     * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case\n     * of an unsuccessful call.\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata\n    ) internal view returns (bytes memory) {\n        if (!success) {\n            _revert(returndata);\n        } else {\n            // only check if target is a contract if the call was successful and the return data is empty\n            // otherwise we already know that it was a contract\n            if (returndata.length == 0 && target.code.length == 0) {\n                revert AddressEmptyCode(target);\n            }\n            return returndata;\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\n     * revert reason or with a default {Errors.FailedCall} error.\n     */\n    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\n        if (!success) {\n            _revert(returndata);\n        } else {\n            return returndata;\n        }\n    }\n\n    /**\n     * @dev Reverts with returndata if present. Otherwise reverts with {Errors.FailedCall}.\n     */\n    function _revert(bytes memory returndata) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            assembly (\"memory-safe\") {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert Errors.FailedCall();\n        }\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/utils/Context.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/utils/Errors.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of common custom errors used in multiple contracts\n *\n * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.\n * It is recommended to avoid relying on the error API for critical functionality.\n *\n * _Available since v5.1._\n */\nlibrary Errors {\n    /**\n     * @dev The ETH balance of the account is not enough to perform the operation.\n     */\n    error InsufficientBalance(uint256 balance, uint256 needed);\n\n    /**\n     * @dev A call to an address target failed. The target may have reverted.\n     */\n    error FailedCall();\n\n    /**\n     * @dev The deployment failed.\n     */\n    error FailedDeployment();\n\n    /**\n     * @dev A necessary precompile is missing.\n     */\n    error MissingPrecompile(address);\n}\n"},{"file_path":"@openzeppelin/contracts/utils/Pausable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract Pausable is Context {\n    bool private _paused;\n\n    /**\n     * @dev Emitted when the pause is triggered by `account`.\n     */\n    event Paused(address account);\n\n    /**\n     * @dev Emitted when the pause is lifted by `account`.\n     */\n    event Unpaused(address account);\n\n    /**\n     * @dev The operation failed because the contract is paused.\n     */\n    error EnforcedPause();\n\n    /**\n     * @dev The operation failed because the contract is not paused.\n     */\n    error ExpectedPause();\n\n    /**\n     * @dev Initializes the contract in unpaused state.\n     */\n    constructor() {\n        _paused = false;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is not paused.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    modifier whenNotPaused() {\n        _requireNotPaused();\n        _;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is paused.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    modifier whenPaused() {\n        _requirePaused();\n        _;\n    }\n\n    /**\n     * @dev Returns true if the contract is paused, and false otherwise.\n     */\n    function paused() public view virtual returns (bool) {\n        return _paused;\n    }\n\n    /**\n     * @dev Throws if the contract is paused.\n     */\n    function _requireNotPaused() internal view virtual {\n        if (paused()) {\n            revert EnforcedPause();\n        }\n    }\n\n    /**\n     * @dev Throws if the contract is not paused.\n     */\n    function _requirePaused() internal view virtual {\n        if (!paused()) {\n            revert ExpectedPause();\n        }\n    }\n\n    /**\n     * @dev Triggers stopped state.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    function _pause() internal virtual whenNotPaused {\n        _paused = true;\n        emit Paused(_msgSender());\n    }\n\n    /**\n     * @dev Returns to normal state.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    function _unpause() internal virtual whenPaused {\n        _paused = false;\n        emit Unpaused(_msgSender());\n    }\n}\n"},{"file_path":"@openzeppelin/contracts/utils/introspection/IERC165.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},{"file_path":"contracts/Common.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.26;\n\nimport {Ownable2Step, Ownable} from \"@openzeppelin/contracts/access/Ownable2Step.sol\";\nimport {Pausable} from \"@openzeppelin/contracts/utils/Pausable.sol\";\nimport {SafeERC20, IERC20} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport {ICommon} from \"contracts/interfaces/ICommon.sol\";\n\ncontract Common is Ownable2Step, Pausable, ICommon {\n    using SafeERC20 for IERC20;\n\n    address public operator;\n    address public safe;\n    address public caller;\n\n    modifier onlyCaller() {\n        if (_msgSender() != caller) {\n            revert OnlyCaller();\n        }\n        _;\n    }\n\n    modifier onlyOperator() {\n        if (_msgSender() != operator) {\n            revert OnlyOperator();\n        }\n        _;\n    }\n\n    constructor(address _initialOwner, address _initialOperator, address _initialSafe, address _initialCaller)\n        Ownable(_initialOwner)\n    {\n        _updateOperator(_initialOperator);\n        _updateSafe(_initialSafe);\n        _manageCaller(_initialCaller);\n    }\n\n    function updateOperator(address newOperator) external onlyOwner {\n        _updateOperator(newOperator);\n    }\n\n    function _updateOperator(address _newOperator) private {\n        if (_newOperator == address(0)) {\n            revert ZeroAddressNotAllowed();\n        }\n\n        if (_newOperator == operator) {\n            revert OperatorAlreadySet();\n        }\n\n        address oldOperator = operator;\n        operator = _newOperator;\n        emit OperatorUpdated(oldOperator, _newOperator);\n    }\n\n    function manageCaller(address newCaller) external onlyOwner whenNotPaused {\n        _manageCaller(newCaller);\n    }\n\n    function _manageCaller(address _newCaller) private {\n        if (_newCaller == address(0)) {\n            revert ZeroAddressNotAllowed();\n        }\n\n        if (caller == _newCaller) {\n            revert CallerStatusAlreadySet();\n        }\n\n        address oldCaller = caller;\n        caller = _newCaller;\n\n        emit ManageCaller(oldCaller, _newCaller);\n    }\n\n    function pause() external onlyOperator {\n        _pause();\n    }\n\n    function unpause() external onlyOwner {\n        _unpause();\n    }\n\n    function updateSafe(address _bksafe) external onlyOwner {\n        _updateSafe(_bksafe);\n    }\n\n    function _updateSafe(address _newSafe) private {\n        if (_newSafe == address(0)) {\n            revert ZeroAddressNotAllowed();\n        }\n\n        if (_newSafe == safe) {\n            revert SafeAlreadySet();\n        }\n\n        address oldSafe = safe;\n        safe = _newSafe;\n        emit SafeUpdated(oldSafe, _newSafe);\n    }\n\n    function rescueERC20(address asset) external onlyOperator {\n        IERC20(asset).safeTransfer(safe, IERC20(asset).balanceOf(address(this)));\n        emit RescueERC20(asset, safe);\n    }\n\n    function rescueETH() external onlyOperator {\n        _transferEth(safe, address(this).balance);\n        emit RescueETH(safe, address(this).balance);\n    }\n\n    function _transferEth(address _to, uint256 _amount) internal {\n        bool callStatus;\n        assembly {\n            // Transfer the ETH and store if it succeeded or not.\n            callStatus := call(gas(), _to, _amount, 0, 0, 0, 0)\n        }\n        require(callStatus, \"_transferEth: Eth transfer failed\");\n    }\n}\n"},{"file_path":"contracts/MintUtil.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.26;\n\nimport \"@openzeppelin/contracts/utils/Address.sol\";\n\nlibrary MintUtil {\n    bytes4 private constant _MINT_SELECTOR = bytes4(keccak256(\"mint(uint256)\"));\n\n    function safeMint(uint256 amount, address tokenContract) internal {\n        bytes memory data = abi.encodeWithSelector(_MINT_SELECTOR, amount);\n        Address.functionCall(tokenContract, data);\n    }\n}\n"},{"file_path":"contracts/interfaces/ICommon.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.26;\n\ninterface ICommon {\n    error OnlyOperator();\n    error OnlyCaller();\n\n    error ZeroAddressNotAllowed();\n    error SafeAlreadySet();\n    error OperatorAlreadySet();\n    error CallerStatusAlreadySet();\n\n    event RescueETH(address indexed recipient, uint256 amount);\n    event RescueERC20(address indexed asset, address recipient);\n    event OperatorUpdated(address indexed oldOperator, address indexed newOperator);\n    event SafeUpdated(address indexed oldOperator, address indexed newOperator);\n    event ManageCaller(address indexed oldCaller, address indexed newCaller);\n}\n"},{"file_path":"contracts/interfaces/IMinterContract.sol","source_code":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.26;\n\ninterface IMinterContract {\n    error MintAmountCanNotBeZero();\n    error MintAmountTooSmall();\n    error MintAmountTooLarge();\n    error DailyMintLimitExceeded();\n    error InvalidMintAmountRange();\n    error InvalidMintAmountLimit();\n    error InvalidMintAmount();\n\n    event MintParamsUpdated(\n        uint256 oldMinMint,\n        uint256 newMinMint,\n        uint256 oldMaxMint,\n        uint256 newMaxMint,\n        uint256 oldMaxDaily,\n        uint256 newMaxDaily\n    );\n}\n"}],"certified":false,"conflicting_implementations":null,"abi":[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_operator","type":"address"},{"internalType":"address","name":"_tokenContract","type":"address"},{"internalType":"address","name":"_safe","type":"address"},{"internalType":"address","name":"_initialCaller","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[],"name":"CallerStatusAlreadySet","type":"error"},{"inputs":[],"name":"DailyMintLimitExceeded","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"inputs":[],"name":"FailedCall","type":"error"},{"inputs":[{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"InvalidMintAmount","type":"error"},{"inputs":[],"name":"InvalidMintAmountLimit","type":"error"},{"inputs":[],"name":"InvalidMintAmountRange","type":"error"},{"inputs":[],"name":"MintAmountCanNotBeZero","type":"error"},{"inputs":[],"name":"MintAmountTooLarge","type":"error"},{"inputs":[],"name":"MintAmountTooSmall","type":"error"},{"inputs":[],"name":"OnlyCaller","type":"error"},{"inputs":[],"name":"OnlyOperator","type":"error"},{"inputs":[],"name":"OperatorAlreadySet","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"SafeAlreadySet","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"ZeroAddressNotAllowed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldCaller","type":"address"},{"indexed":true,"internalType":"address","name":"newCaller","type":"address"}],"name":"ManageCaller","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldMinMint","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newMinMint","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"oldMaxMint","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newMaxMint","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"oldMaxDaily","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newMaxDaily","type":"uint256"}],"name":"MintParamsUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOperator","type":"address"},{"indexed":true,"internalType":"address","name":"newOperator","type":"address"}],"name":"OperatorUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","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":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"address","name":"recipient","type":"address"}],"name":"RescueERC20","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RescueETH","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOperator","type":"address"},{"indexed":true,"internalType":"address","name":"newOperator","type":"address"}],"name":"SafeUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DECIMALS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SECONDS_PER_DAY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"caller","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dailyMintTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentDailyMintTotal","outputs":[{"internalType":"uint256","name":"total","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastMintTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newCaller","type":"address"}],"name":"manageCaller","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxMintAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintPerDay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minMintAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"operator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"}],"name":"rescueERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rescueETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"safe","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minMintAmount","type":"uint256"},{"internalType":"uint256","name":"_maxMintAmount","type":"uint256"},{"internalType":"uint256","name":"_maxMintPerDay","type":"uint256"}],"name":"updateMintAmountParams","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOperator","type":"address"}],"name":"updateOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_bksafe","type":"address"}],"name":"updateSafe","outputs":[],"stateMutability":"nonpayable","type":"function"}],"is_changed_bytecode":false,"is_partially_verified":false,"constructor_args":"0000000000000000000000003df3c01b72dc5d63565af0bcb20d847227c2201a0000000000000000000000005db8606f2927e7173b3cab5a4c512d9f00bbf1930000000000000000000000000520930f21b14cafac7a27b102487bee7138a0170000000000000000000000009287b8e84d972dd02f618bbed45b9a6d7ed1638400000000000000000000000069c46c049502aeb0d9c6a01432e1d2c2c8384993"}