{"abi":[{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"AuthorizationCanceled","type":"event","inputs":[{"name":"authorizer","type":"address","indexed":true,"internalType":"address"},{"name":"nonce","type":"bytes32","indexed":true,"internalType":"bytes32"}],"anonymous":false},{"name":"AuthorizationUsed","type":"event","inputs":[{"name":"authorizer","type":"address","indexed":true,"internalType":"address"},{"name":"nonce","type":"bytes32","indexed":true,"internalType":"bytes32"}],"anonymous":false},{"name":"Blacklisted","type":"event","inputs":[{"name":"_account","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"BlacklisterChanged","type":"event","inputs":[{"name":"newBlacklister","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Burn","type":"event","inputs":[{"name":"burner","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"DepositEth","type":"event","inputs":[{"name":"user","type":"address","indexed":true,"internalType":"address"},{"name":"ethAmount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"wBETHAmount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"referral","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"EthReceiverUpdated","type":"event","inputs":[{"name":"previousReceiver","type":"address","indexed":true,"internalType":"address"},{"name":"newReceiver","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"ExchangeRateUpdated","type":"event","inputs":[{"name":"oracle","type":"address","indexed":true,"internalType":"address"},{"name":"newExchangeRate","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MasterMinterChanged","type":"event","inputs":[{"name":"newMasterMinter","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Mint","type":"event","inputs":[{"name":"minter","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MinterConfigured","type":"event","inputs":[{"name":"minter","type":"address","indexed":true,"internalType":"address"},{"name":"minterAllowedAmount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MinterRemoved","type":"event","inputs":[{"name":"oldMinter","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"MovedToStakingAddress","type":"event","inputs":[{"name":"ethReceiver","type":"address","indexed":true,"internalType":"address"},{"name":"ethAmount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MovedToUnwrapAddress","type":"event","inputs":[{"name":"unwrapAddress","type":"address","indexed":true,"internalType":"address"},{"name":"ethAmount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"OperatorUpdated","type":"event","inputs":[{"name":"previousOperator","type":"address","indexed":true,"internalType":"address"},{"name":"newOperator","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OracleUpdated","type":"event","inputs":[{"name":"newOracle","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":false,"internalType":"address"},{"name":"newOwner","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"Pause","type":"event","inputs":[],"anonymous":false},{"name":"PauserChanged","type":"event","inputs":[{"name":"newAddress","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RequestWithdrawEth","type":"event","inputs":[{"name":"user","type":"address","indexed":true,"internalType":"address"},{"name":"wbethAmount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"ethAmount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"RescuerChanged","type":"event","inputs":[{"name":"newRescuer","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"SuppliedEth","type":"event","inputs":[{"name":"supplier","type":"address","indexed":true,"internalType":"address"},{"name":"ethAmount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"UnBlacklisted","type":"event","inputs":[{"name":"_account","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Unpause","type":"event","inputs":[],"anonymous":false},{"name":"CANCEL_AUTHORIZATION_TYPEHASH","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"DOMAIN_SEPARATOR","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"PERMIT_TYPEHASH","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"RECEIVE_WITH_AUTHORIZATION_TYPEHASH","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"TRANSFER_WITH_AUTHORIZATION_TYPEHASH","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"_ETH_ADDRESS","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"_EXCHANGE_RATE_UNIT","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"_UNWRAP_ETH_ADDRESS","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"approve","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"authorizationState","type":"function","inputs":[{"name":"authorizer","type":"address","internalType":"address"},{"name":"nonce","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"blacklist","type":"function","inputs":[{"name":"_account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"blacklister","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"burn","type":"function","inputs":[{"name":"_amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"cancelAuthorization","type":"function","inputs":[{"name":"authorizer","type":"address","internalType":"address"},{"name":"nonce","type":"bytes32","internalType":"bytes32"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"configureMinter","type":"function","inputs":[{"name":"minter","type":"address","internalType":"address"},{"name":"minterAllowedAmount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"currency","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"decreaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"decrement","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"deposit","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"referral","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"ethReceiver","type":"function","inputs":[],"outputs":[{"name":"_ethReceiver","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"exchangeRate","type":"function","inputs":[],"outputs":[{"name":"_exchangeRate","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"increaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"increment","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"initialize","type":"function","inputs":[{"name":"tokenName","type":"string","internalType":"string"},{"name":"tokenSymbol","type":"string","internalType":"string"},{"name":"tokenCurrency","type":"string","internalType":"string"},{"name":"tokenDecimals","type":"uint8","internalType":"uint8"},{"name":"newMasterMinter","type":"address","internalType":"address"},{"name":"newPauser","type":"address","internalType":"address"},{"name":"newBlacklister","type":"address","internalType":"address"},{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"initializeV2","type":"function","inputs":[{"name":"newName","type":"string","internalType":"string"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"initializeV2_1","type":"function","inputs":[{"name":"lostAndFound","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"isBlacklisted","type":"function","inputs":[{"name":"_account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isMinter","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"masterMinter","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"mint","type":"function","inputs":[{"name":"_to","type":"address","internalType":"address"},{"name":"_amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"mint","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"minterAllowance","type":"function","inputs":[{"name":"minter","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"moveToStakingAddress","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"moveToUnwrapAddress","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"nonces","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"operator","type":"function","inputs":[],"outputs":[{"name":"_operator","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"oracle","type":"function","inputs":[],"outputs":[{"name":"_oracle","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"pause","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"paused","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"pauser","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"permit","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"receiveWithAuthorization","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"validAfter","type":"uint256","internalType":"uint256"},{"name":"validBefore","type":"uint256","internalType":"uint256"},{"name":"nonce","type":"bytes32","internalType":"bytes32"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"removeMinter","type":"function","inputs":[{"name":"minter","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"requestWithdrawEth","type":"function","inputs":[{"name":"wbethAmount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"rescueERC20","type":"function","inputs":[{"name":"tokenContract","type":"address","internalType":"contract IERC20"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"rescuer","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"supplyEth","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferWithAuthorization","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"validAfter","type":"uint256","internalType":"uint256"},{"name":"validBefore","type":"uint256","internalType":"uint256"},{"name":"nonce","type":"bytes32","internalType":"bytes32"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"unBlacklist","type":"function","inputs":[{"name":"_account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"unpause","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateBlacklister","type":"function","inputs":[{"name":"_newBlacklister","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateEthReceiver","type":"function","inputs":[{"name":"newEthReceiver","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateExchangeRate","type":"function","inputs":[{"name":"newExchangeRate","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateMasterMinter","type":"function","inputs":[{"name":"_newMasterMinter","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateOperator","type":"function","inputs":[{"name":"newOperator","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateOracle","type":"function","inputs":[{"name":"newOracle","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updatePauser","type":"function","inputs":[{"name":"_newPauser","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateRescuer","type":"function","inputs":[{"name":"newRescuer","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"version","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"type":"receive","stateMutability":"payable"}],"sources":{"@openzeppelin/contracts/math/SafeMath.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.6.0;\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations with added overflow\n * checks.\n *\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\n * in bugs, because programmers usually assume that an overflow raises an\n * error, which is the standard behavior in high level programming languages.\n * `SafeMath` restores this intuition by reverting the transaction when an\n * operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeMath {\n    /**\n     * @dev Returns the addition of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `+` operator.\n     *\n     * Requirements:\n     *\n     * - Addition cannot overflow.\n     */\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 c = a + b;\n        require(c >= a, \"SafeMath: addition overflow\");\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        return sub(a, b, \"SafeMath: subtraction overflow\");\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b <= a, errorMessage);\n        uint256 c = a - b;\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `*` operator.\n     *\n     * Requirements:\n     *\n     * - Multiplication cannot overflow.\n     */\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n        // benefit is lost if 'b' is also tested.\n        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n        if (a == 0) {\n            return 0;\n        }\n\n        uint256 c = a * b;\n        require(c / a == b, \"SafeMath: multiplication overflow\");\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers. Reverts on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\n        return div(a, b, \"SafeMath: division by zero\");\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b > 0, errorMessage);\n        uint256 c = a / b;\n        // assert(a == b * c + a % b); // There is no case in which this doesn't hold\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * Reverts when dividing by zero.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n        return mod(a, b, \"SafeMath: modulo by zero\");\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * Reverts with custom message when dividing by zero.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b != 0, errorMessage);\n        return a % b;\n    }\n}\n"},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.6.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\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 `recipient`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address recipient, 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 `sender` to `recipient` 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 sender, address recipient, uint256 amount) external returns (bool);\n\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"},"@openzeppelin/contracts/token/ERC20/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.6.0;\n\nimport \"./IERC20.sol\";\nimport \"../../math/SafeMath.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 SafeMath for uint256;\n    using Address for address;\n\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n    }\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        // solhint-disable-next-line max-line-length\n        require((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    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 newAllowance = token.allowance(address(this), spender).add(value);\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n    }\n\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 newAllowance = token.allowance(address(this), spender).sub(value, \"SafeERC20: decreased allowance below zero\");\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\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        if (returndata.length > 0) { // Return data is optional\n            // solhint-disable-next-line max-line-length\n            require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/Address.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.6.2;\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     */\n    function isContract(address account) internal view returns (bool) {\n        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts\n        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned\n        // for accounts without code, i.e. `keccak256('')`\n        bytes32 codehash;\n        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;\n        // solhint-disable-next-line no-inline-assembly\n        assembly { codehash := extcodehash(account) }\n        return (codehash != accountHash && codehash != 0x0);\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://diligence.consensys.net/posts/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.5.11/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        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\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 functionCall(target, data, \"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(address target, bytes memory data, string memory errorMessage) 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(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        return _functionCallWithValue(target, data, value, errorMessage);\n    }\n\n    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {\n        require(isContract(target), \"Address: call to non-contract\");\n\n        // solhint-disable-next-line avoid-low-level-calls\n        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);\n        if (success) {\n            return returndata;\n        } else {\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\n                // solhint-disable-next-line no-inline-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}\n"},"centre-tokens/contracts/util/ECRecover.sol":{"content":"/**\n * SPDX-License-Identifier: MIT\n *\n * Copyright (c) 2016-2019 zOS Global Limited\n * Copyright (c) 2018-2020 CENTRE SECZ\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\npragma solidity 0.6.12;\n\n/**\n * @title ECRecover\n * @notice A library that provides a safe ECDSA recovery function\n */\nlibrary ECRecover {\n    /**\n     * @notice Recover signer's address from a signed message\n     * @dev Adapted from: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/65e4ffde586ec89af3b7e9140bdc9235d1254853/contracts/cryptography/ECDSA.sol\n     * Modifications: Accept v, r, and s as separate arguments\n     * @param digest    Keccak-256 hash digest of the signed message\n     * @param v         v of the signature\n     * @param r         r of the signature\n     * @param s         s of the signature\n     * @return Signer address\n     */\n    function recover(\n        bytes32 digest,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        if (\n            uint256(s) >\n            0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0\n        ) {\n            revert(\"ECRecover: invalid signature 's' value\");\n        }\n\n        if (v != 27 && v != 28) {\n            revert(\"ECRecover: invalid signature 'v' value\");\n        }\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(digest, v, r, s);\n        require(signer != address(0), \"ECRecover: invalid signature\");\n\n        return signer;\n    }\n}\n"},"centre-tokens/contracts/util/EIP712.sol":{"content":"/**\n * SPDX-License-Identifier: MIT\n *\n * Copyright (c) 2018-2020 CENTRE SECZ\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\npragma solidity 0.6.12;\n\nimport { ECRecover } from \"./ECRecover.sol\";\n\n/**\n * @title EIP712\n * @notice A library that provides EIP712 helper functions\n */\nlibrary EIP712 {\n    /**\n     * @notice Make EIP712 domain separator\n     * @param name      Contract name\n     * @param version   Contract version\n     * @return Domain separator\n     */\n    function makeDomainSeparator(string memory name, string memory version)\n        internal\n        view\n        returns (bytes32)\n    {\n        uint256 chainId;\n        assembly {\n            chainId := chainid()\n        }\n        return\n            keccak256(\n                abi.encode(\n                    // keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\")\n                    0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f,\n                    keccak256(bytes(name)),\n                    keccak256(bytes(version)),\n                    chainId,\n                    address(this)\n                )\n            );\n    }\n\n    /**\n     * @notice Recover signer's address from a EIP712 signature\n     * @param domainSeparator   Domain separator\n     * @param v                 v of the signature\n     * @param r                 r of the signature\n     * @param s                 s of the signature\n     * @param typeHashAndData   Type hash concatenated with data\n     * @return Signer's address\n     */\n    function recover(\n        bytes32 domainSeparator,\n        uint8 v,\n        bytes32 r,\n        bytes32 s,\n        bytes memory typeHashAndData\n    ) internal pure returns (address) {\n        bytes32 digest = keccak256(\n            abi.encodePacked(\n                \"\\x19\\x01\",\n                domainSeparator,\n                keccak256(typeHashAndData)\n            )\n        );\n        return ECRecover.recover(digest, v, r, s);\n    }\n}\n"},"centre-tokens/contracts/v1.1/FiatTokenV1_1.sol":{"content":"/**\n * SPDX-License-Identifier: MIT\n *\n * Copyright (c) 2018-2020 CENTRE SECZ\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\npragma solidity 0.6.12;\n\nimport { FiatTokenV1 } from \"../v1/FiatTokenV1.sol\";\nimport { Rescuable } from \"./Rescuable.sol\";\n\n/**\n * @title FiatTokenV1_1\n * @dev ERC20 Token backed by fiat reserves\n */\ncontract FiatTokenV1_1 is FiatTokenV1, Rescuable {\n\n}\n"},"centre-tokens/contracts/v1.1/Rescuable.sol":{"content":"/**\n * SPDX-License-Identifier: MIT\n *\n * Copyright (c) 2018-2020 CENTRE SECZ\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\npragma solidity 0.6.12;\n\nimport { Ownable } from \"../v1/Ownable.sol\";\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { SafeERC20 } from \"@openzeppelin/contracts/token/ERC20/SafeERC20.sol\";\n\ncontract Rescuable is Ownable {\n    using SafeERC20 for IERC20;\n\n    address private _rescuer;\n\n    event RescuerChanged(address indexed newRescuer);\n\n    /**\n     * @notice Returns current rescuer\n     * @return Rescuer's address\n     */\n    function rescuer() external view returns (address) {\n        return _rescuer;\n    }\n\n    /**\n     * @notice Revert if called by any account other than the rescuer.\n     */\n    modifier onlyRescuer() {\n        require(msg.sender == _rescuer, \"Rescuable: caller is not the rescuer\");\n        _;\n    }\n\n    /**\n     * @notice Rescue ERC20 tokens locked up in this contract.\n     * @param tokenContract ERC20 token contract address\n     * @param to        Recipient address\n     * @param amount    Amount to withdraw\n     */\n    function rescueERC20(\n        IERC20 tokenContract,\n        address to,\n        uint256 amount\n    ) external onlyRescuer {\n        require(address(tokenContract) != address(0x2170Ed0880ac9A755fd29B2688956BD959F933F8), \"Rescuable: ETH not allowed\");\n        tokenContract.safeTransfer(to, amount);\n    }\n\n    /**\n     * @notice Assign the rescuer role to a given address.\n     * @param newRescuer New rescuer's address\n     */\n    function updateRescuer(address newRescuer) external onlyOwner {\n        require(\n            newRescuer != address(0),\n            \"Rescuable: new rescuer is the zero address\"\n        );\n        _rescuer = newRescuer;\n        emit RescuerChanged(newRescuer);\n    }\n}\n"},"centre-tokens/contracts/v1/AbstractFiatTokenV1.sol":{"content":"/**\n * SPDX-License-Identifier: MIT\n *\n * Copyright (c) 2018-2020 CENTRE SECZ\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\npragma solidity 0.6.12;\n\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\nabstract contract AbstractFiatTokenV1 is IERC20 {\n    function _approve(\n        address owner,\n        address spender,\n        uint256 value\n    ) internal virtual;\n\n    function _transfer(\n        address from,\n        address to,\n        uint256 value\n    ) internal virtual;\n}\n"},"centre-tokens/contracts/v1/Blacklistable.sol":{"content":"/**\n * SPDX-License-Identifier: MIT\n *\n * Copyright (c) 2018-2020 CENTRE SECZ\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\npragma solidity 0.6.12;\n\nimport { Ownable } from \"./Ownable.sol\";\n\n/**\n * @title Blacklistable Token\n * @dev Allows accounts to be blacklisted by a \"blacklister\" role\n */\ncontract Blacklistable is Ownable {\n    address public blacklister;\n    mapping(address => bool) internal blacklisted;\n\n    event Blacklisted(address indexed _account);\n    event UnBlacklisted(address indexed _account);\n    event BlacklisterChanged(address indexed newBlacklister);\n\n    /**\n     * @dev Throws if called by any account other than the blacklister\n     */\n    modifier onlyBlacklister() {\n        require(\n            msg.sender == blacklister,\n            \"Blacklistable: caller is not the blacklister\"\n        );\n        _;\n    }\n\n    /**\n     * @dev Throws if argument account is blacklisted\n     * @param _account The address to check\n     */\n    modifier notBlacklisted(address _account) {\n        require(\n            !blacklisted[_account],\n            \"Blacklistable: account is blacklisted\"\n        );\n        _;\n    }\n\n    /**\n     * @dev Checks if account is blacklisted\n     * @param _account The address to check\n     */\n    function isBlacklisted(address _account) external view returns (bool) {\n        return blacklisted[_account];\n    }\n\n    /**\n     * @dev Adds account to blacklist\n     * @param _account The address to blacklist\n     */\n    function blacklist(address _account) external onlyBlacklister {\n        blacklisted[_account] = true;\n        emit Blacklisted(_account);\n    }\n\n    /**\n     * @dev Removes account from blacklist\n     * @param _account The address to remove from the blacklist\n     */\n    function unBlacklist(address _account) external onlyBlacklister {\n        blacklisted[_account] = false;\n        emit UnBlacklisted(_account);\n    }\n\n    function updateBlacklister(address _newBlacklister) external onlyOwner {\n        require(\n            _newBlacklister != address(0),\n            \"Blacklistable: new blacklister is the zero address\"\n        );\n        blacklister = _newBlacklister;\n        emit BlacklisterChanged(blacklister);\n    }\n}\n"},"centre-tokens/contracts/v1/FiatTokenV1.sol":{"content":"/**\n * SPDX-License-Identifier: MIT\n *\n * Copyright (c) 2018-2020 CENTRE SECZ\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\npragma solidity 0.6.12;\n\nimport { SafeMath } from \"@openzeppelin/contracts/math/SafeMath.sol\";\nimport { AbstractFiatTokenV1 } from \"./AbstractFiatTokenV1.sol\";\nimport { Ownable } from \"./Ownable.sol\";\nimport { Pausable } from \"./Pausable.sol\";\nimport { Blacklistable } from \"./Blacklistable.sol\";\n\n/**\n * @title FiatToken\n * @dev ERC20 Token backed by fiat reserves\n */\ncontract FiatTokenV1 is AbstractFiatTokenV1, Ownable, Pausable, Blacklistable {\n    using SafeMath for uint256;\n\n    string public name;\n    string public symbol;\n    uint8 public decimals;\n    string public currency;\n    address public masterMinter;\n    bool internal initialized;\n\n    mapping(address => uint256) internal balances;\n    mapping(address => mapping(address => uint256)) internal allowed;\n    uint256 internal totalSupply_ = 0;\n    mapping(address => bool) internal minters;\n    mapping(address => uint256) internal minterAllowed;\n\n    event Mint(address indexed minter, address indexed to, uint256 amount);\n    event Burn(address indexed burner, uint256 amount);\n    event MinterConfigured(address indexed minter, uint256 minterAllowedAmount);\n    event MinterRemoved(address indexed oldMinter);\n    event MasterMinterChanged(address indexed newMasterMinter);\n\n    function initialize(\n        string memory tokenName,\n        string memory tokenSymbol,\n        string memory tokenCurrency,\n        uint8 tokenDecimals,\n        address newMasterMinter,\n        address newPauser,\n        address newBlacklister,\n        address newOwner\n    ) public {\n        require(!initialized, \"FiatToken: contract is already initialized\");\n        require(\n            newMasterMinter != address(0),\n            \"FiatToken: new masterMinter is the zero address\"\n        );\n        require(\n            newPauser != address(0),\n            \"FiatToken: new pauser is the zero address\"\n        );\n        require(\n            newBlacklister != address(0),\n            \"FiatToken: new blacklister is the zero address\"\n        );\n        require(\n            newOwner != address(0),\n            \"FiatToken: new owner is the zero address\"\n        );\n\n        name = tokenName;\n        symbol = tokenSymbol;\n        currency = tokenCurrency;\n        decimals = tokenDecimals;\n        masterMinter = newMasterMinter;\n        pauser = newPauser;\n        blacklister = newBlacklister;\n        setOwner(newOwner);\n        initialized = true;\n    }\n\n    /**\n     * @dev Throws if called by any account other than a minter\n     */\n    modifier onlyMinters() {\n        require(minters[msg.sender], \"FiatToken: caller is not a minter\");\n        _;\n    }\n\n    /**\n     * @dev Function to mint tokens\n     * @param _to The address that will receive the minted tokens.\n     * @param _amount The amount of tokens to mint. Must be less than or equal\n     * to the minterAllowance of the caller.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function mint(address _to, uint256 _amount)\n        external\n        whenNotPaused\n        onlyMinters\n        notBlacklisted(msg.sender)\n        notBlacklisted(_to)\n        returns (bool)\n    {\n        require(_to != address(0), \"FiatToken: mint to the zero address\");\n        require(_amount > 0, \"FiatToken: mint amount not greater than 0\");\n\n        uint256 mintingAllowedAmount = minterAllowed[msg.sender];\n        require(\n            _amount <= mintingAllowedAmount,\n            \"FiatToken: mint amount exceeds minterAllowance\"\n        );\n\n        totalSupply_ = totalSupply_.add(_amount);\n        balances[_to] = balances[_to].add(_amount);\n        minterAllowed[msg.sender] = mintingAllowedAmount.sub(_amount);\n        emit Mint(msg.sender, _to, _amount);\n        emit Transfer(address(0), _to, _amount);\n        return true;\n    }\n\n    /**\n     * @dev Throws if called by any account other than the masterMinter\n     */\n    modifier onlyMasterMinter() {\n        require(\n            msg.sender == masterMinter,\n            \"FiatToken: caller is not the masterMinter\"\n        );\n        _;\n    }\n\n    /**\n     * @dev Get minter allowance for an account\n     * @param minter The address of the minter\n     */\n    function minterAllowance(address minter) external view returns (uint256) {\n        return minterAllowed[minter];\n    }\n\n    /**\n     * @dev Checks if account is a minter\n     * @param account The address to check\n     */\n    function isMinter(address account) external view returns (bool) {\n        return minters[account];\n    }\n\n    /**\n     * @notice Amount of remaining tokens spender is allowed to transfer on\n     * behalf of the token owner\n     * @param owner     Token owner's address\n     * @param spender   Spender's address\n     * @return Allowance amount\n     */\n    function allowance(address owner, address spender)\n        external\n        override\n        view\n        returns (uint256)\n    {\n        return allowed[owner][spender];\n    }\n\n    /**\n     * @dev Get totalSupply of token\n     */\n    function totalSupply() external override view returns (uint256) {\n        return totalSupply_;\n    }\n\n    /**\n     * @dev Get token balance of an account\n     * @param account address The account\n     */\n    function balanceOf(address account)\n        external\n        override\n        view\n        returns (uint256)\n    {\n        return balances[account];\n    }\n\n    /**\n     * @notice Set spender's allowance over the caller's tokens to be a given\n     * value.\n     * @param spender   Spender's address\n     * @param value     Allowance amount\n     * @return True if successful\n     */\n    function approve(address spender, uint256 value)\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     * @dev 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(\n        address owner,\n        address spender,\n        uint256 value\n    ) internal override {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n        allowed[owner][spender] = value;\n        emit Approval(owner, spender, value);\n    }\n\n    /**\n     * @notice Transfer tokens by spending allowance\n     * @param from  Payer's address\n     * @param to    Payee's address\n     * @param value Transfer amount\n     * @return True if 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        require(\n            value <= allowed[from][msg.sender],\n            \"ERC20: transfer amount exceeds allowance\"\n        );\n        _transfer(from, to, value);\n        allowed[from][msg.sender] = allowed[from][msg.sender].sub(value);\n        return true;\n    }\n\n    /**\n     * @notice Transfer tokens from the caller\n     * @param to    Payee's address\n     * @param value Transfer amount\n     * @return True if successful\n     */\n    function transfer(address to, uint256 value)\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 transfers\n     * @param from  Payer's address\n     * @param to    Payee's address\n     * @param value Transfer amount\n     */\n    function _transfer(\n        address from,\n        address to,\n        uint256 value\n    ) internal override {\n        require(from != address(0), \"ERC20: transfer from the zero address\");\n        require(to != address(0), \"ERC20: transfer to the zero address\");\n        require(\n            value <= balances[from],\n            \"ERC20: transfer amount exceeds balance\"\n        );\n\n        balances[from] = balances[from].sub(value);\n        balances[to] = balances[to].add(value);\n        emit Transfer(from, to, value);\n    }\n\n    /**\n     * @dev Function to add/update a new minter\n     * @param minter The address of the minter\n     * @param minterAllowedAmount The minting amount allowed for the minter\n     * @return True if the operation was successful.\n     */\n    function configureMinter(address minter, uint256 minterAllowedAmount)\n        external\n        whenNotPaused\n        onlyMasterMinter\n        returns (bool)\n    {\n        minters[minter] = true;\n        minterAllowed[minter] = minterAllowedAmount;\n        emit MinterConfigured(minter, minterAllowedAmount);\n        return true;\n    }\n\n    /**\n     * @dev Function to remove 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)\n        external\n        onlyMasterMinter\n        returns (bool)\n    {\n        minters[minter] = false;\n        minterAllowed[minter] = 0;\n        emit MinterRemoved(minter);\n        return true;\n    }\n\n    /**\n     * @dev allows a minter to burn some of its own tokens\n     * Validates that caller is a minter and that sender is not blacklisted\n     * amount is less than or equal to the minter's account balance\n     * @param _amount uint256 the amount of tokens to be burned\n     */\n    function burn(uint256 _amount)\n        external\n        whenNotPaused\n        onlyMinters\n        notBlacklisted(msg.sender)\n    {\n        uint256 balance = balances[msg.sender];\n        require(_amount > 0, \"FiatToken: burn amount not greater than 0\");\n        require(balance >= _amount, \"FiatToken: burn amount exceeds balance\");\n\n        totalSupply_ = totalSupply_.sub(_amount);\n        balances[msg.sender] = balance.sub(_amount);\n        emit Burn(msg.sender, _amount);\n        emit Transfer(msg.sender, address(0), _amount);\n    }\n\n    function updateMasterMinter(address _newMasterMinter) external onlyOwner {\n        require(\n            _newMasterMinter != address(0),\n            \"FiatToken: new masterMinter is the zero address\"\n        );\n        masterMinter = _newMasterMinter;\n        emit MasterMinterChanged(masterMinter);\n    }\n}\n"},"centre-tokens/contracts/v1/Ownable.sol":{"content":"/**\n * SPDX-License-Identifier: MIT\n *\n * Copyright (c) 2018 zOS Global Limited.\n * Copyright (c) 2018-2020 CENTRE SECZ\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\npragma solidity 0.6.12;\n\n/**\n * @notice The Ownable contract has an owner address, and provides basic\n * authorization control functions\n * @dev Forked from https://github.com/OpenZeppelin/openzeppelin-labs/blob/3887ab77b8adafba4a26ace002f3a684c1a3388b/upgradeability_ownership/contracts/ownership/Ownable.sol\n * Modifications:\n * 1. Consolidate OwnableStorage into this contract (7/13/18)\n * 2. Reformat, conform to Solidity 0.6 syntax, and add error messages (5/13/20)\n * 3. Make public functions external (5/27/20)\n */\ncontract Ownable {\n    // Owner of the contract\n    address private _owner;\n\n    /**\n     * @dev Event to show ownership has been transferred\n     * @param previousOwner representing the address of the previous owner\n     * @param newOwner representing the address of the new owner\n     */\n    event OwnershipTransferred(address previousOwner, address newOwner);\n\n    /**\n     * @dev The constructor sets the original owner of the contract to the sender account.\n     */\n    constructor() public {\n        setOwner(msg.sender);\n    }\n\n    /**\n     * @dev Tells the address of the owner\n     * @return the address of the owner\n     */\n    function owner() external view returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Sets a new owner address\n     */\n    function setOwner(address newOwner) internal {\n        _owner = newOwner;\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        require(msg.sender == _owner, \"Ownable: caller is not the owner\");\n        _;\n    }\n\n    /**\n     * @dev Allows the current owner to transfer control of the contract to a newOwner.\n     * @param newOwner The address to transfer ownership to.\n     */\n    function transferOwnership(address newOwner) external onlyOwner {\n        require(\n            newOwner != address(0),\n            \"Ownable: new owner is the zero address\"\n        );\n        emit OwnershipTransferred(_owner, newOwner);\n        setOwner(newOwner);\n    }\n}\n"},"centre-tokens/contracts/v1/Pausable.sol":{"content":"/**\n * SPDX-License-Identifier: MIT\n *\n * Copyright (c) 2016 Smart Contract Solutions, Inc.\n * Copyright (c) 2018-2020 CENTRE SECZ0\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\npragma solidity 0.6.12;\n\nimport { Ownable } from \"./Ownable.sol\";\n\n/**\n * @notice Base contract which allows children to implement an emergency stop\n * mechanism\n * @dev Forked from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/feb665136c0dae9912e08397c1a21c4af3651ef3/contracts/lifecycle/Pausable.sol\n * Modifications:\n * 1. Added pauser role, switched pause/unpause to be onlyPauser (6/14/2018)\n * 2. Removed whenNotPause/whenPaused from pause/unpause (6/14/2018)\n * 3. Removed whenPaused (6/14/2018)\n * 4. Switches ownable library to use ZeppelinOS (7/12/18)\n * 5. Remove constructor (7/13/18)\n * 6. Reformat, conform to Solidity 0.6 syntax and add error messages (5/13/20)\n * 7. Make public functions external (5/27/20)\n */\ncontract Pausable is Ownable {\n    event Pause();\n    event Unpause();\n    event PauserChanged(address indexed newAddress);\n\n    address public pauser;\n    bool public paused = false;\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is not paused.\n     */\n    modifier whenNotPaused() {\n        require(!paused, \"Pausable: paused\");\n        _;\n    }\n\n    /**\n     * @dev throws if called by any account other than the pauser\n     */\n    modifier onlyPauser() {\n        require(msg.sender == pauser, \"Pausable: caller is not the pauser\");\n        _;\n    }\n\n    /**\n     * @dev called by the owner to pause, triggers stopped state\n     */\n    function pause() external onlyPauser {\n        paused = true;\n        emit Pause();\n    }\n\n    /**\n     * @dev called by the owner to unpause, returns to normal state\n     */\n    function unpause() external onlyPauser {\n        paused = false;\n        emit Unpause();\n    }\n\n    /**\n     * @dev update the pauser role\n     */\n    function updatePauser(address _newPauser) external onlyOwner {\n        require(\n            _newPauser != address(0),\n            \"Pausable: new pauser is the zero address\"\n        );\n        pauser = _newPauser;\n        emit PauserChanged(pauser);\n    }\n}\n"},"centre-tokens/contracts/v2/AbstractFiatTokenV2.sol":{"content":"/**\n * SPDX-License-Identifier: MIT\n *\n * Copyright (c) 2018-2020 CENTRE SECZ\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\npragma solidity 0.6.12;\n\nimport { AbstractFiatTokenV1 } from \"../v1/AbstractFiatTokenV1.sol\";\n\nabstract contract AbstractFiatTokenV2 is AbstractFiatTokenV1 {\n    function _increaseAllowance(\n        address owner,\n        address spender,\n        uint256 increment\n    ) internal virtual;\n\n    function _decreaseAllowance(\n        address owner,\n        address spender,\n        uint256 decrement\n    ) internal virtual;\n}\n"},"centre-tokens/contracts/v2/EIP2612.sol":{"content":"/**\n * SPDX-License-Identifier: MIT\n *\n * Copyright (c) 2018-2020 CENTRE SECZ\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\npragma solidity 0.6.12;\n\nimport { AbstractFiatTokenV2 } from \"./AbstractFiatTokenV2.sol\";\nimport { EIP712Domain } from \"./EIP712Domain.sol\";\nimport { EIP712 } from \"../util/EIP712.sol\";\n\n/**\n * @title EIP-2612\n * @notice Provide internal implementation for gas-abstracted approvals\n */\nabstract contract EIP2612 is AbstractFiatTokenV2, EIP712Domain {\n    // keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\")\n    bytes32\n        public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;\n\n    mapping(address => uint256) private _permitNonces;\n\n    /**\n     * @notice Nonces for permit\n     * @param owner Token owner's address (Authorizer)\n     * @return Next nonce\n     */\n    function nonces(address owner) external view returns (uint256) {\n        return _permitNonces[owner];\n    }\n\n    /**\n     * @notice Verify a signed approval permit and execute if valid\n     * @param owner     Token owner's address (Authorizer)\n     * @param spender   Spender's address\n     * @param value     Amount of allowance\n     * @param deadline  The time at which this expires (unix time)\n     * @param v         v of the signature\n     * @param r         r of the signature\n     * @param s         s of the signature\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    ) internal {\n        require(deadline >= now, \"FiatTokenV2: permit is expired\");\n\n        bytes memory data = abi.encode(\n            PERMIT_TYPEHASH,\n            owner,\n            spender,\n            value,\n            _permitNonces[owner]++,\n            deadline\n        );\n        require(\n            EIP712.recover(DOMAIN_SEPARATOR, v, r, s, data) == owner,\n            \"EIP2612: invalid signature\"\n        );\n\n        _approve(owner, spender, value);\n    }\n}\n"},"centre-tokens/contracts/v2/EIP3009.sol":{"content":"/**\n * SPDX-License-Identifier: MIT\n *\n * Copyright (c) 2018-2020 CENTRE SECZ\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\npragma solidity 0.6.12;\n\nimport { AbstractFiatTokenV2 } from \"./AbstractFiatTokenV2.sol\";\nimport { EIP712Domain } from \"./EIP712Domain.sol\";\nimport { EIP712 } from \"../util/EIP712.sol\";\n\n/**\n * @title EIP-3009\n * @notice Provide internal implementation for gas-abstracted transfers\n * @dev Contracts that inherit from this must wrap these with publicly\n * accessible functions, optionally adding modifiers where necessary\n */\nabstract contract EIP3009 is AbstractFiatTokenV2, EIP712Domain {\n    // keccak256(\"TransferWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)\")\n    bytes32\n        public constant TRANSFER_WITH_AUTHORIZATION_TYPEHASH = 0x7c7c6cdb67a18743f49ec6fa9b35f50d52ed05cbed4cc592e13b44501c1a2267;\n\n    // keccak256(\"ReceiveWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)\")\n    bytes32\n        public constant RECEIVE_WITH_AUTHORIZATION_TYPEHASH = 0xd099cc98ef71107a616c4f0f941f04c322d8e254fe26b3c6668db87aae413de8;\n\n    // keccak256(\"CancelAuthorization(address authorizer,bytes32 nonce)\")\n    bytes32\n        public constant CANCEL_AUTHORIZATION_TYPEHASH = 0x158b0a9edf7a828aad02f63cd515c68ef2f50ba807396f6d12842833a1597429;\n\n    /**\n     * @dev authorizer address => nonce => bool (true if nonce is used)\n     */\n    mapping(address => mapping(bytes32 => bool)) private _authorizationStates;\n\n    event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce);\n    event AuthorizationCanceled(\n        address indexed authorizer,\n        bytes32 indexed nonce\n    );\n\n    /**\n     * @notice Returns the state of an authorization\n     * @dev Nonces are randomly generated 32-byte data unique to the\n     * authorizer's address\n     * @param authorizer    Authorizer's address\n     * @param nonce         Nonce of the authorization\n     * @return True if the nonce is used\n     */\n    function authorizationState(address authorizer, bytes32 nonce)\n        external\n        view\n        returns (bool)\n    {\n        return _authorizationStates[authorizer][nonce];\n    }\n\n    /**\n     * @notice Execute a transfer with a signed authorization\n     * @param from          Payer's address (Authorizer)\n     * @param to            Payee's address\n     * @param value         Amount to be transferred\n     * @param validAfter    The time after which this is valid (unix time)\n     * @param validBefore   The time before which this is valid (unix time)\n     * @param nonce         Unique nonce\n     * @param v             v of the signature\n     * @param r             r of the signature\n     * @param s             s of the signature\n     */\n    function _transferWithAuthorization(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal {\n        _requireValidAuthorization(from, nonce, validAfter, validBefore);\n\n        bytes memory data = abi.encode(\n            TRANSFER_WITH_AUTHORIZATION_TYPEHASH,\n            from,\n            to,\n            value,\n            validAfter,\n            validBefore,\n            nonce\n        );\n        require(\n            EIP712.recover(DOMAIN_SEPARATOR, v, r, s, data) == from,\n            \"FiatTokenV2: invalid signature\"\n        );\n\n        _markAuthorizationAsUsed(from, nonce);\n        _transfer(from, to, value);\n    }\n\n    /**\n     * @notice Receive a transfer with a signed authorization from the payer\n     * @dev This has an additional check to ensure that the payee's address\n     * matches the caller of this function to prevent front-running attacks.\n     * @param from          Payer's address (Authorizer)\n     * @param to            Payee's address\n     * @param value         Amount to be transferred\n     * @param validAfter    The time after which this is valid (unix time)\n     * @param validBefore   The time before which this is valid (unix time)\n     * @param nonce         Unique nonce\n     * @param v             v of the signature\n     * @param r             r of the signature\n     * @param s             s of the signature\n     */\n    function _receiveWithAuthorization(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal {\n        require(to == msg.sender, \"FiatTokenV2: caller must be the payee\");\n        _requireValidAuthorization(from, nonce, validAfter, validBefore);\n\n        bytes memory data = abi.encode(\n            RECEIVE_WITH_AUTHORIZATION_TYPEHASH,\n            from,\n            to,\n            value,\n            validAfter,\n            validBefore,\n            nonce\n        );\n        require(\n            EIP712.recover(DOMAIN_SEPARATOR, v, r, s, data) == from,\n            \"FiatTokenV2: invalid signature\"\n        );\n\n        _markAuthorizationAsUsed(from, nonce);\n        _transfer(from, to, value);\n    }\n\n    /**\n     * @notice Attempt to cancel an authorization\n     * @param authorizer    Authorizer's address\n     * @param nonce         Nonce of the authorization\n     * @param v             v of the signature\n     * @param r             r of the signature\n     * @param s             s of the signature\n     */\n    function _cancelAuthorization(\n        address authorizer,\n        bytes32 nonce,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal {\n        _requireUnusedAuthorization(authorizer, nonce);\n\n        bytes memory data = abi.encode(\n            CANCEL_AUTHORIZATION_TYPEHASH,\n            authorizer,\n            nonce\n        );\n        require(\n            EIP712.recover(DOMAIN_SEPARATOR, v, r, s, data) == authorizer,\n            \"FiatTokenV2: invalid signature\"\n        );\n\n        _authorizationStates[authorizer][nonce] = true;\n        emit AuthorizationCanceled(authorizer, nonce);\n    }\n\n    /**\n     * @notice Check that an authorization is unused\n     * @param authorizer    Authorizer's address\n     * @param nonce         Nonce of the authorization\n     */\n    function _requireUnusedAuthorization(address authorizer, bytes32 nonce)\n        private\n        view\n    {\n        require(\n            !_authorizationStates[authorizer][nonce],\n            \"FiatTokenV2: authorization is used or canceled\"\n        );\n    }\n\n    /**\n     * @notice Check that authorization is valid\n     * @param authorizer    Authorizer's address\n     * @param nonce         Nonce of the authorization\n     * @param validAfter    The time after which this is valid (unix time)\n     * @param validBefore   The time before which this is valid (unix time)\n     */\n    function _requireValidAuthorization(\n        address authorizer,\n        bytes32 nonce,\n        uint256 validAfter,\n        uint256 validBefore\n    ) private view {\n        require(\n            now > validAfter,\n            \"FiatTokenV2: authorization is not yet valid\"\n        );\n        require(now < validBefore, \"FiatTokenV2: authorization is expired\");\n        _requireUnusedAuthorization(authorizer, nonce);\n    }\n\n    /**\n     * @notice Mark an authorization as used\n     * @param authorizer    Authorizer's address\n     * @param nonce         Nonce of the authorization\n     */\n    function _markAuthorizationAsUsed(address authorizer, bytes32 nonce)\n        private\n    {\n        _authorizationStates[authorizer][nonce] = true;\n        emit AuthorizationUsed(authorizer, nonce);\n    }\n}\n"},"centre-tokens/contracts/v2/EIP712Domain.sol":{"content":"/**\n * SPDX-License-Identifier: MIT\n *\n * Copyright (c) 2018-2020 CENTRE SECZ\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\npragma solidity 0.6.12;\n\n/**\n * @title EIP712 Domain\n */\ncontract EIP712Domain {\n    /**\n     * @dev EIP712 Domain Separator\n     */\n    bytes32 public DOMAIN_SEPARATOR;\n}\n"},"centre-tokens/contracts/v2/FiatTokenV2.sol":{"content":"/**\n * SPDX-License-Identifier: MIT\n *\n * Copyright (c) 2018-2020 CENTRE SECZ\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\npragma solidity 0.6.12;\n\nimport { FiatTokenV1_1 } from \"../v1.1/FiatTokenV1_1.sol\";\nimport { AbstractFiatTokenV2 } from \"./AbstractFiatTokenV2.sol\";\nimport { EIP712 } from \"../util/EIP712.sol\";\nimport { EIP712Domain } from \"./EIP712Domain.sol\";\nimport { EIP3009 } from \"./EIP3009.sol\";\nimport { EIP2612 } from \"./EIP2612.sol\";\n\n/**\n * @title FiatToken V2\n * @notice ERC20 Token backed by fiat reserves, version 2\n */\ncontract FiatTokenV2 is FiatTokenV1_1, EIP3009, EIP2612 {\n    uint8 internal _initializedVersion;\n\n    /**\n     * @notice Initialize v2\n     * @param newName   New token name\n     */\n    function initializeV2(string calldata newName) external {\n        // solhint-disable-next-line reason-string\n        require(initialized && _initializedVersion == 0);\n        name = newName;\n        DOMAIN_SEPARATOR = EIP712.makeDomainSeparator(newName, \"2\");\n        _initializedVersion = 1;\n    }\n\n    /**\n     * @notice Increase the allowance by a given increment\n     * @param spender   Spender's address\n     * @param increment Amount of increase in allowance\n     * @return True if successful\n     */\n    function increaseAllowance(address spender, uint256 increment)\n        external\n        whenNotPaused\n        notBlacklisted(msg.sender)\n        notBlacklisted(spender)\n        returns (bool)\n    {\n        _increaseAllowance(msg.sender, spender, increment);\n        return true;\n    }\n\n    /**\n     * @notice Decrease the allowance by a given decrement\n     * @param spender   Spender's address\n     * @param decrement Amount of decrease in allowance\n     * @return True if successful\n     */\n    function decreaseAllowance(address spender, uint256 decrement)\n        external\n        whenNotPaused\n        notBlacklisted(msg.sender)\n        notBlacklisted(spender)\n        returns (bool)\n    {\n        _decreaseAllowance(msg.sender, spender, decrement);\n        return true;\n    }\n\n    /**\n     * @notice Execute a transfer with a signed authorization\n     * @param from          Payer's address (Authorizer)\n     * @param to            Payee's address\n     * @param value         Amount to be transferred\n     * @param validAfter    The time after which this is valid (unix time)\n     * @param validBefore   The time before which this is valid (unix time)\n     * @param nonce         Unique nonce\n     * @param v             v of the signature\n     * @param r             r of the signature\n     * @param s             s of the signature\n     */\n    function transferWithAuthorization(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external whenNotPaused notBlacklisted(from) notBlacklisted(to) {\n        _transferWithAuthorization(\n            from,\n            to,\n            value,\n            validAfter,\n            validBefore,\n            nonce,\n            v,\n            r,\n            s\n        );\n    }\n\n    /**\n     * @notice Receive a transfer with a signed authorization from the payer\n     * @dev This has an additional check to ensure that the payee's address\n     * matches the caller of this function to prevent front-running attacks.\n     * @param from          Payer's address (Authorizer)\n     * @param to            Payee's address\n     * @param value         Amount to be transferred\n     * @param validAfter    The time after which this is valid (unix time)\n     * @param validBefore   The time before which this is valid (unix time)\n     * @param nonce         Unique nonce\n     * @param v             v of the signature\n     * @param r             r of the signature\n     * @param s             s of the signature\n     */\n    function receiveWithAuthorization(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external whenNotPaused notBlacklisted(from) notBlacklisted(to) {\n        _receiveWithAuthorization(\n            from,\n            to,\n            value,\n            validAfter,\n            validBefore,\n            nonce,\n            v,\n            r,\n            s\n        );\n    }\n\n    /**\n     * @notice Attempt to cancel an authorization\n     * @dev Works only if the authorization is not yet used.\n     * @param authorizer    Authorizer's address\n     * @param nonce         Nonce of the authorization\n     * @param v             v of the signature\n     * @param r             r of the signature\n     * @param s             s of the signature\n     */\n    function cancelAuthorization(\n        address authorizer,\n        bytes32 nonce,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external whenNotPaused {\n        _cancelAuthorization(authorizer, nonce, v, r, s);\n    }\n\n    /**\n     * @notice Update allowance with a signed permit\n     * @param owner       Token owner's address (Authorizer)\n     * @param spender     Spender's address\n     * @param value       Amount of allowance\n     * @param deadline    Expiration time, seconds since the epoch\n     * @param v           v of the signature\n     * @param r           r of the signature\n     * @param s           s of the signature\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 whenNotPaused notBlacklisted(owner) notBlacklisted(spender) {\n        _permit(owner, spender, value, deadline, v, r, s);\n    }\n\n    /**\n     * @notice Internal function to increase the allowance by a given increment\n     * @param owner     Token owner's address\n     * @param spender   Spender's address\n     * @param increment Amount of increase\n     */\n    function _increaseAllowance(\n        address owner,\n        address spender,\n        uint256 increment\n    ) internal override {\n        _approve(owner, spender, allowed[owner][spender].add(increment));\n    }\n\n    /**\n     * @notice Internal function to decrease the allowance by a given decrement\n     * @param owner     Token owner's address\n     * @param spender   Spender's address\n     * @param decrement Amount of decrease\n     */\n    function _decreaseAllowance(\n        address owner,\n        address spender,\n        uint256 decrement\n    ) internal override {\n        _approve(\n            owner,\n            spender,\n            allowed[owner][spender].sub(\n                decrement,\n                \"ERC20: decreased allowance below zero\"\n            )\n        );\n    }\n}\n"},"centre-tokens/contracts/v2/FiatTokenV2_1.sol":{"content":"/**\n * SPDX-License-Identifier: MIT\n *\n * Copyright (c) 2018-2020 CENTRE SECZ\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\npragma solidity 0.6.12;\n\nimport { FiatTokenV2 } from \"./FiatTokenV2.sol\";\n\n// solhint-disable func-name-mixedcase\n\n/**\n * @title FiatToken V2.1\n * @notice ERC20 Token backed by fiat reserves, version 2.1\n */\ncontract FiatTokenV2_1 is FiatTokenV2 {\n    /**\n     * @notice Initialize v2.1\n     * @param lostAndFound  The address to which the locked funds are sent\n     */\n    function initializeV2_1(address lostAndFound) external {\n        // solhint-disable-next-line reason-string\n        require(_initializedVersion == 1);\n\n        uint256 lockedAmount = balances[address(this)];\n        if (lockedAmount > 0) {\n            _transfer(address(this), lostAndFound, lockedAmount);\n        }\n        blacklisted[address(this)] = true;\n\n        _initializedVersion = 2;\n    }\n\n    /**\n     * @notice Version string for the EIP712 domain separator\n     * @return Version string\n     */\n    function version() external view returns (string memory) {\n        return \"2\";\n    }\n}\n"},"contracts/wrapped-tokens/interface/IUnwrapTokenV1.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\npragma solidity 0.6.12;\n\ninterface IUnwrapTokenV1 {\n    function requestWithdraw(address _recipient, uint256 _wbethAmount, uint256 _ethAmount) external;\n\n    function moveFromWrapContract() payable external;\n\n    function moveFromWrapContract(uint256 _ethAmount) external;\n}\n"},"contracts/wrapped-tokens/staking/upgrade/StakedTokenV2.sol":{"content":"/**\n * SPDX-License-Identifier: MIT\n *\n * Copyright (c) 2022 Coinbase, Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\npragma solidity 0.6.12;\n\nimport { FiatTokenV2_1 } from \"centre-tokens/contracts/v2/FiatTokenV2_1.sol\";\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\n/**\n * @title StakedTokenV2\n * @notice ERC20 token backed by staked cryptocurrency reserves, version 2\n */\ncontract StakedTokenV2 is FiatTokenV2_1 {\n    /**\n     * @dev The unit of exchangeRate\n     */\n    uint256 public constant _EXCHANGE_RATE_UNIT = 1e18;\n    /**\n     * @dev Storage slot with the address of the current oracle.\n     * This is the keccak-256 hash of \"org.binance.stakedToken.exchangeRateOracle\"\n     */\n    bytes32 private constant _EXCHANGE_RATE_ORACLE_POSITION = keccak256(\n        \"org.binance.stakedToken.exchangeRateOracle\"\n    );\n    /**\n     * @dev Storage slot with the current exchange rate.\n     * This is the keccak-256 hash of \"org.binance.stakedToken.exchangeRate\"\n     */\n    bytes32 private constant _EXCHANGE_RATE_POSITION = keccak256(\n        \"org.binance.stakedToken.exchangeRate\"\n    );\n    /**\n     * @dev Storage slot with the current eth receiver.\n     * This is the keccak-256 hash of \"org.binance.stakedToken.ethReceiver\"\n     */\n    bytes32 private constant _ETH_RECEIVER_POSITION = keccak256(\n        \"org.binance.stakedToken.ethReceiver\"\n    );\n    /**\n     * @dev Storage slot with the operator.\n     * This is the keccak-256 hash of \"org.binance.stakedToken.operator\"\n     */\n    bytes32 private constant _OPERATOR_POSITION = keccak256(\n        \"org.binance.stakedToken.operator\"\n    );\n\n    /**\n     * @dev Emitted when the oracle is updated\n     * @param newOracle The address of the new oracle\n     */\n    event OracleUpdated(address indexed newOracle);\n\n    /**\n     * @dev Emitted when the exchange rate is updated\n     * @param oracle The address initiating the exchange rate update\n     * @param newExchangeRate The new exchange rate\n     */\n    event ExchangeRateUpdated(address indexed oracle, uint256 newExchangeRate);\n\n    /**\n     * @dev Emitted when the ethReceiver is updated\n     * @param previousReceiver The previous ethReceiver\n     * @param newReceiver The new ethReceiver\n     */\n    event EthReceiverUpdated(address indexed previousReceiver, address indexed newReceiver);\n\n    /**\n     * @dev Emitted when the Operator is updated\n     * @param previousOperator The previous Operator\n     * @param newOperator The new Operator\n     */\n    event OperatorUpdated(address indexed previousOperator, address indexed newOperator);\n\n    /**\n     * @dev Emitted when the user deposit ETH for wBETH\n     * @param user The address depositing ETH\n     * @param ethAmount The ETH amount that the user deposited\n     * @param wBETHAmount The wBETH amount that the user received\n     * @param referral The referral address\n     */\n    event DepositEth(address indexed user, uint256 ethAmount, uint256 wBETHAmount, address indexed referral);\n\n    /**\n     * @dev Emitted when the operator supply ETH to this contract\n     * @param supplier The supplier\n     * @param ethAmount The ETH amount\n     */\n    event SuppliedEth(address indexed supplier, uint256 ethAmount);\n\n    /**\n     * @dev Emitted when the operator move ETH to the staking address\n     * @param ethReceiver The staking address\n     * @param ethAmount The ETH amount\n     */\n    event MovedToStakingAddress(address indexed ethReceiver, uint256 ethAmount);\n\n    /**\n     * @dev Emitted when user request withdraw eth\n     * @param user The address want to withdraw eth\n     * @param wbethAmount The wbeth amount user send\n     * @param ethAmount The eth amount user will get\n     */\n    event RequestWithdrawEth(address indexed user, uint256 wbethAmount, uint256 ethAmount);\n\n\n    /**\n     * @dev Emitted when the operator move ETH to the unwrap address\n     * @param unwrapAddress The unwrap address\n     * @param ethAmount The ETH amount\n     */\n    event MovedToUnwrapAddress(address indexed unwrapAddress, uint256 ethAmount);\n\n    /**\n     * @dev Throws if called by any account other than the oracle\n     */\n    modifier onlyOracle() {\n        require(\n            msg.sender == oracle(),\n            \"StakedTokenV1: caller is not the oracle\"\n        );\n        _;\n    }\n\n    /**\n     * @dev Throws if called by any account other than the operator\n     */\n    modifier onlyOperator() {\n        require(\n            msg.sender == operator(),\n            \"StakedTokenV1: caller is not the operator\"\n        );\n        _;\n    }\n\n    receive() external payable {\n        revert(\"please use deposit function to deposit ETH\");\n    }\n\n    /**\n     * @dev Function to mint tokens to msg.sender\n     * @param amount to mint\n     */\n    function mint(uint256 amount)\n        external\n        onlyMinters\n        returns (bool)\n    {\n        uint256 mintingAllowedAmount = minterAllowed[msg.sender];\n        require(\n            amount <= mintingAllowedAmount,\n            \"StakedTokenV1: mint amount exceeds minterAllowance\"\n        );\n\n        _mint(msg.sender, amount);\n\n        minterAllowed[msg.sender] = mintingAllowedAmount.sub(amount);\n        return true;\n    }\n\n    /**\n     * @dev Function to update the oracle\n     * @param newOracle The new oracle\n     */\n    function updateOracle(address newOracle) external onlyOwner {\n        require(\n            newOracle != address(0),\n            \"StakedTokenV1: oracle is the zero address\"\n        );\n        require(\n            newOracle != oracle(),\n            \"StakedTokenV1: new oracle is already the oracle\"\n        );\n        bytes32 position = _EXCHANGE_RATE_ORACLE_POSITION;\n        assembly {\n            sstore(position, newOracle)\n        }\n        emit OracleUpdated(newOracle);\n    }\n\n    /**\n     * @dev Function to update the exchange rate\n     * @param newExchangeRate The new exchange rate\n     */\n    function updateExchangeRate(uint256 newExchangeRate) external onlyOracle {\n        require(\n            newExchangeRate >= _EXCHANGE_RATE_UNIT,\n            \"StakedTokenV1: new exchange rate cannot be less than 1e18\"\n        );\n        bytes32 position = _EXCHANGE_RATE_POSITION;\n        assembly {\n            sstore(position, newExchangeRate)\n        }\n        emit ExchangeRateUpdated(msg.sender, newExchangeRate);\n    }\n\n    /**\n     * @dev Function to update the ethReceiver\n     * @param newEthReceiver The new ETH receiver\n     */\n    function updateEthReceiver(address newEthReceiver) external onlyOwner {\n        require(\n            newEthReceiver != address(0),\n            \"StakedTokenV1: newEthReceiver is the zero address\"\n        );\n\n        address currentReceiver = ethReceiver();\n        require(newEthReceiver != currentReceiver, \"StakedTokenV1: newEthReceiver is already the ethReceiver\");\n\n        bytes32 position = _ETH_RECEIVER_POSITION;\n        assembly {\n            sstore(position, newEthReceiver)\n        }\n        emit EthReceiverUpdated(currentReceiver, newEthReceiver);\n    }\n\n    /**\n     * @dev Function to update the operator\n     * @param newOperator The new operator\n     */\n    function updateOperator(address newOperator) external onlyOwner {\n        require(\n            newOperator != address(0),\n            \"StakedTokenV1: newOperator is the zero address\"\n        );\n\n        address currentOperator = operator();\n        require(newOperator != currentOperator, \"StakedTokenV1: newOperator is already the operator\");\n\n        bytes32 position = _OPERATOR_POSITION;\n        assembly {\n            sstore(position, newOperator)\n        }\n        emit OperatorUpdated(currentOperator, newOperator);\n    }\n\n    /**\n     * @dev Returns the address of the current oracle\n     * @return _oracle The address of the oracle\n     */\n    function oracle() public view returns (address _oracle) {\n        bytes32 position = _EXCHANGE_RATE_ORACLE_POSITION;\n        assembly {\n            _oracle := sload(position)\n        }\n    }\n\n    /**\n     * @dev Returns the current exchange rate scaled by by 10**18\n     * @return _exchangeRate The exchange rate\n     */\n    function exchangeRate() public view returns (uint256 _exchangeRate) {\n        bytes32 position = _EXCHANGE_RATE_POSITION;\n        assembly {\n            _exchangeRate := sload(position)\n        }\n    }\n\n    /**\n     * @dev Returns the current eth receiver\n     * @return _ethReceiver The eth receiver\n     */\n    function ethReceiver() public view returns (address _ethReceiver) {\n        bytes32 position = _ETH_RECEIVER_POSITION;\n        assembly {\n            _ethReceiver := sload(position)\n        }\n    }\n    \n    /**\n     * @dev Returns the operator\n     * @return _operator The operator\n     */\n    function operator() public view returns (address _operator) {\n        bytes32 position = _OPERATOR_POSITION;\n        assembly {\n            _operator := sload(position)\n        }\n    }\n\n    /**\n     * @dev Function to mint tokens\n     * @param _to The address that will receive the minted tokens.\n     * @param _amount The amount of tokens to mint. Must be less than or equal\n     * to the minterAllowance of the caller.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function _mint(address _to, uint256 _amount)\n    internal\n    whenNotPaused\n    notBlacklisted(msg.sender)\n    notBlacklisted(_to)\n    returns (bool)\n    {\n        require(_to != address(0), \"StakedTokenV1: mint to the zero address\");\n        require(_amount > 0, \"StakedTokenV1: mint amount not greater than 0\");\n\n        totalSupply_ = totalSupply_.add(_amount);\n        balances[_to] = balances[_to].add(_amount);\n\n        emit Mint(msg.sender, _to, _amount);\n        emit Transfer(address(0), _to, _amount);\n        return true;\n    }\n\n    /**\n     * @dev Function to burn tokens\n     * @param _amount The amount of tokens to burn. Must be less than or equal\n     * to the balance of the caller.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function _burn(uint256 _amount)\n    internal\n    whenNotPaused\n    notBlacklisted(msg.sender)\n    returns (bool)\n    {\n        uint256 balance = balances[msg.sender];\n        require(_amount > 0, \"burn amount not greater than 0\");\n        require(balance >= _amount, \"burn amount exceeds balance\");\n\n        totalSupply_ = totalSupply_.sub(_amount);\n        balances[msg.sender] = balance.sub(_amount);\n        emit Burn(msg.sender, _amount);\n        emit Transfer(msg.sender, address(0), _amount);\n        return true;\n    }\n}\n"},"contracts/wrapped-tokens/staking/upgrade/WrapTokenV2BSC.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\npragma solidity 0.6.12;\n\nimport \"./StakedTokenV2.sol\";\nimport \"../../interface/IUnwrapTokenV1.sol\";\n\ncontract WrapTokenV2BSC is StakedTokenV2 {\n    /**\n     * @dev ETH contract address on current chain.\n     */\n    address public constant _ETH_ADDRESS = 0x2170Ed0880ac9A755fd29B2688956BD959F933F8;\n\n    /**\n    * @dev UNWRAP ETH contract address on current chain.\n     */\n    address public constant _UNWRAP_ETH_ADDRESS = 0x79973d557CD9dd87eb61E250cc2572c990e20196;\n\n\n    /**\n     * @dev Function to deposit eth to the contract for wBETH\n     * @param amount The eth amount to deposit\n     * @param referral The referral address\n     */\n    function deposit(uint256 amount, address referral) external {\n        require(amount > 0, \"zero ETH amount\");\n        _safeTransferFrom(_ETH_ADDRESS, msg.sender, address(this), amount);\n\n        // ETH amount and exchangeRate are all scaled by 1e18\n        uint256 wBETHAmount = amount.mul(_EXCHANGE_RATE_UNIT).div(exchangeRate());\n\n        _mint(msg.sender, wBETHAmount);\n\n        emit DepositEth(msg.sender, amount, wBETHAmount, referral);\n    }\n\n    /**\n     * @dev Function to supply eth to the contract\n     * @param amount The eth amount to supply\n     */\n    function supplyEth(uint256 amount) external onlyOperator {\n        require(amount > 0, \"zero ETH amount\");\n        _safeTransferFrom(_ETH_ADDRESS, msg.sender, address(this), amount);\n\n        emit SuppliedEth(msg.sender, amount);\n    }\n\n    /**\n     * @dev Function to move eth to the ethReceiver\n     * @param amount The eth amount to move\n     */\n    function moveToStakingAddress(uint256 amount) external onlyOperator {\n        require(amount > 0, \"move amount cannot be 0\");\n\n        address _ethReceiver = ethReceiver();\n        require(_ethReceiver != address(0), \"zero ethReceiver\");\n\n        require(amount <= IERC20(_ETH_ADDRESS).balanceOf(address(this)), \"balance not enough\");\n        _safeTransfer(_ETH_ADDRESS, _ethReceiver, amount);\n\n        emit MovedToStakingAddress(_ethReceiver, amount);\n    }\n\n    function _safeTransfer(\n        address token,\n        address to,\n        uint256 value\n    ) internal {\n        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));\n        require(success && (data.length == 0 || abi.decode(data, (bool))), 'transfer failed');\n    }\n\n    function _safeTransferFrom(\n        address token,\n        address from,\n        address to,\n        uint256 value\n    ) internal {\n        (bool success, bytes memory data) =\n        token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));\n        require(success && (data.length == 0 || abi.decode(data, (bool))), 'transferFrom failed');\n    }\n\n    /**\n     * @dev Function to withdraw wBETH for eth\n     * @param wbethAmount The wBETH amount\n     */\n    function requestWithdrawEth(uint256 wbethAmount) external {\n        require(wbethAmount > 0, \"zero amount\");\n        // msg.value and exchangeRate are all scaled by 1e18\n        uint256 ethAmount = wbethAmount.mul(exchangeRate()).div(_EXCHANGE_RATE_UNIT);\n        _burn(wbethAmount);\n        IUnwrapTokenV1(_UNWRAP_ETH_ADDRESS).requestWithdraw(msg.sender, wbethAmount, ethAmount);\n        emit RequestWithdrawEth(msg.sender, wbethAmount, ethAmount);\n    }\n\n    /**\n     * @dev Function to move eth to the unwrap address\n     * @param amount The eth amount to move\n     */\n    function moveToUnwrapAddress(uint256 amount) external onlyOperator {\n        require(amount > 0, \"amount cannot be 0\");\n        require(_UNWRAP_ETH_ADDRESS != address(0), \"zero address\");\n        require(amount <= IERC20(_ETH_ADDRESS).balanceOf(address(this)), \"balance not enough\");\n\n        IUnwrapTokenV1(_UNWRAP_ETH_ADDRESS).moveFromWrapContract(amount);\n\n        emit MovedToUnwrapAddress(_UNWRAP_ETH_ADDRESS, amount);\n    }\n\n    /**\n    * @dev allow _UNWRAP_ETH_ADDRESS transfer eth\n     */\n    function approve() external onlyOperator {\n        IERC20(_ETH_ADDRESS).approve(_UNWRAP_ETH_ADDRESS, type(uint256).max);\n    }\n}\n"}},"matchId":"29498338","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-05-21T05:14:50Z","match":"exact_match","chainId":"56","address":"0xfe928A7D8Be9c8cEce7e97F0Ed5704f4fA2cb42A"}