{"file_path":"contracts/src/TokenContracts/TokenV1.sol","creation_status":"success","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.11;\n\nimport {AbstractTokenV1} from \"./AbstractTokenV1.sol\";\nimport {Ownable} from \"./Ownable.sol\";\nimport {Pausable} from \"./Pausable.sol\";\nimport {Blacklistable} from \"./Blacklistable.sol\";\nimport {Rescuable} from \"./Rescuable.sol\";\nimport {MinterManagementInterface} from \"../Minting/MinterManagerInterface.sol\";\n\n/**\n * @title TokenV1\n * @dev ERC20 Token backed by fiat reserves with additional functionality for minting, burning, pausing, blacklisting, and rescuing tokens.\n * Inherits MinterManagementInterface to comply with minter management specifications.\n */\ncontract TokenV1 is AbstractTokenV1, Ownable, Pausable, Blacklistable, Rescuable, MinterManagementInterface {\n string private _name;\n string private _symbol;\n uint8 private _decimals;\n string public currency;\n address public masterMinter;\n\n uint256 internal _totalSupply;\n\n mapping(address => uint256) internal balances;\n mapping(address => mapping(address => uint256)) internal allowed;\n mapping(address => bool) public isMinter;\n mapping(address => uint256) public minterAllowance; // Allowance set by approval\n\n /**\n * @dev Emitted when tokens are minted.\n * @param minter The address of the minter.\n * @param to The address of the recipient.\n * @param amount The amount of tokens minted.\n */\n event Mint(address indexed minter, address indexed to, uint256 amount);\n\n /**\n * @dev Emitted when tokens are burned.\n * @param burner The address of the burner.\n * @param amount The amount of tokens burned.\n */\n event Burn(address indexed burner, uint256 amount);\n\n /**\n * @dev Emitted when a minter is configured.\n * @param minter The address of the minter.\n * @param minterAllowedAmount The allowance of the minter.\n */\n event MinterConfigured(address indexed minter, uint256 minterAllowedAmount);\n\n /**\n * @dev Emitted when a minter is removed.\n * @param oldMinter The address of the removed minter.\n */\n event MinterRemoved(address indexed oldMinter);\n\n /**\n * @dev Emitted when the master minter is changed.\n * @param newMasterMinter The address of the new master minter.\n */\n event MasterMinterChanged(address indexed newMasterMinter);\n\n /**\n * @dev Emitted when the token decimals are set.\n * @param decimals The number of decimals set.\n */\n event TokenDecimalsSet(uint8 decimals);\n\n /**\n * @dev Emitted when a new master minter is set.\n * @param newMasterMinter The address of the new master minter.\n */\n event NewMasterMinter(address indexed newMasterMinter);\n\n /**\n * @dev Emitted when a new pauser is set.\n * @param newPauser The address of the new pauser.\n */\n event NewPauser(address indexed newPauser);\n\n /**\n * @dev Emitted when a new blacklister is set.\n * @param newBlacklister The address of the new blacklister.\n */\n event NewBlacklister(address indexed newBlacklister);\n\n /**\n * @dev Error thrown when the caller is not a minter.\n */\n error NotMinter();\n\n /**\n * @dev Error thrown when the caller is not the master minter.\n */\n error NotMasterMinter();\n\n /**\n * @dev Error thrown when a zero address is provided.\n */\n error NoZeroAddress();\n\n /**\n * @dev Error thrown when the mint amount is zero.\n */\n error MintMustBeGreaterThanZero();\n\n /**\n * @dev Error thrown when the amount exceeds the balance.\n */\n error AmountExceedsBalance();\n\n /**\n * @dev Error thrown when the burn amount is not greater than zero.\n */\n error BurnAmountNotGreaterThanZero();\n\n /**\n * @dev Error thrown when the allowance is exceeded.\n */\n error AllowanceExceeded();\n\n /**\n * @dev Error thrown when a minter tries to mint to a different address.\n */\n error NotSelfMinting();\n\n /**\n * @dev Error thrown when an attempt to decrease the allowance fails.\n * @param owner The owner address.\n * @param spender The spender address.\n * @param currentAllowance The current allowance.\n * @param decrement The decrement amount.\n */\n error FailedDecreaseAllowance(address owner, address spender, uint256 currentAllowance, uint256 decrement);\n\n /**\n * @dev Error thrown when an address is not blacklisted.\n */\n error NotBlacklisted();\n\n /**\n * @dev Error thrown when an address has zero balance.\n */\n error ZeroBalance();\n\n /**\n * @dev Modifier to make a function callable only by a minter.\n */\n modifier onlyMinter() {\n if (!isMinter[msg.sender]) revert NotMinter();\n _;\n }\n\n /**\n * @dev Modifier to make a function callable only by the master minter.\n */\n modifier onlyMasterMinter() {\n if (msg.sender != masterMinter) revert NotMasterMinter();\n _;\n }\n\n /**\n * @notice Initializes the token with given parameters at most once.\n * @param tokenName The name of the token.\n * @param tokenSymbol The symbol of the token.\n * @param tokenCurrency The currency of the token.\n * @param tokenDecimals The number of decimals the token uses.\n * @param newMasterMinter The address of the new master minter.\n * @param newPauser The address of the new pauser.\n * @param newBlacklister The address of the new blacklister.\n * @param newRescuer The address of the new rescuer.\n */\n function initializeToken(\n string calldata tokenName,\n string calldata tokenSymbol,\n string calldata tokenCurrency,\n uint8 tokenDecimals,\n address newMasterMinter,\n address newPauser,\n address newBlacklister,\n address newRescuer\n ) public initializer {\n Ownable.initialize(msg.sender);\n Pausable.initializePausable();\n\n if (newMasterMinter == address(0)) revert NoZeroAddress();\n if (newPauser == address(0)) revert NoZeroAddress();\n if (newBlacklister == address(0)) revert NoZeroAddress();\n if (newRescuer == address(0)) revert NoZeroAddress();\n\n _name = tokenName;\n _symbol = tokenSymbol;\n currency = tokenCurrency;\n _decimals = tokenDecimals;\n masterMinter = newMasterMinter;\n _pauser = newPauser;\n _blacklister = newBlacklister;\n _rescuer = newRescuer;\n\n emit NewMasterMinter(newMasterMinter);\n emit NewPauser(newPauser);\n emit NewBlacklister(newBlacklister);\n emit TokenDecimalsSet(tokenDecimals);\n emit RescuerChanged(newRescuer);\n }\n\n /**\n * @notice Returns the name of the token.\n * @return The name of the token.\n */\n function name() public view virtual returns (string memory) {\n return _name;\n }\n\n /**\n * @notice Returns the symbol of the token.\n * @return The symbol of the token.\n */\n function symbol() public view virtual returns (string memory) {\n return _symbol;\n }\n\n /**\n * @notice Returns the number of decimals used to get its user representation.\n * @return The number of decimals used by the token.\n */\n function decimals() public view virtual returns (uint8) {\n return _decimals;\n }\n\n /**\n * @notice Returns the minting allowance of a minter.\n * @param minter The address of the minter.\n * @return The minting allowance of the minter.\n */\n function getMinterAllowance(address minter) external view override returns (uint256) {\n return minterAllowance[minter];\n }\n\n /**\n * @notice Returns the amount of tokens that spender is allowed to transfer on behalf of owner.\n * @param owner Token owner's address.\n * @param spender Spender's address.\n * @return The allowance amount.\n */\n function allowance(address owner, address spender) external view override returns (uint256) {\n return allowed[owner][spender];\n }\n\n /**\n * @notice Returns the total supply of the token.\n * @return The total supply.\n */\n function totalSupply() external view override returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @notice Returns the token balance of an account.\n * @param account The address of the account.\n * @return The token balance of the account.\n */\n function balanceOf(address account) external view override returns (uint256) {\n return balances[account];\n }\n\n /**\n * @notice Sets spender's allowance over the caller's tokens to be a given value.\n * @param spender Spender's address.\n * @param value Allowance amount.\n * @return True if the operation was successful.\n */\n function approve(\n address spender,\n uint256 value\n )\n external\n override\n whenNotPaused\n notBlacklisted(msg.sender)\n notBlacklisted(spender)\n returns (bool)\n {\n _approve(msg.sender, spender, value);\n return true;\n }\n\n /**\n * @notice Internal function to set allowance.\n * @param owner Token owner's address.\n * @param spender Spender's address.\n * @param value Allowance amount.\n */\n function _approve(address owner, address spender, uint256 value) internal override {\n if (owner == address(0)) revert NoZeroAddress();\n if (spender == address(0)) revert NoZeroAddress();\n allowed[owner][spender] = value;\n emit Approval(owner, spender, value);\n }\n\n /**\n * @notice Transfers tokens from one address to another using allowance.\n * @param from Payer's address.\n * @param to Payee's address.\n * @param value Transfer amount.\n * @return True if the operation was successful.\n */\n function transferFrom(\n address from,\n address to,\n uint256 value\n )\n external\n override\n whenNotPaused\n notBlacklisted(msg.sender)\n notBlacklisted(from)\n notBlacklisted(to)\n returns (bool)\n {\n if (value > allowed[from][msg.sender]) revert AllowanceExceeded();\n _transfer(from, to, value);\n allowed[from][msg.sender] -= value;\n return true;\n }\n\n /**\n * @notice Transfers tokens from the caller to another address.\n * @param to Payee's address.\n * @param value Transfer amount.\n * @return True if the operation was successful.\n */\n function transfer(\n address to,\n uint256 value\n )\n external\n override\n whenNotPaused\n notBlacklisted(msg.sender)\n notBlacklisted(to)\n returns (bool)\n {\n _transfer(msg.sender, to, value);\n return true;\n }\n\n /**\n * @notice Internal function to process token transfers.\n * @param from Payer's address.\n * @param to Payee's address.\n * @param value Transfer amount.\n */\n function _transfer(address from, address to, uint256 value) internal override {\n if (from == address(0)) revert NoZeroAddress();\n if (to == address(0)) revert NoZeroAddress();\n if (value > balances[from]) revert AmountExceedsBalance();\n\n balances[from] -= value;\n balances[to] += value;\n emit Transfer(from, to, value);\n }\n\n /**\n * @notice Configures a new minter or updates the allowance of an existing minter.\n * @param minter The address of the minter.\n * @param _minterAllowedAmount The minting allowance for the minter.\n * @return True if the operation was successful.\n */\n function configureMinter(\n address minter,\n uint256 _minterAllowedAmount\n ) external override whenNotPaused onlyMasterMinter returns (bool) {\n isMinter[minter] = true;\n minterAllowance[minter] = _minterAllowedAmount;\n\n emit MinterConfigured(minter, _minterAllowedAmount);\n return true;\n }\n\n /**\n * @notice Removes a minter.\n * @param minter The address of the minter to remove.\n * @return True if the operation was successful.\n */\n function removeMinter(address minter) external override onlyMasterMinter returns (bool) {\n isMinter[minter] = false;\n minterAllowance[minter] = 0;\n emit MinterRemoved(minter);\n return true;\n }\n\n /**\n * @notice Allows a minter to burn some of its own tokens.\n * @param _amount The amount of tokens to be burned.\n */\n function burn(uint256 _amount) external whenNotPaused onlyMinter notBlacklisted(msg.sender) {\n uint256 balance = balances[msg.sender];\n if (_amount <= 0) revert BurnAmountNotGreaterThanZero();\n if (balance < _amount) revert AmountExceedsBalance();\n\n _totalSupply -= _amount;\n balances[msg.sender] -= _amount;\n emit Burn(msg.sender, _amount);\n emit Transfer(msg.sender, address(0), _amount);\n }\n\n /**\n * @notice Allows a minter to minter some of its tokens from allowance.\n * @param _to The address to receive the minted tokens.\n * @param _amount The amount of tokens to mint.\n * @return True if the operation was successful.\n */\n function mint(\n address _to,\n uint256 _amount\n ) public whenNotPaused onlyMinter notBlacklisted(msg.sender) notBlacklisted(_to) returns (bool) {\n if (_to == address(0)) revert NoZeroAddress();\n if (_amount <= 0) revert MintMustBeGreaterThanZero();\n if (msg.sender != _to) revert NotSelfMinting();\n if (minterAllowance[_to] < _amount) revert AllowanceExceeded();\n\n _totalSupply += _amount;\n balances[_to] += _amount;\n minterAllowance[_to] -= _amount;\n emit Mint(msg.sender, _to, _amount);\n emit Transfer(address(0), _to, _amount);\n return true;\n }\n\n /**\n * @notice Updates the master minter address.\n * @param _newMasterMinter The address of the new master minter.\n */\n function updateMasterMinter(address _newMasterMinter) external onlyOwner {\n if (_newMasterMinter == address(0)) revert NoZeroAddress();\n masterMinter = _newMasterMinter;\n emit MasterMinterChanged(masterMinter);\n }\n\n /**\n * @notice Increases the allowance by a given increment.\n * @param spender Spender's address.\n * @param increment The amount to increase the allowance by.\n * @return True if the operation was successful.\n */\n function increaseAllowance(\n address spender,\n uint256 increment\n ) external whenNotPaused notBlacklisted(msg.sender) notBlacklisted(spender) returns (bool) {\n address owner = msg.sender;\n _approve(owner, spender, allowed[owner][spender] + increment);\n\n return true;\n }\n\n /**\n * @notice Decreases the allowance by a given decrement.\n * @param spender Spender's address.\n * @param decrement The amount to decrease the allowance by.\n * @return True if the operation was successful.\n */\n function decreaseAllowance(\n address spender,\n uint256 decrement\n ) external whenNotPaused notBlacklisted(msg.sender) notBlacklisted(spender) returns (bool) {\n address owner = msg.sender;\n uint256 currentAllowance = allowed[owner][spender];\n if (currentAllowance < decrement) {\n revert FailedDecreaseAllowance(owner, spender, currentAllowance, decrement);\n }\n\n _approve(owner, spender, currentAllowance - decrement);\n return true;\n }\n\n /**\n * @notice Wipes the balance of a blacklisted address, decreasing the totalSupply.\n * @dev Only the owner can call this function, and the address must be blacklisted.\n * @param _account The address to wipe.\n */\n function wipeBlacklistedAddress(address _account) external onlyOwner {\n if (!blacklisted[_account]) revert NotBlacklisted();\n uint256 balance = balances[_account];\n if (balance == 0) revert ZeroBalance();\n _totalSupply -= balance;\n balances[_account] = 0;\n \n emit Transfer(_account, address(0), balance);\n }\n\n // Storage Gap for future upgrades\n uint256[49] private __gap;\n}\n","deployed_bytecode":"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","optimization_enabled":true,"verified_twin_address_hash":null,"is_verified":true,"compiler_settings":{"libraries":{},"metadata":{"useLiteralContent":true},"optimizer":{"enabled":true,"runs":10000},"outputSelection":{"*":{"":["*"],"*":["*"]}}},"optimization_runs":10000,"sourcify_repo_url":null,"decoded_constructor_args":null,"compiler_version":"v0.8.11+commit.d7f03943","is_verified_via_verifier_alliance":false,"verified_at":"2026-07-02T19:38:27.240003Z","implementations":[],"proxy_type":null,"external_libraries":[],"creation_bytecode":"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","name":"TokenV1","is_blueprint":false,"license_type":"none","is_fully_verified":true,"is_verified_via_eth_bytecode_db":false,"language":"solidity","evm_version":"default","can_be_visualized_via_sol2uml":true,"is_verified_via_sourcify":false,"additional_sources":[{"file_path":"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n * function initialize() initializer public {\n * __ERC20_init(\"MyToken\", \"MTK\");\n * }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n * function initializeV2() reinitializer(2) public {\n * __ERC20Permit_init(\"MyToken\");\n * }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n * _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n /**\n * @dev Indicates that the contract has been initialized.\n * @custom:oz-retyped-from bool\n */\n uint8 private _initialized;\n\n /**\n * @dev Indicates that the contract is in the process of being initialized.\n */\n bool private _initializing;\n\n /**\n * @dev Triggered when the contract has been initialized or reinitialized.\n */\n event Initialized(uint8 version);\n\n /**\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n * `onlyInitializing` functions can be used to initialize parent contracts.\n *\n * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\n * constructor.\n *\n * Emits an {Initialized} event.\n */\n modifier initializer() {\n bool isTopLevelCall = !_initializing;\n require(\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n \"Initializable: contract is already initialized\"\n );\n _initialized = 1;\n if (isTopLevelCall) {\n _initializing = true;\n }\n _;\n if (isTopLevelCall) {\n _initializing = false;\n emit Initialized(1);\n }\n }\n\n /**\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n * used to initialize parent contracts.\n *\n * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n * are added through upgrades and that require initialization.\n *\n * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n * cannot be nested. If one is invoked in the context of another, execution will revert.\n *\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n * a contract, executing them in the right order is up to the developer or operator.\n *\n * WARNING: setting the version to 255 will prevent any future reinitialization.\n *\n * Emits an {Initialized} event.\n */\n modifier reinitializer(uint8 version) {\n require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n _initialized = version;\n _initializing = true;\n _;\n _initializing = false;\n emit Initialized(version);\n }\n\n /**\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\n */\n modifier onlyInitializing() {\n require(_initializing, \"Initializable: contract is not initializing\");\n _;\n }\n\n /**\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n * through proxies.\n *\n * Emits an {Initialized} event the first time it is successfully executed.\n */\n function _disableInitializers() internal virtual {\n require(!_initializing, \"Initializable: contract is initializing\");\n if (_initialized != type(uint8).max) {\n _initialized = type(uint8).max;\n emit Initialized(type(uint8).max);\n }\n }\n\n /**\n * @dev Returns the highest version that has been initialized. See {reinitializer}.\n */\n function _getInitializedVersion() internal view returns (uint8) {\n return _initialized;\n }\n\n /**\n * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n */\n function _isInitializing() internal view returns (bool) {\n return _initializing;\n }\n}\n"},{"file_path":"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n *\n * Furthermore, `isContract` will also return true if the target contract within\n * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n * which only has an effect at the end of a transaction.\n * ====\n *\n * [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n *\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\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.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\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, it is bubbled up by this\n * function (like regular Solidity function calls).\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 * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\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 * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n *\n * _Available since v4.8._\n */\n function verifyCallResultFromTarget(\n address target,\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n if (success) {\n if (returndata.length == 0) {\n // only check isContract if the call was successful and the return data is empty\n // otherwise we already know that it was a contract\n require(isContract(target), \"Address: call to non-contract\");\n }\n return returndata;\n } else {\n _revert(returndata, errorMessage);\n }\n }\n\n /**\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason or using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n _revert(returndata, errorMessage);\n }\n }\n\n function _revert(bytes memory returndata, string memory errorMessage) 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 /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n}\n"},{"file_path":"@openzeppelin/contracts/token/ERC20/IERC20.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\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 amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` 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 amount) 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 `amount` as the allowance of `spender` over the 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 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `from` to `to` using the\n * allowance mechanism. `amount` 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 amount) external returns (bool);\n}\n"},{"file_path":"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * ==== Security Considerations\n *\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\n * generally recommended is:\n *\n * ```solidity\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\n * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\n * doThing(..., value);\n * }\n *\n * function doThing(..., uint256 value) public {\n * token.safeTransferFrom(msg.sender, address(this), value);\n * ...\n * }\n * ```\n *\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\n * {SafeERC20-safeTransferFrom}).\n *\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\n * contracts should have entry points that don't rely on permit.\n */\ninterface IERC20Permit {\n /**\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n * given ``owner``'s signed approval.\n *\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n * ordering also apply here.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `deadline` must be a timestamp in the future.\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n * over the EIP712-formatted function arguments.\n * - the signature must use ``owner``'s current nonce (see {nonces}).\n *\n * For more information on the signature format, see the\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n * section].\n *\n * CAUTION: See Security Considerations above.\n */\n function permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external;\n\n /**\n * @dev Returns the current nonce for `owner`. This value must be\n * included whenever a signature is generated for {permit}.\n *\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\n * prevents a signature from being used multiple times.\n */\n function nonces(address owner) external view returns (uint256);\n\n /**\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n */\n // solhint-disable-next-line func-name-mixedcase\n function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"},{"file_path":"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\nimport \"../extensions/IERC20Permit.sol\";\nimport \"../../../utils/Address.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 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 using Address for address;\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.encodeWithSelector(token.transfer.selector, 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.encodeWithSelector(token.transferFrom.selector, from, to, value));\n }\n\n /**\n * @dev Deprecated. This function has issues similar to the ones found in\n * {IERC20-approve}, and its usage is discouraged.\n *\n * Whenever possible, use {safeIncreaseAllowance} and\n * {safeDecreaseAllowance} instead.\n */\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\n // safeApprove should only be called when setting an initial allowance,\n // or when resetting it to zero. To increase and decrease it, use\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n require(\n (value == 0) || (token.allowance(address(this), spender) == 0),\n \"SafeERC20: approve from non-zero to non-zero allowance\"\n );\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 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 function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n uint256 oldAllowance = token.allowance(address(this), spender);\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\n }\n\n /**\n * @dev Decrease 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 function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n unchecked {\n uint256 oldAllowance = token.allowance(address(this), spender);\n require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\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 function forceApprove(IERC20 token, address spender, uint256 value) internal {\n bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\n\n if (!_callOptionalReturnBool(token, approvalCall)) {\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\n _callOptionalReturn(token, approvalCall);\n }\n }\n\n /**\n * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\n * Revert on invalid signature.\n */\n function safePermit(\n IERC20Permit token,\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) internal {\n uint256 nonceBefore = token.nonces(owner);\n token.permit(owner, spender, value, deadline, v, r, s);\n uint256 nonceAfter = token.nonces(owner);\n require(nonceAfter == nonceBefore + 1, \"SafeERC20: permit did not succeed\");\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 function _callOptionalReturn(IERC20 token, bytes memory data) private {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\n // the target address contains contract code and also asserts for success in the low-level call.\n\n bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n require(returndata.length == 0 || abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\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 silents catches all reverts and returns a bool instead.\n */\n function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\n // and not revert is the subcall reverts.\n\n (bool success, bytes memory returndata) = address(token).call(data);\n return\n success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));\n }\n}\n"},{"file_path":"@openzeppelin/contracts/utils/Address.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n *\n * Furthermore, `isContract` will also return true if the target contract within\n * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n * which only has an effect at the end of a transaction.\n * ====\n *\n * [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n *\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\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.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\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, it is bubbled up by this\n * function (like regular Solidity function calls).\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 * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\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 * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n }\n\n /**\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n *\n * _Available since v4.8._\n */\n function verifyCallResultFromTarget(\n address target,\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n if (success) {\n if (returndata.length == 0) {\n // only check isContract if the call was successful and the return data is empty\n // otherwise we already know that it was a contract\n require(isContract(target), \"Address: call to non-contract\");\n }\n return returndata;\n } else {\n _revert(returndata, errorMessage);\n }\n }\n\n /**\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason or using the provided one.\n *\n * _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n _revert(returndata, errorMessage);\n }\n }\n\n function _revert(bytes memory returndata, string memory errorMessage) 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 /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n}\n"},{"file_path":"contracts/src/Minting/MinterManagerInterface.sol","source_code":"//SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.11;\n\n/**\n * @title MinterManagementInterface\n * @notice Interface that defines external functions for managing minters and their allowances.\n * @dev Implementing contracts should provide functionality for adding, removing, and configuring minters.\n */\ninterface MinterManagementInterface {\n /**\n * @notice Checks if an account is a registered minter.\n * @param _account The address to check.\n * @return A boolean indicating whether the address is a minter.\n */\n function isMinter(address _account) external view returns (bool);\n\n /**\n * @notice Gets the allowance of a minter.\n * @param _minter The address of the minter.\n * @return The amount of tokens the minter is allowed to mint.\n */\n function getMinterAllowance(address _minter) external view returns (uint256);\n\n /**\n * @notice Configures a new minter or updates the allowance of an existing minter.\n * @param _minter The address of the minter.\n * @param _minterAllowedAmount The new allowance for the minter.\n * @return A boolean indicating whether the configuration was successful.\n */\n function configureMinter(address _minter, uint256 _minterAllowedAmount) external returns (bool);\n\n /**\n * @notice Removes a minter.\n * @param _minter The address of the minter to remove.\n * @return A boolean indicating whether the removal was successful.\n */\n function removeMinter(address _minter) external returns (bool);\n}\n"},{"file_path":"contracts/src/TokenContracts/AbstractTokenV1.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.11;\n\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\n/**\n * @title AbstractTokenV1\n * @dev Abstract contract for ERC20 token operations. Defines internal functions for approving and transferring tokens.\n * Inherits from the IERC20 interface.\n */\nabstract contract AbstractTokenV1 is IERC20 {\n /**\n * @notice Internal function to set the allowance for a spender over the owner's tokens.\n * @param owner The address of the token owner.\n * @param spender The address of the spender.\n * @param value The amount of tokens the spender is allowed to spend.\n * @dev This function must be overridden in the derived contract.\n */\n function _approve(address owner, address spender, uint256 value) internal virtual;\n\n /**\n * @notice Internal function to transfer tokens from one address to another.\n * @param from The address of the token sender.\n * @param to The address of the token recipient.\n * @param value The amount of tokens to transfer.\n * @dev This function must be overridden in the derived contract.\n */\n function _transfer(address from, address to, uint256 value) internal virtual;\n\n // Storage Gap for future upgrades\n uint256[49] private __gap;\n}\n"},{"file_path":"contracts/src/TokenContracts/Blacklistable.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.11;\n\nimport {PermissionAdmin} from \"./PermissionAdmin.sol\";\n\n/**\n * @title Blacklistable\n * @notice Contract that allows accounts to be blacklisted by a \"blacklister\" role.\n * @dev Inherits from PermissionAdmin to manage blacklister permissions.\n */\nabstract contract Blacklistable is PermissionAdmin {\n address internal _blacklister;\n mapping(address => bool) public blacklisted;\n\n /// @notice Emitted when an account is blacklisted.\n /// @param _account The address of the blacklisted account.\n event Blacklisted(address indexed _account);\n\n /// @notice Emitted when an account is removed from the blacklist.\n /// @param _account The address of the unblacklisted account.\n event UnBlacklisted(address indexed _account);\n\n /// @notice Emitted when the blacklister is changed.\n /// @param newBlacklister The address of the new blacklister.\n event BlacklisterChanged(address indexed newBlacklister);\n\n /// @notice Error thrown when the caller is not the blacklister.\n error Blacklistable__CallerNotBlacklister();\n\n /// @notice Error thrown when trying to perform an operation with the zero address, which is prohibited.\n error Blacklistable__NoZeroAddress();\n\n /// @notice Error thrown when the account is already blacklisted.\n /// @param account The address that is already blacklisted.\n error Blacklistable__AccountBlacklisted(address account);\n\n /// @notice Error thrown when the blacklister tries to blacklist themselves.\n error Blacklistable__BlacklisterSelfBlacklist();\n\n /// @notice Error thrown when trying to unblacklist an address that is already non blacklisted.\n error Blacklistable__NotBlacklisted(address account);\n\n /**\n * @dev Modifier to make a function callable only by the blacklister.\n */\n modifier onlyBlacklister() {\n if (msg.sender != _blacklister) revert Blacklistable__CallerNotBlacklister();\n _;\n }\n\n /**\n * @dev Ensures the specified account is not blacklisted and the blacklister is properly set.\n * @param _account The address to check for blacklisting.\n * @custom:revert Blacklistable__NoZeroAddress if the blacklister address has not been set (is zero).\n * @custom:revert Blacklistable__AccountBlacklisted if the account is blacklisted.\n */\n modifier notBlacklisted(address _account) {\n if (_blacklister == address(0)) revert Blacklistable__NoZeroAddress();\n if (blacklisted[_account]) revert Blacklistable__AccountBlacklisted(_account);\n _;\n }\n\n /**\n * @notice Returns the current blacklister.\n * @return The address of the current blacklister.\n */\n function getBlacklister() external view returns (address) {\n return _blacklister;\n }\n\n /**\n * @notice Checks if an account is blacklisted.\n * @param _account The address to check.\n * @return True if the account is blacklisted, false otherwise.\n */\n function isBlacklisted(address _account) external view returns (bool) {\n return blacklisted[_account];\n }\n\n /**\n * @notice Adds an account to the blacklist.\n * @param _account The address to blacklist.\n * @dev Emits a {Blacklisted} event.\n * @dev Can only be called by the current blacklister.\n * @dev The address cannot be the zero address or the blacklister's own address.\n */\n function blacklist(address _account) external onlyBlacklister {\n if (blacklisted[_account]) revert Blacklistable__AccountBlacklisted(_account);\n if (_account == _blacklister) revert Blacklistable__BlacklisterSelfBlacklist();\n if (_account == address(0)) revert Blacklistable__NoZeroAddress();\n blacklisted[_account] = true;\n emit Blacklisted(_account);\n }\n\n /**\n * @notice Removes an account from the blacklist.\n * @param _account The address to remove from the blacklist.\n * @dev Emits an {UnBlacklisted} event.\n * @dev Can only be called by the current blacklister.\n */\n function unBlacklist(address _account) external onlyBlacklister {\n if (!blacklisted[_account]) revert Blacklistable__NotBlacklisted(_account);\n blacklisted[_account] = false;\n emit UnBlacklisted(_account);\n }\n\n /**\n * @notice Updates the blacklister role to a new address.\n * @param _newBlacklister The address of the new blacklister.\n * @dev Emits a {BlacklisterChanged} event.\n * @dev Can only be called by the permission admin.\n * @dev The new blacklister address cannot be the zero address.\n */\n function updateBlacklister(address _newBlacklister) external onlyPermissionAdmin {\n if (_newBlacklister == address(0)) revert Blacklistable__NoZeroAddress();\n _blacklister = _newBlacklister;\n emit BlacklisterChanged(_blacklister);\n }\n\n // Storage Gap for future upgrades\n uint256[49] private __gap;\n}\n"},{"file_path":"contracts/src/TokenContracts/Ownable.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.11;\n\nimport {Initializable} from \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\n\n/**\n * @title Ownable\n * @dev The Ownable contract has an owner address and provides basic authorization control functions.\n * Inherits from Initializable for upgradeable contract pattern.\n */\ncontract Ownable is Initializable {\n // Address of the contract owner\n address private _owner;\n\n // Address of the pending owner\n address private _pendingOwner;\n\n /**\n * @notice Error thrown when a zero address is provided.\n */\n error Ownable__NoZeroAddress();\n\n /**\n * @notice Error thrown when a caller is not the owner.\n */\n error Ownable__CallerNotOwner();\n\n /**\n * @notice Error thrown when a caller is not the pending owner.\n */\n error Ownable__CallerNotPendingOwner();\n\n /**\n * @dev Event emitted when ownership is transferred.\n * @param previousOwner The address of the previous owner.\n * @param newOwner The address of the new owner.\n */\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Event emitted when ownership transfer is started.\n * @param previousOwner The address of the previous owner.\n * @param newOwner The address of the new owner.\n */\n event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Modifier to check if the caller is the owner.\n */\n modifier onlyOwner() {\n if (msg.sender != _owner) revert Ownable__CallerNotOwner();\n _;\n }\n\n /**\n * @dev Modifier to check if the caller is the pending owner.\n */\n modifier onlyPendingOwner() {\n if (msg.sender != _pendingOwner) revert Ownable__CallerNotPendingOwner();\n _;\n }\n\n /**\n * @notice Initializes the contract setting the deployer as the initial owner.\n * @param owner The address of the initial owner.\n */\n function initialize(address owner) public onlyInitializing {\n setOwner(owner);\n }\n\n /**\n * @notice Returns the address of the current owner.\n * @return The address of the owner.\n */\n function getOwner() external view returns (address) {\n return _owner;\n }\n\n /**\n * @notice Returns the address of the pending owner.\n * @return The address of the pending owner.\n */\n function getPendingOwner() external view returns (address) {\n return _pendingOwner;\n }\n\n /**\n * @dev Sets a new owner address internally.\n * @param newOwner The address to set as the new owner.\n */\n function setOwner(address newOwner) internal {\n _owner = newOwner;\n }\n\n /**\n * @notice Starts the ownership transfer of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n * @param newOwner The address to transfer ownership to.\n */\n function transferOwnership(address newOwner) external onlyOwner {\n if (newOwner == address(0)) revert Ownable__NoZeroAddress();\n _pendingOwner = newOwner;\n emit OwnershipTransferStarted(_owner, newOwner);\n }\n\n /**\n * @notice The new owner accepts the ownership transfer.\n * Can only be called by the pending owner.\n */\n function acceptOwnership() external onlyPendingOwner {\n address oldOwner = _owner;\n setOwner(_pendingOwner);\n _pendingOwner = address(0);\n emit OwnershipTransferred(oldOwner, _owner);\n }\n\n // Storage Gap for future upgrades\n uint256[49] private __gap;\n}"},{"file_path":"contracts/src/TokenContracts/Pausable.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.11;\n\nimport {PermissionAdmin} from \"./PermissionAdmin.sol\";\n\n/**\n * @title Pausable\n * @notice Base contract which allows children to implement an emergency stop mechanism.\n * @dev Inherits from PermissionAdmin to manage pauser permissions.\n */\nabstract contract Pausable is PermissionAdmin {\n address internal _pauser;\n bool public paused;\n\n /// @notice Emitted when the contract is paused.\n event Paused();\n\n /// @notice Emitted when the contract is unpaused.\n event Unpaused();\n\n /// @notice Emitted when the pauser is changed.\n /// @param newPauser The address of the new pauser.\n event PauserChanged(address indexed newPauser);\n\n /// @notice Error thrown when trying to perform an action while the contract is paused.\n error Pausable__Paused();\n\n /// @notice Error thrown when the caller is not the pauser.\n error Pausable__CallerNotPauser();\n\n /// @notice Error thrown when trying to pause the contract when it is already paused.\n error Pausable__AlreadyPaused();\n\n /// @notice Error thrown when trying to unpause the contract when it is not paused.\n error Pausable__AlreadyUnpaused();\n\n /// @notice Error thrown when trying to set the pauser to the zero address.\n error Pausable__NoZeroAddress();\n\n /**\n * @dev Modifier to make a function callable only when the contract is not paused.\n */\n modifier whenNotPaused() {\n if (paused) revert Pausable__Paused();\n _;\n }\n\n /**\n * @dev Modifier to make a function callable only by the pauser.\n */\n modifier onlyPauser() {\n if (msg.sender != _pauser) revert Pausable__CallerNotPauser();\n _;\n }\n\n /**\n * @notice Returns the current pauser.\n * @return The address of the current pauser.\n */\n function getPauser() external view returns (address) {\n return _pauser;\n }\n\n /**\n * @notice Called by the pauser to pause the contract, triggering the stopped state.\n * @dev Emits a {Paused} event.\n * @dev Can only be called by the current pauser.\n */\n function pause() external onlyPauser {\n if (paused) revert Pausable__AlreadyPaused();\n paused = true;\n emit Paused();\n }\n\n /**\n * @notice Initializes the contract in an unpaused state.\n * @dev This function should be called during contract initialization.\n */\n function initializePausable() public onlyInitializing {\n paused = false;\n }\n\n /**\n * @notice Called by the pauser to unpause the contract, returning to normal state.\n * @dev Emits an {Unpaused} event.\n * @dev Can only be called by the current pauser.\n */\n function unpause() external onlyPauser {\n if (!paused) revert Pausable__AlreadyUnpaused();\n paused = false;\n emit Unpaused();\n }\n\n /**\n * @notice Updates the pauser role to a new address.\n * @param _newPauser The address of the new pauser.\n * @dev Emits a {PauserChanged} event.\n * @dev Can only be called by the permission admin.\n * @dev The new pauser address cannot be the zero address.\n */\n function updatePauser(address _newPauser) external onlyPermissionAdmin {\n if (_newPauser == address(0)) revert Pausable__NoZeroAddress();\n _pauser = _newPauser;\n emit PauserChanged(_pauser);\n }\n\n // Storage Gap for future upgrades\n uint256[49] private __gap;\n}\n"},{"file_path":"contracts/src/TokenContracts/PermissionAdmin.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.11;\n\nimport {Ownable} from \"./Ownable.sol\";\n\n/**\n * @title PermissionAdmin\n * @notice Base contract which allows the owner to set an admin with the ability to select the pauser, blacklister, and rescuer.\n * @dev Only the contract owner can modify the admin. The admin has special permissions defined by this contract.\n */\nabstract contract PermissionAdmin is Ownable {\n address private _permissionAdmin;\n\n /// @notice Emitted when the permission admin is changed.\n /// @param admin The new permission admin.\n event PermissionAdminChanged(address indexed admin);\n\n /// @notice Error thrown when the caller is not the permission admin.\n error PermissionAdmin__CallerNotPermissionAdmin();\n\n /// @notice Error thrown when trying to set the permission admin to the zero address.\n error PermissionAdmin__NoZeroAddress();\n \n /**\n * @dev Modifier to make a function callable only by the permission admin.\n */\n modifier onlyPermissionAdmin() {\n if (msg.sender != _permissionAdmin) {\n revert PermissionAdmin__CallerNotPermissionAdmin();\n }\n _;\n }\n\n /**\n * @notice Returns the current permission admin.\n * @return The address of the current permission admin.\n */\n function getPermissionAdmin() external view returns (address) {\n return _permissionAdmin;\n }\n\n /**\n * @notice Sets a new permission admin.\n * @param _newAdmin The address of the new permission admin.\n * @dev Only the contract owner can call this function. The new admin address cannot be the zero address.\n */\n function setPermissionAdmin(address _newAdmin) external onlyOwner {\n if (_newAdmin == address(0)) revert PermissionAdmin__NoZeroAddress();\n _permissionAdmin = _newAdmin;\n emit PermissionAdminChanged(_permissionAdmin);\n }\n\n // Storage Gap for future upgrades\n uint256[49] private __gap;\n}\n"},{"file_path":"contracts/src/TokenContracts/Rescuable.sol","source_code":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.11;\n\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {SafeERC20} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport {PermissionAdmin} from \"./PermissionAdmin.sol\";\n\n/**\n * @title Rescuable\n * @notice Contract that allows rescuing ERC20 tokens locked up in this contract by a \"rescuer\" role.\n * @dev Inherits from PermissionAdmin to manage rescuer permissions.\n */\nabstract contract Rescuable is PermissionAdmin {\n using SafeERC20 for IERC20;\n\n address internal _rescuer;\n\n /// @notice Error thrown when the caller is not the rescuer.\n error Rescuable__CallerNotRescuer();\n\n /// @notice Error thrown when trying to set the rescuer to the zero address.\n error Rescuable__NoZeroAddress();\n\n /// @notice Emitted when the rescuer is changed.\n /// @param newRescuer The address of the new rescuer.\n event RescuerChanged(address indexed newRescuer);\n\n /**\n * @notice Returns the current rescuer.\n * @return The address of the current rescuer.\n */\n function rescuer() external view returns (address) {\n return _rescuer;\n }\n\n /**\n * @dev Modifier to make a function callable only by the rescuer.\n */\n modifier onlyRescuer() {\n if (msg.sender != _rescuer) revert Rescuable__CallerNotRescuer();\n _;\n }\n\n /**\n * @notice Rescue ERC20 tokens locked up in this contract.\n * @param tokenContract The address of the ERC20 token contract.\n * @param to The recipient address to receive the rescued tokens.\n * @param amount The amount of tokens to withdraw.\n * @dev Can only be called by the current rescuer.\n */\n function rescueERC20(\n IERC20 tokenContract,\n address to,\n uint256 amount\n ) external onlyRescuer {\n tokenContract.safeTransfer(to, amount);\n }\n\n /**\n * @notice Assign the rescuer role to a given address.\n * @param newRescuer The address of the new rescuer.\n * @dev Emits a {RescuerChanged} event.\n * @dev Can only be called by the permission admin.\n * @dev The new rescuer address cannot be the zero address.\n */\n function updateRescuer(address newRescuer) external onlyPermissionAdmin {\n if (newRescuer == address(0)) revert Rescuable__NoZeroAddress();\n _rescuer = newRescuer;\n emit RescuerChanged(newRescuer);\n }\n\n // Storage Gap for future upgrades\n uint256[49] private __gap;\n}\n"}],"certified":false,"conflicting_implementations":null,"abi":[{"inputs":[],"name":"AllowanceExceeded","type":"error"},{"inputs":[],"name":"AmountExceedsBalance","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"Blacklistable__AccountBlacklisted","type":"error"},{"inputs":[],"name":"Blacklistable__BlacklisterSelfBlacklist","type":"error"},{"inputs":[],"name":"Blacklistable__CallerNotBlacklister","type":"error"},{"inputs":[],"name":"Blacklistable__NoZeroAddress","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"Blacklistable__NotBlacklisted","type":"error"},{"inputs":[],"name":"BurnAmountNotGreaterThanZero","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"currentAllowance","type":"uint256"},{"internalType":"uint256","name":"decrement","type":"uint256"}],"name":"FailedDecreaseAllowance","type":"error"},{"inputs":[],"name":"MintMustBeGreaterThanZero","type":"error"},{"inputs":[],"name":"NoZeroAddress","type":"error"},{"inputs":[],"name":"NotBlacklisted","type":"error"},{"inputs":[],"name":"NotMasterMinter","type":"error"},{"inputs":[],"name":"NotMinter","type":"error"},{"inputs":[],"name":"NotSelfMinting","type":"error"},{"inputs":[],"name":"Ownable__CallerNotOwner","type":"error"},{"inputs":[],"name":"Ownable__CallerNotPendingOwner","type":"error"},{"inputs":[],"name":"Ownable__NoZeroAddress","type":"error"},{"inputs":[],"name":"Pausable__AlreadyPaused","type":"error"},{"inputs":[],"name":"Pausable__AlreadyUnpaused","type":"error"},{"inputs":[],"name":"Pausable__CallerNotPauser","type":"error"},{"inputs":[],"name":"Pausable__NoZeroAddress","type":"error"},{"inputs":[],"name":"Pausable__Paused","type":"error"},{"inputs":[],"name":"PermissionAdmin__CallerNotPermissionAdmin","type":"error"},{"inputs":[],"name":"PermissionAdmin__NoZeroAddress","type":"error"},{"inputs":[],"name":"Rescuable__CallerNotRescuer","type":"error"},{"inputs":[],"name":"Rescuable__NoZeroAddress","type":"error"},{"inputs":[],"name":"ZeroBalance","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_account","type":"address"}],"name":"Blacklisted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newBlacklister","type":"address"}],"name":"BlacklisterChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"burner","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newMasterMinter","type":"address"}],"name":"MasterMinterChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"minter","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"minter","type":"address"},{"indexed":false,"internalType":"uint256","name":"minterAllowedAmount","type":"uint256"}],"name":"MinterConfigured","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldMinter","type":"address"}],"name":"MinterRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newBlacklister","type":"address"}],"name":"NewBlacklister","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newMasterMinter","type":"address"}],"name":"NewMasterMinter","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newPauser","type":"address"}],"name":"NewPauser","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":[],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newPauser","type":"address"}],"name":"PauserChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"admin","type":"address"}],"name":"PermissionAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newRescuer","type":"address"}],"name":"RescuerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"decimals","type":"uint8"}],"name":"TokenDecimalsSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_account","type":"address"}],"name":"UnBlacklisted","type":"event"},{"anonymous":false,"inputs":[],"name":"Unpaused","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"blacklist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"blacklisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"minter","type":"address"},{"internalType":"uint256","name":"_minterAllowedAmount","type":"uint256"}],"name":"configureMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"currency","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"decrement","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getBlacklister","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"minter","type":"address"}],"name":"getMinterAllowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPauser","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPermissionAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"increment","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initializePausable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"tokenName","type":"string"},{"internalType":"string","name":"tokenSymbol","type":"string"},{"internalType":"string","name":"tokenCurrency","type":"string"},{"internalType":"uint8","name":"tokenDecimals","type":"uint8"},{"internalType":"address","name":"newMasterMinter","type":"address"},{"internalType":"address","name":"newPauser","type":"address"},{"internalType":"address","name":"newBlacklister","type":"address"},{"internalType":"address","name":"newRescuer","type":"address"}],"name":"initializeToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"isBlacklisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"masterMinter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minterAllowance","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":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"minter","type":"address"}],"name":"removeMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"tokenContract","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"rescueERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rescuer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newAdmin","type":"address"}],"name":"setPermissionAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","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":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"unBlacklist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newBlacklister","type":"address"}],"name":"updateBlacklister","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newMasterMinter","type":"address"}],"name":"updateMasterMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newPauser","type":"address"}],"name":"updatePauser","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRescuer","type":"address"}],"name":"updateRescuer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"wipeBlacklistedAddress","outputs":[],"stateMutability":"nonpayable","type":"function"}],"is_changed_bytecode":false,"is_partially_verified":false,"constructor_args":null}