{"file_path":"TrueUSD.sol","creation_status":"success","source_code":"// Dependency file: @openzeppelin/contracts/token/ERC20/IERC20.sol\r\n\r\n// SPDX-License-Identifier: MIT\r\n\r\n// pragma solidity >=0.6.0 <0.8.0;\r\n\r\n/**\r\n * @dev Interface of the ERC20 standard as defined in the EIP.\r\n */\r\ninterface IERC20 {\r\n    /**\r\n     * @dev Returns the amount of tokens in existence.\r\n     */\r\n    function totalSupply() external view returns (uint256);\r\n\r\n    /**\r\n     * @dev Returns the amount of tokens owned by `account`.\r\n     */\r\n    function balanceOf(address account) external view returns (uint256);\r\n\r\n    /**\r\n     * @dev Moves `amount` tokens from the caller's account to `recipient`.\r\n     *\r\n     * Returns a boolean value indicating whether the operation succeeded.\r\n     *\r\n     * Emits a {Transfer} event.\r\n     */\r\n    function transfer(address recipient, uint256 amount) external returns (bool);\r\n\r\n    /**\r\n     * @dev Returns the remaining number of tokens that `spender` will be\r\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\r\n     * zero by default.\r\n     *\r\n     * This value changes when {approve} or {transferFrom} are called.\r\n     */\r\n    function allowance(address owner, address spender) external view returns (uint256);\r\n\r\n    /**\r\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\r\n     *\r\n     * Returns a boolean value indicating whether the operation succeeded.\r\n     *\r\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\r\n     * that someone may use both the old and the new allowance by unfortunate\r\n     * transaction ordering. One possible solution to mitigate this race\r\n     * condition is to first reduce the spender's allowance to 0 and set the\r\n     * desired value afterwards:\r\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\r\n     *\r\n     * Emits an {Approval} event.\r\n     */\r\n    function approve(address spender, uint256 amount) external returns (bool);\r\n\r\n    /**\r\n     * @dev Moves `amount` tokens from `sender` to `recipient` using the\r\n     * allowance mechanism. `amount` is then deducted from the caller's\r\n     * allowance.\r\n     *\r\n     * Returns a boolean value indicating whether the operation succeeded.\r\n     *\r\n     * Emits a {Transfer} event.\r\n     */\r\n    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\r\n\r\n    /**\r\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\r\n     * another (`to`).\r\n     *\r\n     * Note that `value` may be zero.\r\n     */\r\n    event Transfer(address indexed from, address indexed to, uint256 value);\r\n\r\n    /**\r\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\r\n     * a call to {approve}. `value` is the new allowance.\r\n     */\r\n    event Approval(address indexed owner, address indexed spender, uint256 value);\r\n}\r\n\r\n\r\n// Dependency file: contracts/interface/ITrueCurrency.sol\r\n\r\n// pragma solidity 0.6.10;\r\n\r\n// import {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\r\n\r\ninterface ITrueCurrency {\r\n    function mint(address account, uint256 amount) external;\r\n\r\n    function burn(uint256 amount) external;\r\n\r\n    function setCanBurn(address account, bool _canBurn) external;\r\n\r\n    function setBurnBounds(uint256 _min, uint256 _max) external;\r\n\r\n    function reclaimEther(address payable _to) external;\r\n\r\n    function reclaimToken(IERC20 token, address _to) external;\r\n\r\n    function setBlacklisted(address account, bool isBlacklisted) external;\r\n\r\n    function destroyBlackFunds(address _blackListedUser) external;\r\n}\r\n\r\n\r\n// Dependency file: @openzeppelin/contracts/utils/Context.sol\r\n\r\n\r\n// pragma solidity >=0.6.0 <0.8.0;\r\n\r\n/*\r\n * @dev Provides information about the current execution context, including the\r\n * sender of the transaction and its data. While these are generally available\r\n * via msg.sender and msg.data, they should not be accessed in such a direct\r\n * manner, since when dealing with GSN meta-transactions the account sending and\r\n * paying for execution may not be the actual sender (as far as an application\r\n * is concerned).\r\n *\r\n * This contract is only required for intermediate, library-like contracts.\r\n */\r\nabstract contract Context {\r\n    function _msgSender() internal view virtual returns (address payable) {\r\n        return msg.sender;\r\n    }\r\n\r\n    function _msgData() internal view virtual returns (bytes memory) {\r\n        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\r\n        return msg.data;\r\n    }\r\n}\r\n\r\n\r\n// Dependency file: @openzeppelin/contracts/GSN/Context.sol\r\n\r\n\r\n// pragma solidity >=0.6.0 <0.8.0;\r\n\r\n// import \"@openzeppelin/contracts/utils/Context.sol\";\r\n\r\n\r\n// Dependency file: @openzeppelin/contracts/math/SafeMath.sol\r\n\r\n\r\n// pragma solidity >=0.6.0 <0.8.0;\r\n\r\n/**\r\n * @dev Wrappers over Solidity's arithmetic operations with added overflow\r\n * checks.\r\n *\r\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\r\n * in bugs, because programmers usually assume that an overflow raises an\r\n * error, which is the standard behavior in high level programming languages.\r\n * `SafeMath` restores this intuition by reverting the transaction when an\r\n * operation overflows.\r\n *\r\n * Using this library instead of the unchecked operations eliminates an entire\r\n * class of bugs, so it's recommended to use it always.\r\n */\r\nlibrary SafeMath {\r\n    /**\r\n     * @dev Returns the addition of two unsigned integers, with an overflow flag.\r\n     *\r\n     * _Available since v3.4._\r\n     */\r\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\r\n        uint256 c = a + b;\r\n        if (c < a) return (false, 0);\r\n        return (true, c);\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the substraction of two unsigned integers, with an overflow flag.\r\n     *\r\n     * _Available since v3.4._\r\n     */\r\n    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\r\n        if (b > a) return (false, 0);\r\n        return (true, a - b);\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\r\n     *\r\n     * _Available since v3.4._\r\n     */\r\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\r\n        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\r\n        // benefit is lost if 'b' is also tested.\r\n        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\r\n        if (a == 0) return (true, 0);\r\n        uint256 c = a * b;\r\n        if (c / a != b) return (false, 0);\r\n        return (true, c);\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the division of two unsigned integers, with a division by zero flag.\r\n     *\r\n     * _Available since v3.4._\r\n     */\r\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\r\n        if (b == 0) return (false, 0);\r\n        return (true, a / b);\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\r\n     *\r\n     * _Available since v3.4._\r\n     */\r\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\r\n        if (b == 0) return (false, 0);\r\n        return (true, a % b);\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the addition of two unsigned integers, reverting on\r\n     * overflow.\r\n     *\r\n     * Counterpart to Solidity's `+` operator.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - Addition cannot overflow.\r\n     */\r\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        uint256 c = a + b;\r\n        require(c >= a, \"SafeMath: addition overflow\");\r\n        return c;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the subtraction of two unsigned integers, reverting on\r\n     * overflow (when the result is negative).\r\n     *\r\n     * Counterpart to Solidity's `-` operator.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - Subtraction cannot overflow.\r\n     */\r\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        require(b <= a, \"SafeMath: subtraction overflow\");\r\n        return a - b;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the multiplication of two unsigned integers, reverting on\r\n     * overflow.\r\n     *\r\n     * Counterpart to Solidity's `*` operator.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - Multiplication cannot overflow.\r\n     */\r\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        if (a == 0) return 0;\r\n        uint256 c = a * b;\r\n        require(c / a == b, \"SafeMath: multiplication overflow\");\r\n        return c;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the integer division of two unsigned integers, reverting on\r\n     * division by zero. The result is rounded towards zero.\r\n     *\r\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\r\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\r\n     * uses an invalid opcode to revert (consuming all remaining gas).\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - The divisor cannot be zero.\r\n     */\r\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        require(b > 0, \"SafeMath: division by zero\");\r\n        return a / b;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\r\n     * reverting when dividing by zero.\r\n     *\r\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\r\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\r\n     * invalid opcode to revert (consuming all remaining gas).\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - The divisor cannot be zero.\r\n     */\r\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\r\n        require(b > 0, \"SafeMath: modulo by zero\");\r\n        return a % b;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\r\n     * overflow (when the result is negative).\r\n     *\r\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\r\n     * message unnecessarily. For custom revert reasons use {trySub}.\r\n     *\r\n     * Counterpart to Solidity's `-` operator.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - Subtraction cannot overflow.\r\n     */\r\n    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\r\n        require(b <= a, errorMessage);\r\n        return a - b;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the integer division of two unsigned integers, reverting with custom message on\r\n     * division by zero. The result is rounded towards zero.\r\n     *\r\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\r\n     * message unnecessarily. For custom revert reasons use {tryDiv}.\r\n     *\r\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\r\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\r\n     * uses an invalid opcode to revert (consuming all remaining gas).\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - The divisor cannot be zero.\r\n     */\r\n    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\r\n        require(b > 0, errorMessage);\r\n        return a / b;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\r\n     * reverting with custom message when dividing by zero.\r\n     *\r\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\r\n     * message unnecessarily. For custom revert reasons use {tryMod}.\r\n     *\r\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\r\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\r\n     * invalid opcode to revert (consuming all remaining gas).\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - The divisor cannot be zero.\r\n     */\r\n    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\r\n        require(b > 0, errorMessage);\r\n        return a % b;\r\n    }\r\n}\r\n\r\n\r\n// Dependency file: @openzeppelin/contracts/utils/Address.sol\r\n\r\n\r\n// pragma solidity >=0.6.2 <0.8.0;\r\n\r\n/**\r\n * @dev Collection of functions related to the address type\r\n */\r\nlibrary Address {\r\n    /**\r\n     * @dev Returns true if `account` is a contract.\r\n     *\r\n     * [IMPORTANT]\r\n     * ====\r\n     * It is unsafe to assume that an address for which this function returns\r\n     * false is an externally-owned account (EOA) and not a contract.\r\n     *\r\n     * Among others, `isContract` will return false for the following\r\n     * types of addresses:\r\n     *\r\n     *  - an externally-owned account\r\n     *  - a contract in construction\r\n     *  - an address where a contract will be created\r\n     *  - an address where a contract lived, but was destroyed\r\n     * ====\r\n     */\r\n    function isContract(address account) internal view returns (bool) {\r\n        // This method relies on extcodesize, which returns 0 for contracts in\r\n        // construction, since the code is only stored at the end of the\r\n        // constructor execution.\r\n\r\n        uint256 size;\r\n        // solhint-disable-next-line no-inline-assembly\r\n        assembly { size := extcodesize(account) }\r\n        return size > 0;\r\n    }\r\n\r\n    /**\r\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\r\n     * `recipient`, forwarding all available gas and reverting on errors.\r\n     *\r\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\r\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\r\n     * imposed by `transfer`, making them unable to receive funds via\r\n     * `transfer`. {sendValue} removes this limitation.\r\n     *\r\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\r\n     *\r\n     * IMPORTANT: because control is transferred to `recipient`, care must be\r\n     * taken to not create reentrancy vulnerabilities. Consider using\r\n     * {ReentrancyGuard} or the\r\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\r\n     */\r\n    function sendValue(address payable recipient, uint256 amount) internal {\r\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\r\n\r\n        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\r\n        (bool success, ) = recipient.call{ value: amount }(\"\");\r\n        require(success, \"Address: unable to send value, recipient may have reverted\");\r\n    }\r\n\r\n    /**\r\n     * @dev Performs a Solidity function call using a low level `call`. A\r\n     * plain`call` is an unsafe replacement for a function call: use this\r\n     * function instead.\r\n     *\r\n     * If `target` reverts with a revert reason, it is bubbled up by this\r\n     * function (like regular Solidity function calls).\r\n     *\r\n     * Returns the raw returned data. To convert to the expected return value,\r\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `target` must be a contract.\r\n     * - calling `target` with `data` must not revert.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\r\n      return functionCall(target, data, \"Address: low-level call failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\r\n     * `errorMessage` as a fallback revert reason when `target` reverts.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\r\n        return functionCallWithValue(target, data, 0, errorMessage);\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n     * but also transferring `value` wei to `target`.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the calling contract must have an ETH balance of at least `value`.\r\n     * - the called Solidity function must be `payable`.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\r\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\r\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\r\n     *\r\n     * _Available since v3.1._\r\n     */\r\n    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\r\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\r\n        require(isContract(target), \"Address: call to non-contract\");\r\n\r\n        // solhint-disable-next-line avoid-low-level-calls\r\n        (bool success, bytes memory returndata) = target.call{ value: value }(data);\r\n        return _verifyCallResult(success, returndata, errorMessage);\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n     * but performing a static call.\r\n     *\r\n     * _Available since v3.3._\r\n     */\r\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\r\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\r\n     * but performing a static call.\r\n     *\r\n     * _Available since v3.3._\r\n     */\r\n    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\r\n        require(isContract(target), \"Address: static call to non-contract\");\r\n\r\n        // solhint-disable-next-line avoid-low-level-calls\r\n        (bool success, bytes memory returndata) = target.staticcall(data);\r\n        return _verifyCallResult(success, returndata, errorMessage);\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n     * but performing a delegate call.\r\n     *\r\n     * _Available since v3.4._\r\n     */\r\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\r\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\r\n     * but performing a delegate call.\r\n     *\r\n     * _Available since v3.4._\r\n     */\r\n    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\r\n        require(isContract(target), \"Address: delegate call to non-contract\");\r\n\r\n        // solhint-disable-next-line avoid-low-level-calls\r\n        (bool success, bytes memory returndata) = target.delegatecall(data);\r\n        return _verifyCallResult(success, returndata, errorMessage);\r\n    }\r\n\r\n    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\r\n        if (success) {\r\n            return returndata;\r\n        } else {\r\n            // Look for revert reason and bubble it up if present\r\n            if (returndata.length > 0) {\r\n                // The easiest way to bubble the revert reason is using memory via assembly\r\n\r\n                // solhint-disable-next-line no-inline-assembly\r\n                assembly {\r\n                    let returndata_size := mload(returndata)\r\n                    revert(add(32, returndata), returndata_size)\r\n                }\r\n            } else {\r\n                revert(errorMessage);\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n\r\n// Dependency file: contracts/common/ProxyStorage.sol\r\n\r\n// pragma solidity 0.6.10;\r\n\r\n// solhint-disable max-states-count, var-name-mixedcase\r\n\r\n/**\r\n * Defines the storage layout of the token implementation contract. Any\r\n * newly declared state variables in future upgrades should be appended\r\n * to the bottom. Never remove state variables from this list, however variables\r\n * can be renamed. Please add _Deprecated to deprecated variables.\r\n */\r\ncontract ProxyStorage {\r\n    address public owner;\r\n    address public pendingOwner;\r\n\r\n    bool initialized;\r\n\r\n    address balances_Deprecated;\r\n    address allowances_Deprecated;\r\n\r\n    uint256 _totalSupply;\r\n\r\n    bool private paused_Deprecated = false;\r\n    address private globalPause_Deprecated;\r\n\r\n    uint256 public burnMin = 0;\r\n    uint256 public burnMax = 0;\r\n\r\n    address registry_Deprecated;\r\n\r\n    string name_Deprecated;\r\n    string symbol_Deprecated;\r\n\r\n    uint256[] gasRefundPool_Deprecated;\r\n    uint256 private redemptionAddressCount_Deprecated;\r\n    uint256 minimumGasPriceForFutureRefunds_Deprecated;\r\n\r\n    mapping(address => uint256) _balances;\r\n    mapping(address => mapping(address => uint256)) _allowances;\r\n    mapping(bytes32 => mapping(address => uint256)) attributes_Deprecated;\r\n\r\n    // reward token storage\r\n    mapping(address => address) finOps_Deprecated;\r\n    mapping(address => mapping(address => uint256)) finOpBalances_Deprecated;\r\n    mapping(address => uint256) finOpSupply_Deprecated;\r\n\r\n    // true reward allocation\r\n    // proportion: 1000 = 100%\r\n    struct RewardAllocation {\r\n        uint256 proportion;\r\n        address finOp;\r\n    }\r\n    mapping(address => RewardAllocation[]) _rewardDistribution_Deprecated;\r\n    uint256 maxRewardProportion_Deprecated = 1000;\r\n\r\n    mapping(address => bool) isBlacklisted;\r\n    mapping(address => bool) public canBurn;\r\n\r\n    // Proof of Reserve feed related variables\r\n    uint256 public chainReserveHeartbeat;\r\n    address public chainReserveFeed;\r\n    bool public proofOfReserveEnabled;\r\n\r\n    /* Additionally, we have several keccak-based storage locations.\r\n     * If you add more keccak-based storage mappings, such as mappings, you must document them here.\r\n     * If the length of the keccak input is the same as an existing mapping, it is possible there could be a preimage collision.\r\n     * A preimage collision can be used to attack the contract by treating one storage location as another,\r\n     * which would always be a critical issue.\r\n     * Carefully examine future keccak-based storage to ensure there can be no preimage collisions.\r\n     *******************************************************************************************************\r\n     ** length     input                                                         usage\r\n     *******************************************************************************************************\r\n     ** 19         \"trueXXX.proxy.owner\"                                         Proxy Owner\r\n     ** 27         \"trueXXX.pending.proxy.owner\"                                 Pending Proxy Owner\r\n     ** 28         \"trueXXX.proxy.implementation\"                                Proxy Implementation\r\n     ** 32         uint256(11)                                                   gasRefundPool_Deprecated\r\n     ** 64         uint256(address),uint256(14)                                  balanceOf\r\n     ** 64         uint256(address),keccak256(uint256(address),uint256(15))      allowance\r\n     ** 64         uint256(address),keccak256(bytes32,uint256(16))               attributes\r\n     **/\r\n}\r\n\r\n\r\n// Dependency file: contracts/common/ClaimableOwnable.sol\r\n\r\n// pragma solidity 0.6.10;\r\n\r\n// import {ProxyStorage} from \"contracts/common/ProxyStorage.sol\";\r\n\r\n/**\r\n * @title ClamableOwnable\r\n * @dev The ClamableOwnable contract is a copy of Claimable Contract by Zeppelin.\r\n * and provides basic authorization control functions. Inherits storage layout of\r\n * ProxyStorage.\r\n */\r\ncontract ClaimableOwnable is ProxyStorage {\r\n    /**\r\n     * @dev emitted when ownership is transferred\r\n     * @param previousOwner previous owner of this contract\r\n     * @param newOwner new owner of this contract\r\n     */\r\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\r\n\r\n    /**\r\n     * @dev sets the original `owner` of the contract to the sender\r\n     * at construction. Must then be reinitialized\r\n     */\r\n    constructor() public {\r\n        owner = msg.sender;\r\n        emit OwnershipTransferred(address(0), owner);\r\n    }\r\n\r\n    /**\r\n     * @dev Throws if called by any account other than the owner.\r\n     */\r\n    modifier onlyOwner() {\r\n        require(msg.sender == owner, \"only Owner\");\r\n        _;\r\n    }\r\n\r\n    /**\r\n     * @dev Modifier throws if called by any account other than the pendingOwner.\r\n     */\r\n    modifier onlyPendingOwner() {\r\n        require(msg.sender == pendingOwner, \"only pending owner\");\r\n        _;\r\n    }\r\n\r\n    /**\r\n     * @dev Allows the current owner to set the pendingOwner address.\r\n     * @param newOwner The address to transfer ownership to.\r\n     */\r\n    function transferOwnership(address newOwner) external onlyOwner {\r\n        pendingOwner = newOwner;\r\n    }\r\n\r\n    /**\r\n     * @dev Allows the pendingOwner address to finalize the transfer.\r\n     */\r\n    function claimOwnership() external onlyPendingOwner {\r\n        emit OwnershipTransferred(owner, pendingOwner);\r\n        owner = pendingOwner;\r\n        pendingOwner = address(0);\r\n    }\r\n}\r\n\r\n\r\n// Dependency file: contracts/common/ERC20.sol\r\n\r\n/**\r\n * @notice This is a copy of openzeppelin ERC20 contract with removed state variables.\r\n * Removing state variables has been necessary due to proxy pattern usage.\r\n * Changes to Openzeppelin ERC20 https://github.com/OpenZeppelin/openzeppelin-contracts/blob/de99bccbfd4ecd19d7369d01b070aa72c64423c9/contracts/token/ERC20/ERC20.sol:\r\n * - Remove state variables _name, _symbol, _decimals\r\n * - Use state variables _balances, _allowances, _totalSupply from ProxyStorage\r\n * - Remove constructor\r\n * - Solidity version changed from ^0.6.0 to 0.6.10\r\n * - Contract made abstract\r\n *\r\n * See also: ClaimableOwnable.sol and ProxyStorage.sol\r\n */\r\n\r\n\r\n// pragma solidity 0.6.10;\r\n\r\n// import {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\r\n// import {Context} from \"@openzeppelin/contracts/GSN/Context.sol\";\r\n// import {SafeMath} from \"@openzeppelin/contracts/math/SafeMath.sol\";\r\n// import {Address} from \"@openzeppelin/contracts/utils/Address.sol\";\r\n\r\n// import {ClaimableOwnable} from \"contracts/common/ClaimableOwnable.sol\";\r\n\r\n// prettier-ignore\r\n/**\r\n * @dev Implementation of the {IERC20} interface.\r\n *\r\n * This implementation is agnostic to the way tokens are created. This means\r\n * that a supply mechanism has to be added in a derived contract using {_mint}.\r\n * For a generic mechanism see {ERC20PresetMinterPauser}.\r\n *\r\n * TIP: For a detailed writeup see our guide\r\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\r\n * to implement supply mechanisms].\r\n *\r\n * We have followed general OpenZeppelin guidelines: functions revert instead\r\n * of returning `false` on failure. This behavior is nonetheless conventional\r\n * and does not conflict with the expectations of ERC20 applications.\r\n *\r\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\r\n * This allows applications to reconstruct the allowance for all accounts just\r\n * by listening to said events. Other implementations of the EIP may not emit\r\n * these events, as it isn't required by the specification.\r\n *\r\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\r\n * functions have been added to mitigate the well-known issues around setting\r\n * allowances. See {IERC20-approve}.\r\n */\r\nabstract contract ERC20 is ClaimableOwnable, Context, IERC20 {\r\n    using SafeMath for uint256;\r\n    using Address for address;\r\n\r\n    /**\r\n     * @dev Returns the name of the token.\r\n     */\r\n    function name() public virtual pure returns (string memory);\r\n\r\n    /**\r\n     * @dev Returns the symbol of the token, usually a shorter version of the\r\n     * name.\r\n     */\r\n    function symbol() public virtual pure returns (string memory);\r\n\r\n    /**\r\n     * @dev Returns the number of decimals used to get its user representation.\r\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\r\n     * be displayed to a user as `5,05` (`505 / 10 ** 2`).\r\n     *\r\n     * Tokens usually opt for a value of 18, imitating the relationship between\r\n     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is\r\n     * called.\r\n     *\r\n     * NOTE: This information is only used for _display_ purposes: it in\r\n     * no way affects any of the arithmetic of the contract, including\r\n     * {IERC20-balanceOf} and {IERC20-transfer}.\r\n     */\r\n    function decimals() public virtual pure returns (uint8) {\r\n        return 18;\r\n    }\r\n\r\n    /**\r\n     * @dev See {IERC20-totalSupply}.\r\n     */\r\n    function totalSupply() public view virtual override returns (uint256) {\r\n        return _totalSupply;\r\n    }\r\n\r\n    /**\r\n     * @dev See {IERC20-balanceOf}.\r\n     */\r\n    function balanceOf(address account) public view virtual override returns (uint256) {\r\n        return _balances[account];\r\n    }\r\n\r\n    /**\r\n     * @dev See {IERC20-transfer}.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `recipient` cannot be the zero address.\r\n     * - the caller must have a balance of at least `amount`.\r\n     */\r\n    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\r\n        _transfer(_msgSender(), recipient, amount);\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * @dev See {IERC20-allowance}.\r\n     */\r\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\r\n        return _allowances[owner][spender];\r\n    }\r\n\r\n    /**\r\n     * @dev See {IERC20-approve}.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `spender` cannot be the zero address.\r\n     */\r\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\r\n        _approve(_msgSender(), spender, amount);\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * @dev See {IERC20-transferFrom}.\r\n     *\r\n     * Emits an {Approval} event indicating the updated allowance. This is not\r\n     * required by the EIP. See the note at the beginning of {ERC20};\r\n     *\r\n     * Requirements:\r\n     * - `sender` and `recipient` cannot be the zero address.\r\n     * - `sender` must have a balance of at least `amount`.\r\n     * - the caller must have allowance for ``sender``'s tokens of at least\r\n     * `amount`.\r\n     */\r\n    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\r\n        _transfer(sender, recipient, amount);\r\n        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \"ERC20: transfer amount exceeds allowance\"));\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\r\n     *\r\n     * This is an alternative to {approve} that can be used as a mitigation for\r\n     * problems described in {IERC20-approve}.\r\n     *\r\n     * Emits an {Approval} event indicating the updated allowance.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `spender` cannot be the zero address.\r\n     */\r\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\r\n        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\r\n     *\r\n     * This is an alternative to {approve} that can be used as a mitigation for\r\n     * problems described in {IERC20-approve}.\r\n     *\r\n     * Emits an {Approval} event indicating the updated allowance.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `spender` cannot be the zero address.\r\n     * - `spender` must have allowance for the caller of at least\r\n     * `subtractedValue`.\r\n     */\r\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\r\n        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \"ERC20: decreased allowance below zero\"));\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * @dev Moves tokens `amount` from `sender` to `recipient`.\r\n     *\r\n     * This is internal function is equivalent to {transfer}, and can be used to\r\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\r\n     *\r\n     * Emits a {Transfer} event.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `sender` cannot be the zero address.\r\n     * - `recipient` cannot be the zero address.\r\n     * - `sender` must have a balance of at least `amount`.\r\n     */\r\n    function _transfer(address sender, address recipient, uint256 amount) internal virtual {\r\n        require(sender != address(0), \"ERC20: transfer from the zero address\");\r\n        require(recipient != address(0), \"ERC20: transfer to the zero address\");\r\n\r\n        _beforeTokenTransfer(sender, recipient, amount);\r\n\r\n        _balances[sender] = _balances[sender].sub(amount, \"ERC20: transfer amount exceeds balance\");\r\n        _balances[recipient] = _balances[recipient].add(amount);\r\n        emit Transfer(sender, recipient, amount);\r\n    }\r\n\r\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\r\n     * the total supply.\r\n     *\r\n     * Emits a {Transfer} event with `from` set to the zero address.\r\n     *\r\n     * Requirements\r\n     *\r\n     * - `to` cannot be the zero address.\r\n     */\r\n    function _mint(address account, uint256 amount) internal virtual {\r\n        require(account != address(0), \"ERC20: mint to the zero address\");\r\n\r\n        _beforeTokenTransfer(address(0), account, amount);\r\n\r\n        _totalSupply = _totalSupply.add(amount);\r\n        _balances[account] = _balances[account].add(amount);\r\n        emit Transfer(address(0), account, amount);\r\n    }\r\n\r\n    /**\r\n     * @dev Destroys `amount` tokens from `account`, reducing the\r\n     * total supply.\r\n     *\r\n     * Emits a {Transfer} event with `to` set to the zero address.\r\n     *\r\n     * Requirements\r\n     *\r\n     * - `account` cannot be the zero address.\r\n     * - `account` must have at least `amount` tokens.\r\n     */\r\n    function _burn(address account, uint256 amount) internal virtual {\r\n        require(account != address(0), \"ERC20: burn from the zero address\");\r\n\r\n        _beforeTokenTransfer(account, address(0), amount);\r\n\r\n        _balances[account] = _balances[account].sub(amount, \"ERC20: burn amount exceeds balance\");\r\n        _totalSupply = _totalSupply.sub(amount);\r\n        emit Transfer(account, address(0), amount);\r\n    }\r\n\r\n    /**\r\n     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.\r\n     *\r\n     * This is internal function is equivalent to `approve`, and can be used to\r\n     * e.g. set automatic allowances for certain subsystems, etc.\r\n     *\r\n     * Emits an {Approval} event.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `owner` cannot be the zero address.\r\n     * - `spender` cannot be the zero address.\r\n     */\r\n    function _approve(address owner, address spender, uint256 amount) internal virtual {\r\n        require(owner != address(0), \"ERC20: approve from the zero address\");\r\n        require(spender != address(0), \"ERC20: approve to the zero address\");\r\n\r\n        _allowances[owner][spender] = amount;\r\n        emit Approval(owner, spender, amount);\r\n    }\r\n\r\n    /**\r\n     * @dev Hook that is called before any transfer of tokens. This includes\r\n     * minting and burning.\r\n     *\r\n     * Calling conditions:\r\n     *\r\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\r\n     * will be to transferred to `to`.\r\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\r\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\r\n     * - `from` and `to` are never both zero.\r\n     *\r\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\r\n     */\r\n    // solhint-disable-next-line no-empty-blocks\r\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\r\n}\r\n\r\n\r\n// Dependency file: contracts/common/ReclaimerToken.sol\r\n\r\n// pragma solidity 0.6.10;\r\n\r\n// import {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\r\n// import {ITrueCurrency} from \"contracts/interface/ITrueCurrency.sol\";\r\n// import {ERC20} from \"contracts/common/ERC20.sol\";\r\n\r\n/**\r\n * @title ReclaimerToken\r\n * @dev ERC20 token which allows owner to reclaim ERC20 tokens\r\n * or ether sent to this contract\r\n */\r\nabstract contract ReclaimerToken is ERC20, ITrueCurrency {\r\n    /**\r\n     * @dev send all eth balance in the contract to another address\r\n     * @param _to address to send eth balance to\r\n     */\r\n    function reclaimEther(address payable _to) external override onlyOwner {\r\n        _to.transfer(address(this).balance);\r\n    }\r\n\r\n    /**\r\n     * @dev send all token balance of an arbitrary erc20 token\r\n     * in the contract to another address\r\n     * @param token token to reclaim\r\n     * @param _to address to send eth balance to\r\n     */\r\n    function reclaimToken(IERC20 token, address _to) external override onlyOwner {\r\n        uint256 balance = token.balanceOf(address(this));\r\n        token.transfer(_to, balance);\r\n    }\r\n}\r\n\r\n\r\n// Dependency file: contracts/common/BurnableTokenWithBounds.sol\r\n\r\n// pragma solidity 0.6.10;\r\n\r\n// import {ReclaimerToken} from \"contracts/common/ReclaimerToken.sol\";\r\n\r\n/**\r\n * @title BurnableTokenWithBounds\r\n * @dev Burning functions as redeeming money from the system.\r\n * The platform will keep track of who burns coins,\r\n * and will send them back the equivalent amount of money (rounded down to the nearest cent).\r\n */\r\nabstract contract BurnableTokenWithBounds is ReclaimerToken {\r\n    /**\r\n     * @dev Emitted when `value` tokens are burnt from one account (`burner`)\r\n     * @param burner address which burned tokens\r\n     * @param value amount of tokens burned\r\n     */\r\n    event Burn(address indexed burner, uint256 value);\r\n\r\n    /**\r\n     * @dev Emitted when new burn bounds were set\r\n     * @param newMin new minimum burn amount\r\n     * @param newMax new maximum burn amount\r\n     * @notice `newMin` should never be greater than `newMax`\r\n     */\r\n    event SetBurnBounds(uint256 newMin, uint256 newMax);\r\n\r\n    /**\r\n     * @dev Emitted when _blackListedUser's funds are destroyed\r\n     */\r\n    event DestroyedBlackFunds(address indexed _blackListedUser, uint256 _balance);\r\n\r\n    /**\r\n     * @dev Destroys `amount` tokens from `msg.sender`, reducing the\r\n     * total supply.\r\n     * @param amount amount of tokens to burn\r\n     *\r\n     * Emits a {Transfer} event with `to` set to the zero address.\r\n     * Emits a {Burn} event with `burner` set to `msg.sender`\r\n     *\r\n     * Requirements\r\n     *\r\n     * - `msg.sender` must have at least `amount` tokens.\r\n     *\r\n     */\r\n    function burn(uint256 amount) external override {\r\n        _burn(msg.sender, amount);\r\n    }\r\n\r\n    /**\r\n     * @dev Change the minimum and maximum amount that can be burned at once.\r\n     * Burning may be disabled by setting both to 0 (this will not be done\r\n     * under normal operation, but we can't add checks to disallow it without\r\n     * losing a lot of flexibility since burning could also be as good as disabled\r\n     * by setting the minimum extremely high, and we don't want to lock\r\n     * in any particular cap for the minimum)\r\n     * @param _min minimum amount that can be burned at once\r\n     * @param _max maximum amount that can be burned at once\r\n     */\r\n    function setBurnBounds(uint256 _min, uint256 _max) external override onlyOwner {\r\n        require(_min <= _max, \"BurnableTokenWithBounds: min > max\");\r\n        burnMin = _min;\r\n        burnMax = _max;\r\n        emit SetBurnBounds(_min, _max);\r\n    }\r\n\r\n    /**\r\n     * @dev Checks if amount is within allowed burn bounds and\r\n     * destroys `amount` tokens from `account`, reducing the\r\n     * total supply.\r\n     * @param account account to burn tokens for\r\n     * @param amount amount of tokens to burn\r\n     *\r\n     * Emits a {Burn} event\r\n     */\r\n    function _burn(address account, uint256 amount) internal virtual override {\r\n        require(amount >= burnMin, \"BurnableTokenWithBounds: below min burn bound\");\r\n        require(amount <= burnMax, \"BurnableTokenWithBounds: exceeds max burn bound\");\r\n\r\n        super._burn(account, amount);\r\n        emit Burn(account, amount);\r\n    }\r\n\r\n    /**\r\n     * @dev destroy black funds from _blackListedUser\r\n     * @param _blackListedUser the address to destroy from\r\n     */\r\n    function destroyBlackFunds(address _blackListedUser) external override onlyOwner {\r\n        require(isBlacklisted[_blackListedUser]);\r\n        uint256 dirtyFunds = balanceOf(_blackListedUser);\r\n\r\n        _balances[_blackListedUser] = 0;\r\n        _totalSupply = _totalSupply.sub(dirtyFunds);\r\n        emit DestroyedBlackFunds(_blackListedUser, dirtyFunds);\r\n    }\r\n}\r\n\r\n\r\n// Dependency file: contracts/TrueCurrency.sol\r\n\r\n// pragma solidity 0.6.10;\r\n\r\n// import {BurnableTokenWithBounds} from \"contracts/common/BurnableTokenWithBounds.sol\";\r\n\r\n/**\r\n * @title TrueCurrency\r\n * @dev TrueCurrency is an ERC20 with blacklist & redemption addresses\r\n *\r\n * TrueCurrency is a compliant stablecoin with blacklist and redemption\r\n * addresses. Only the owner can blacklist accounts. Redemption addresses\r\n * are assigned automatically to the first 0x100000 addresses. Sending\r\n * tokens to the redemption address will trigger a burn operation. Only\r\n * the owner can mint or blacklist accounts.\r\n *\r\n * This contract is owned by the TokenController, which manages token\r\n * minting & admin functionality. See TokenController.sol\r\n *\r\n * See also: BurnableTokenWithBounds.sol\r\n *\r\n * ~~~~ Features ~~~~\r\n *\r\n * Redemption Addresses\r\n * - The first 0x100000 addresses except from address(0) are redemption addresses\r\n * - Tokens sent to redemption addresses are burned\r\n * - Redemptions are tracked off-chain\r\n * - Cannot mint tokens to redemption addresses\r\n *\r\n * Blacklist\r\n * - Owner can blacklist accounts in accordance with local regulatory bodies\r\n * - Only a court order will merit a blacklist; blacklisting is extremely rare\r\n *\r\n * Burn Bounds & CanBurn\r\n * - Owner can set min & max burn amounts\r\n * - Only accounts flagged in canBurn are allowed to burn tokens\r\n * - canBurn prevents tokens from being sent to the incorrect address\r\n *\r\n * Reclaimer Token\r\n * - ERC20 Tokens and Ether sent to this contract can be reclaimed by the owner\r\n */\r\nabstract contract TrueCurrency is BurnableTokenWithBounds {\r\n    uint256 constant CENT = 10**16;\r\n    uint256 constant REDEMPTION_ADDRESS_COUNT = 0x100000;\r\n\r\n    /**\r\n     * @dev Emitted when account blacklist status changes\r\n     */\r\n    event Blacklisted(address indexed account, bool isBlacklisted);\r\n\r\n    /**\r\n     * @dev Emitted when `value` tokens are minted for `to`\r\n     * @param to address to mint tokens for\r\n     * @param value amount of tokens to be minted\r\n     */\r\n    event Mint(address indexed to, uint256 value);\r\n\r\n    /**\r\n     * @dev Creates `amount` tokens and assigns them to `account`, increasing\r\n     * the total supply.\r\n     * @param account address to mint tokens for\r\n     * @param amount amount of tokens to be minted\r\n     *\r\n     * Emits a {Mint} event\r\n     *\r\n     * Requirements\r\n     *\r\n     * - `account` cannot be the zero address.\r\n     * - `account` cannot be blacklisted.\r\n     * - `account` cannot be a redemption address.\r\n     */\r\n    function mint(address account, uint256 amount) external override onlyOwner {\r\n        require(!isBlacklisted[account], \"TrueCurrency: account is blacklisted\");\r\n        require(!isRedemptionAddress(account), \"TrueCurrency: account is a redemption address\");\r\n        _mint(account, amount);\r\n        emit Mint(account, amount);\r\n    }\r\n\r\n    /**\r\n     * @dev Set blacklisted status for the account.\r\n     * @param account address to set blacklist flag for\r\n     * @param _isBlacklisted blacklist flag value\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `msg.sender` should be owner.\r\n     */\r\n    function setBlacklisted(address account, bool _isBlacklisted) external override onlyOwner {\r\n        require(uint256(account) >= REDEMPTION_ADDRESS_COUNT, \"TrueCurrency: blacklisting of redemption address is not allowed\");\r\n        isBlacklisted[account] = _isBlacklisted;\r\n        emit Blacklisted(account, _isBlacklisted);\r\n    }\r\n\r\n    /**\r\n     * @dev Set canBurn status for the account.\r\n     * @param account address to set canBurn flag for\r\n     * @param _canBurn canBurn flag value\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `msg.sender` should be owner.\r\n     */\r\n    function setCanBurn(address account, bool _canBurn) external override onlyOwner {\r\n        canBurn[account] = _canBurn;\r\n    }\r\n\r\n    /**\r\n     * @dev Check if neither account is blacklisted before performing transfer\r\n     * If transfer recipient is a redemption address, burns tokens\r\n     * @notice Transfer to redemption address will burn tokens with a 1 cent precision\r\n     * @param sender address of sender\r\n     * @param recipient address of recipient\r\n     * @param amount amount of tokens to transfer\r\n     */\r\n    function _transfer(\r\n        address sender,\r\n        address recipient,\r\n        uint256 amount\r\n    ) internal virtual override {\r\n        require(!isBlacklisted[sender], \"TrueCurrency: sender is blacklisted\");\r\n        require(!isBlacklisted[recipient], \"TrueCurrency: recipient is blacklisted\");\r\n\r\n        if (isRedemptionAddress(recipient)) {\r\n            super._transfer(sender, recipient, amount.sub(amount.mod(CENT)));\r\n            _burn(recipient, amount.sub(amount.mod(CENT)));\r\n        } else {\r\n            super._transfer(sender, recipient, amount);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Requere neither accounts to be blacklisted before approval\r\n     * @param owner address of owner giving approval\r\n     * @param spender address of spender to approve for\r\n     * @param amount amount of tokens to approve\r\n     */\r\n    function _approve(\r\n        address owner,\r\n        address spender,\r\n        uint256 amount\r\n    ) internal override {\r\n        require(!isBlacklisted[owner], \"TrueCurrency: tokens owner is blacklisted\");\r\n        require(!isBlacklisted[spender] || amount == 0, \"TrueCurrency: tokens spender is blacklisted\");\r\n\r\n        super._approve(owner, spender, amount);\r\n    }\r\n\r\n    /**\r\n     * @dev Check if tokens can be burned at address before burning\r\n     * @param account account to burn tokens from\r\n     * @param amount amount of tokens to burn\r\n     */\r\n    function _burn(address account, uint256 amount) internal override {\r\n        require(canBurn[account], \"TrueCurrency: cannot burn from this address\");\r\n        super._burn(account, amount);\r\n    }\r\n\r\n    /**\r\n     * @dev First 0x100000-1 addresses (0x0000000000000000000000000000000000000001 to 0x00000000000000000000000000000000000fffff)\r\n     * are the redemption addresses.\r\n     * @param account address to check is a redemption address\r\n     *\r\n     * All transfers to redemption address will trigger token burn.\r\n     *\r\n     * @notice For transfer to succeed, canBurn must be true for redemption address\r\n     *\r\n     * @return is `account` a redemption address\r\n     */\r\n    function isRedemptionAddress(address account) internal pure returns (bool) {\r\n        return uint256(account) < REDEMPTION_ADDRESS_COUNT && account != address(0);\r\n    }\r\n}\r\n\r\n\r\n// Dependency file: @chainlink/contracts/src/v0.6/interfaces/AggregatorV3Interface.sol\r\n\r\n// pragma solidity >=0.6.0;\r\n\r\ninterface AggregatorV3Interface {\r\n\r\n  function decimals() external view returns (uint8);\r\n  function description() external view returns (string memory);\r\n  function version() external view returns (uint256);\r\n\r\n  // getRoundData and latestRoundData should both raise \"No data present\"\r\n  // if they do not have data to report, instead of returning unset values\r\n  // which could be misinterpreted as actual reported values.\r\n  function getRoundData(uint80 _roundId)\r\n    external\r\n    view\r\n    returns (\r\n      uint80 roundId,\r\n      int256 answer,\r\n      uint256 startedAt,\r\n      uint256 updatedAt,\r\n      uint80 answeredInRound\r\n    );\r\n  function latestRoundData()\r\n    external\r\n    view\r\n    returns (\r\n      uint80 roundId,\r\n      int256 answer,\r\n      uint256 startedAt,\r\n      uint256 updatedAt,\r\n      uint80 answeredInRound\r\n    );\r\n\r\n}\r\n\r\n\r\n// Dependency file: contracts/interface/IProofOfReserveToken.sol\r\n\r\n// pragma solidity 0.6.10;\r\n\r\ninterface IProofOfReserveToken {\r\n    /*** Admin Functions ***/\r\n\r\n    function setChainReserveFeed(address newFeed) external;\r\n\r\n    function setChainReserveHeartbeat(uint256 newHeartbeat) external;\r\n\r\n    function enableProofOfReserve() external;\r\n\r\n    function disableProofOfReserve() external;\r\n\r\n    /*** Events ***/\r\n\r\n    /**\r\n     * @notice Event emitted when the feed is updated\r\n     */\r\n    event NewChainReserveFeed(address oldFeed, address newFeed);\r\n\r\n    /**\r\n     * @notice Event emitted when the heartbeat of chain reserve feed is updated\r\n     */\r\n    event NewChainReserveHeartbeat(uint256 oldHeartbeat, uint256 newHeartbeat);\r\n\r\n    /**\r\n     * @notice Event emitted when Proof of Reserve is enabled\r\n     */\r\n    event ProofOfReserveEnabled();\r\n\r\n    /**\r\n     * @notice Event emitted when Proof of Reserve is disabled\r\n     */\r\n    event ProofOfReserveDisabled();\r\n}\r\n\r\n\r\n// Dependency file: contracts/TrueCurrencyWithProofOfReserve.sol\r\n\r\n// pragma solidity 0.6.10;\r\n\r\n// import {TrueCurrency} from \"contracts/TrueCurrency.sol\";\r\n// import {AggregatorV3Interface} from \"@chainlink/contracts/src/v0.6/interfaces/AggregatorV3Interface.sol\";\r\n// import {IProofOfReserveToken} from \"contracts/interface/IProofOfReserveToken.sol\";\r\n// import {SafeMath} from \"@openzeppelin/contracts/math/SafeMath.sol\";\r\n\r\n/**\r\n * @title TrueCurrencyWithProofOfReserve\r\n * @dev TrueCurrencyWithProofOfReserve is an ERC20 with blacklist & redemption addresses.\r\n *  Please see TrueCurrency for the implementation that this contract inherits from.\r\n *  This contract implements an additional check against a Proof-of-Reserves feed before\r\n *  allowing tokens to be minted.\r\n */\r\nabstract contract TrueCurrencyWithProofOfReserve is TrueCurrency, IProofOfReserveToken {\r\n    using SafeMath for uint256;\r\n\r\n    /**\r\n     * @notice Overriden mint function that checks the specified proof-of-reserves feed to\r\n     * ensure that the total supply of this TrueCurrency is not greater than the reported\r\n     * reserves.\r\n     * @dev The proof-of-reserves check is bypassed if feed is not set.\r\n     * @param account The address to mint tokens to\r\n     * @param amount The amount of tokens to mint\r\n     */\r\n    function _mint(address account, uint256 amount) internal virtual override {\r\n        if (chainReserveFeed == address(0) || !proofOfReserveEnabled) {\r\n            super._mint(account, amount);\r\n            return;\r\n        }\r\n        // Get required info about decimals.\r\n        // Decimals of the Proof of Reserve feed must be the same as the token's.\r\n        require(decimals() == AggregatorV3Interface(chainReserveFeed).decimals(), \"TrueCurrency: Unexpected decimals of PoR feed\");\r\n\r\n        // Get latest proof-of-reserves from the feed\r\n        (, int256 signedReserves, , uint256 updatedAt, ) = AggregatorV3Interface(chainReserveFeed).latestRoundData();\r\n        require(signedReserves > 0, \"TrueCurrency: Invalid answer from PoR feed\");\r\n        uint256 reserves = uint256(signedReserves);\r\n\r\n        // Sanity check: is chainlink answer updatedAt in the past\r\n        require(block.timestamp >= updatedAt, \"TrueCurrency: invalid PoR updatedAt\");\r\n\r\n        // Check the answer is fresh enough (i.e., within the specified heartbeat)\r\n        require(block.timestamp.sub(updatedAt) <= chainReserveHeartbeat, \"TrueCurrency: PoR answer too old\");\r\n\r\n        // Get required info about total supply.\r\n        // Check that after minting more tokens, the total supply would NOT exceed the reserves\r\n        // reported by the latest valid proof-of-reserves feed.\r\n        require(totalSupply() + amount <= reserves, \"TrueCurrency: total supply would exceed reserves after mint\");\r\n        super._mint(account, amount);\r\n    }\r\n\r\n    /**\r\n     * @notice Sets a new feed address\r\n     * @dev Admin function to set a new feed\r\n     * @param newFeed Address of the new feed\r\n     */\r\n    function setChainReserveFeed(address newFeed) external override onlyOwner {\r\n        emit NewChainReserveFeed(chainReserveFeed, newFeed);\r\n        chainReserveFeed = newFeed;\r\n        if (newFeed == address(0)) {\r\n            proofOfReserveEnabled = false;\r\n            emit ProofOfReserveDisabled();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @notice Sets the feed's heartbeat expectation\r\n     * @dev Admin function to set the heartbeat\r\n     * @param newHeartbeat Value of the age of the latest update from the feed\r\n     */\r\n    function setChainReserveHeartbeat(uint256 newHeartbeat) external override onlyOwner {\r\n        emit NewChainReserveHeartbeat(chainReserveHeartbeat, newHeartbeat);\r\n        chainReserveHeartbeat = newHeartbeat;\r\n    }\r\n\r\n    /**\r\n     * @notice Disable Proof of Reserve check\r\n     * @dev Admin function to disable Proof of Reserve\r\n     */\r\n    function disableProofOfReserve() external override onlyOwner {\r\n        proofOfReserveEnabled = false;\r\n        emit ProofOfReserveDisabled();\r\n    }\r\n\r\n    /**\r\n     * @notice Enable Proof of Reserve check\r\n     * @dev Admin function to enable Proof of Reserve\r\n     */\r\n    function enableProofOfReserve() external override onlyOwner {\r\n        require(chainReserveFeed != address(0), \"TrueCurrency: chainReserveFeed not set\");\r\n        require(chainReserveHeartbeat != 0, \"TrueCurrency: chainReserveHeartbeat not set\");\r\n        proofOfReserveEnabled = true;\r\n        emit ProofOfReserveEnabled();\r\n    }\r\n}\r\n\r\n\r\n// Root file: contracts/tokens/TrueUSD.sol\r\n\r\npragma solidity 0.6.10;\r\n\r\n// import {TrueCurrencyWithProofOfReserve} from \"contracts/TrueCurrencyWithProofOfReserve.sol\";\r\n\r\n/**\r\n * @title TrueUSD\r\n * @dev This is the top-level ERC20 contract, but most of the interesting functionality is\r\n * inherited - see the documentation on the corresponding contracts.\r\n */\r\ncontract TrueUSD is TrueCurrencyWithProofOfReserve {\r\n    uint8 constant DECIMALS = 18;\r\n    uint8 constant ROUNDING = 2;\r\n\r\n    function decimals() public pure override returns (uint8) {\r\n        return DECIMALS;\r\n    }\r\n\r\n    function rounding() public pure returns (uint8) {\r\n        return ROUNDING;\r\n    }\r\n\r\n    function name() public pure override returns (string memory) {\r\n        return \"TrueUSD\";\r\n    }\r\n\r\n    function symbol() public pure override returns (string memory) {\r\n        return \"TUSD\";\r\n    }\r\n}","deployed_bytecode":"0x608060405234801561001057600080fd5b50600436106102065760003560e01c806370a082311161011a578063b1684b17116100ad578063dd62ed3e1161007c578063dd62ed3e146105b5578063e30c3978146105e3578063ecae1e0c146105eb578063f2fde38b14610611578063f3bdc2281461063757610206565b8063b1684b171461056f578063cb4136c714610577578063d01dd6d21461057f578063dcb2126e146105ad57610206565b806395d89b41116100e957806395d89b41146104e95780639a6a30a4146104f1578063a457c2d714610517578063a9059cbb1461054357610206565b806370a0823114610443578063807496561461046957806388ee39cc146104975780638da5cb5b146104c557610206565b80633820a6861161019d57806341e92edc1161016c57806341e92edc146103eb57806342966c68146103f35780634e71e0c81461041057806352006050146104185780635c131d701461043b57610206565b80633820a68614610365578063395093511461038b57806339826dac146103b757806340c10f19146103bf57610206565b806323b872dd116101d957806323b872dd146102ea57806329a2ce9c146103205780632e4404031461033f578063313ce5671461035d57610206565b806302d3fdc91461020b57806306fdde0314610225578063095ea7b3146102a257806318160ddd146102e2575b600080fd5b61021361065d565b60408051918252519081900360200190f35b61022d610663565b6040805160208082528351818301528351919283929083019185019080838360005b8381101561026757818101518382015260200161024f565b50505050905090810190601f1680156102945780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6102ce600480360360408110156102b857600080fd5b506001600160a01b038135169060200135610684565b604080519115158252519081900360200190f35b6102136106a1565b6102ce6004803603606081101561030057600080fd5b506001600160a01b038135811691602081013590911690604001356106a7565b61033d6004803603602081101561033657600080fd5b5035610734565b005b6103476107c2565b6040805160ff9092168252519081900360200190f35b6103476107c7565b6102ce6004803603602081101561037b57600080fd5b50356001600160a01b03166107cc565b6102ce600480360360408110156103a157600080fd5b506001600160a01b0381351690602001356107e1565b610213610835565b61033d600480360360408110156103d557600080fd5b506001600160a01b03813516906020013561083b565b61033d610971565b61033d6004803603602081101561040957600080fd5b50356109f5565b61033d610a02565b61033d6004803603604081101561042e57600080fd5b5080359060200135610aba565b610213610b8e565b6102136004803603602081101561045957600080fd5b50356001600160a01b0316610b94565b61033d6004803603604081101561047f57600080fd5b506001600160a01b0381351690602001351515610baf565b61033d600480360360408110156104ad57600080fd5b506001600160a01b0381358116916020013516610c26565b6104cd610d6f565b604080516001600160a01b039092168252519081900360200190f35b61022d610d7e565b61033d6004803603602081101561050757600080fd5b50356001600160a01b0316610d9c565b6102ce6004803603604081101561052d57600080fd5b506001600160a01b038135169060200135610e21565b6102ce6004803603604081101561055957600080fd5b506001600160a01b038135169060200135610e8f565b6102ce610ea3565b61033d610eb3565b61033d6004803603604081101561059557600080fd5b506001600160a01b0381351690602001351515610fc2565b6104cd6110b9565b610213600480360360408110156105cb57600080fd5b506001600160a01b03813581169160200135166110c8565b6104cd6110f3565b61033d6004803603602081101561060157600080fd5b50356001600160a01b0316611102565b61033d6004803603602081101561062757600080fd5b50356001600160a01b03166111f1565b61033d6004803603602081101561064d57600080fd5b50356001600160a01b031661125f565b60065481565b604080518082019091526007815266151c9d595554d160ca1b602082015290565b6000610698610691611350565b8484611354565b50600192915050565b60045490565b60006106b484848461141d565b61072a846106c0611350565b6107258560405180606001604052806028815260200161213f602891396001600160a01b038a166000908152600f60205260408120906106fe611350565b6001600160a01b03168152602081019190915260400160002054919063ffffffff61154c16565b611354565b5060019392505050565b6000546001600160a01b03163314610780576040805162461bcd60e51b815260206004820152600a60248201526937b7363c9027bbb732b960b11b604482015290519081900360640190fd5b601854604080519182526020820183905280517f8f4442a73fbe31a2f75eb1b278a10e2d878b58f80fe113c7b63c313fb05c48379281900390910190a1601855565b600290565b601290565b60176020526000908152604090205460ff1681565b60006106986107ee611350565b8461072585600f60006107ff611350565b6001600160a01b03908116825260208083019390935260409182016000908120918c16815292529020549063ffffffff6115e316565b60185481565b6000546001600160a01b03163314610887576040805162461bcd60e51b815260206004820152600a60248201526937b7363c9027bbb732b960b11b604482015290519081900360640190fd5b6001600160a01b03821660009081526016602052604090205460ff16156108df5760405162461bcd60e51b815260040180806020018281038252602481526020018061203b6024913960400191505060405180910390fd5b6108e882611644565b156109245760405162461bcd60e51b815260040180806020018281038252602d815260200180612167602d913960400191505060405180910390fd5b61092e828261166f565b6040805182815290516001600160a01b038416917f0f6798a560793a54c3bcfe86a93cde1e73087d944c0ea20544137d4121396885919081900360200190a25050565b6000546001600160a01b031633146109bd576040805162461bcd60e51b815260206004820152600a60248201526937b7363c9027bbb732b960b11b604482015290519081900360640190fd5b6019805460ff60a01b191690556040517fb7da79009bb7dee27ac24cc582fddf2186e6d5fbb28e4f9394d98bf166b1ea4690600090a1565b6109ff338261192c565b50565b6001546001600160a01b03163314610a56576040805162461bcd60e51b815260206004820152601260248201527137b7363c903832b73234b7339037bbb732b960711b604482015290519081900360640190fd5b600154600080546040516001600160a01b0393841693909116917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a360018054600080546001600160a01b03199081166001600160a01b03841617909155169055565b6000546001600160a01b03163314610b06576040805162461bcd60e51b815260206004820152600a60248201526937b7363c9027bbb732b960b11b604482015290519081900360640190fd5b80821115610b455760405162461bcd60e51b815260040180806020018281038252602281526020018061211d6022913960400191505060405180910390fd5b60068290556007819055604080518381526020810183905281517f21d54a4c1f750b4f93779e3e8b4de89db3f31bab8f203e68569727fee906cc32929181900390910190a15050565b60075481565b6001600160a01b03166000908152600e602052604090205490565b6000546001600160a01b03163314610bfb576040805162461bcd60e51b815260206004820152600a60248201526937b7363c9027bbb732b960b11b604482015290519081900360640190fd5b6001600160a01b03919091166000908152601760205260409020805460ff1916911515919091179055565b6000546001600160a01b03163314610c72576040805162461bcd60e51b815260206004820152600a60248201526937b7363c9027bbb732b960b11b604482015290519081900360640190fd5b604080516370a0823160e01b815230600482015290516000916001600160a01b038516916370a0823191602480820192602092909190829003018186803b158015610cbc57600080fd5b505afa158015610cd0573d6000803e3d6000fd5b505050506040513d6020811015610ce657600080fd5b50516040805163a9059cbb60e01b81526001600160a01b0385811660048301526024820184905291519293509085169163a9059cbb916044808201926020929091908290030181600087803b158015610d3e57600080fd5b505af1158015610d52573d6000803e3d6000fd5b505050506040513d6020811015610d6857600080fd5b5050505050565b6000546001600160a01b031681565b604080518082019091526004815263151554d160e21b602082015290565b6000546001600160a01b03163314610de8576040805162461bcd60e51b815260206004820152600a60248201526937b7363c9027bbb732b960b11b604482015290519081900360640190fd5b6040516001600160a01b038216904780156108fc02916000818181858888f19350505050158015610e1d573d6000803e3d6000fd5b5050565b6000610698610e2e611350565b846107258560405180606001604052806025815260200161231e60259139600f6000610e58611350565b6001600160a01b03908116825260208083019390935260409182016000908120918d1681529252902054919063ffffffff61154c16565b6000610698610e9c611350565b848461141d565b601954600160a01b900460ff1681565b6000546001600160a01b03163314610eff576040805162461bcd60e51b815260206004820152600a60248201526937b7363c9027bbb732b960b11b604482015290519081900360640190fd5b6019546001600160a01b0316610f465760405162461bcd60e51b81526004018080602001828103825260268152602001806120f76026913960400191505060405180910390fd5b601854610f845760405162461bcd60e51b815260040180806020018281038252602b81526020018061228d602b913960400191505060405180910390fd5b6019805460ff60a01b1916600160a01b1790556040517f7082258d7dd34469380c488363d2f89413f24989ca88d6d70a0b7222f47b50f990600090a1565b6000546001600160a01b0316331461100e576040805162461bcd60e51b815260206004820152600a60248201526937b7363c9027bbb732b960b11b604482015290519081900360640190fd5b62100000826001600160a01b031610156110595760405162461bcd60e51b815260040180806020018281038252603f815260200180612194603f913960400191505060405180910390fd5b6001600160a01b038216600081815260166020908152604091829020805460ff1916851515908117909155825190815291517fcf3473b85df1594d47b6958f29a32bea0abff9dd68296f7bf33443646793cfd89281900390910190a25050565b6019546001600160a01b031681565b6001600160a01b039182166000908152600f6020908152604080832093909416825291909152205490565b6001546001600160a01b031681565b6000546001600160a01b0316331461114e576040805162461bcd60e51b815260206004820152600a60248201526937b7363c9027bbb732b960b11b604482015290519081900360640190fd5b601954604080516001600160a01b039283168152918316602083015280517fb566b2540a94f2713f3e0bcd83e8487b19cbf5ec138d8bfcf01722075dd063759281900390910190a1601980546001600160a01b0319166001600160a01b0383169081179091556109ff576019805460ff60a01b191690556040517fb7da79009bb7dee27ac24cc582fddf2186e6d5fbb28e4f9394d98bf166b1ea4690600090a150565b6000546001600160a01b0316331461123d576040805162461bcd60e51b815260206004820152600a60248201526937b7363c9027bbb732b960b11b604482015290519081900360640190fd5b600180546001600160a01b0319166001600160a01b0392909216919091179055565b6000546001600160a01b031633146112ab576040805162461bcd60e51b815260206004820152600a60248201526937b7363c9027bbb732b960b11b604482015290519081900360640190fd5b6001600160a01b03811660009081526016602052604090205460ff166112d057600080fd5b60006112db82610b94565b6001600160a01b0383166000908152600e602052604081205560045490915061130a908263ffffffff61198d16565b6004556040805182815290516001600160a01b038416917f61e6e66b0d6339b2980aecc6ccc0039736791f0ccde9ed512e789a7fbdd698c6919081900360200190a25050565b3390565b6001600160a01b03831660009081526016602052604090205460ff16156113ac5760405162461bcd60e51b81526004018080602001828103825260298152602001806120856029913960400191505060405180910390fd5b6001600160a01b03821660009081526016602052604090205460ff1615806113d2575080155b61140d5760405162461bcd60e51b815260040180806020018281038252602b815260200180611f9f602b913960400191505060405180910390fd5b6114188383836119ea565b505050565b6001600160a01b03831660009081526016602052604090205460ff16156114755760405162461bcd60e51b815260040180806020018281038252602381526020018061226a6023913960400191505060405180910390fd5b6001600160a01b03821660009081526016602052604090205460ff16156114cd5760405162461bcd60e51b81526004018080602001828103825260268152602001806120ae6026913960400191505060405180910390fd5b6114d682611644565b156115415761150c83836115076114fa85662386f26fc1000063ffffffff611ad616565b859063ffffffff61198d16565b611b3d565b61153c8261153761152a84662386f26fc1000063ffffffff611ad616565b849063ffffffff61198d16565b61192c565b611418565b611418838383611b3d565b600081848411156115db5760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b838110156115a0578181015183820152602001611588565b50505050905090810190601f1680156115cd5780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b505050900390565b60008282018381101561163d576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b9392505050565b600062100000826001600160a01b031610801561166957506001600160a01b03821615155b92915050565b6019546001600160a01b031615806116915750601954600160a01b900460ff16155b156116a5576116a08282611ca6565b610e1d565b601960009054906101000a90046001600160a01b03166001600160a01b031663313ce5676040518163ffffffff1660e01b815260040160206040518083038186803b1580156116f357600080fd5b505afa158015611707573d6000803e3d6000fd5b505050506040513d602081101561171d57600080fd5b505160ff1661172a6107c7565b60ff16146117695760405162461bcd60e51b815260040180806020018281038252602d815260200180612219602d913960400191505060405180910390fd5b600080601960009054906101000a90046001600160a01b03166001600160a01b031663feaf968c6040518163ffffffff1660e01b815260040160a06040518083038186803b1580156117ba57600080fd5b505afa1580156117ce573d6000803e3d6000fd5b505050506040513d60a08110156117e457600080fd5b5060208101516060909101519092509050600082136118345760405162461bcd60e51b815260040180806020018281038252602a815260200180612343602a913960400191505060405180910390fd5b81428211156118745760405162461bcd60e51b81526004018080602001828103825260238152602001806120d46023913960400191505060405180910390fd5b601854611887428463ffffffff61198d16565b11156118da576040805162461bcd60e51b815260206004820181905260248201527f5472756543757272656e63793a20506f5220616e7377657220746f6f206f6c64604482015290519081900360640190fd5b80846118e46106a1565b0111156119225760405162461bcd60e51b815260040180806020018281038252603b8152602001806122e3603b913960400191505060405180910390fd5b610d688585611ca6565b6001600160a01b03821660009081526017602052604090205460ff166119835760405162461bcd60e51b815260040180806020018281038252602b8152602001806122b8602b913960400191505060405180910390fd5b610e1d8282611da4565b6000828211156119e4576040805162461bcd60e51b815260206004820152601e60248201527f536166654d6174683a207375627472616374696f6e206f766572666c6f770000604482015290519081900360640190fd5b50900390565b6001600160a01b038316611a2f5760405162461bcd60e51b81526004018080602001828103825260248152602001806122466024913960400191505060405180910390fd5b6001600160a01b038216611a745760405162461bcd60e51b81526004018080602001828103825260228152602001806120196022913960400191505060405180910390fd5b6001600160a01b038084166000818152600f6020908152604080832094871680845294825291829020859055815185815291517f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259281900390910190a3505050565b6000808211611b2c576040805162461bcd60e51b815260206004820152601860248201527f536166654d6174683a206d6f64756c6f206279207a65726f0000000000000000604482015290519081900360640190fd5b818381611b3557fe5b069392505050565b6001600160a01b038316611b825760405162461bcd60e51b81526004018080602001828103825260258152602001806121f46025913960400191505060405180910390fd5b6001600160a01b038216611bc75760405162461bcd60e51b8152600401808060200182810382526023815260200180611f7c6023913960400191505060405180910390fd5b611bd2838383611418565b611c158160405180606001604052806026815260200161205f602691396001600160a01b0386166000908152600e6020526040902054919063ffffffff61154c16565b6001600160a01b038085166000908152600e60205260408082209390935590841681522054611c4a908263ffffffff6115e316565b6001600160a01b038084166000818152600e602090815260409182902094909455805185815290519193928716927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef92918290030190a3505050565b6001600160a01b038216611d01576040805162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f206164647265737300604482015290519081900360640190fd5b611d0d60008383611418565b600454611d20908263ffffffff6115e316565b6004556001600160a01b0382166000908152600e6020526040902054611d4c908263ffffffff6115e316565b6001600160a01b0383166000818152600e602090815260408083209490945583518581529351929391927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9281900390910190a35050565b600654811015611de55760405162461bcd60e51b815260040180806020018281038252602d815260200180611fca602d913960400191505060405180910390fd5b600754811115611e265760405162461bcd60e51b815260040180806020018281038252602f81526020018061236d602f913960400191505060405180910390fd5b611e308282611e73565b6040805182815290516001600160a01b038416917fcc16f5dbb4873280815c1ee09dbd06736cffcc184412cf7a71a0fdb75d397ca5919081900360200190a25050565b6001600160a01b038216611eb85760405162461bcd60e51b81526004018080602001828103825260218152602001806121d36021913960400191505060405180910390fd5b611ec482600083611418565b611f0781604051806060016040528060228152602001611ff7602291396001600160a01b0385166000908152600e6020526040902054919063ffffffff61154c16565b6001600160a01b0383166000908152600e6020526040902055600454611f33908263ffffffff61198d16565b6004556040805182815290516000916001600160a01b038516917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9181900360200190a3505056fe45524332303a207472616e7366657220746f20746865207a65726f20616464726573735472756543757272656e63793a20746f6b656e73207370656e64657220697320626c61636b6c69737465644275726e61626c65546f6b656e57697468426f756e64733a2062656c6f77206d696e206275726e20626f756e6445524332303a206275726e20616d6f756e7420657863656564732062616c616e636545524332303a20617070726f766520746f20746865207a65726f20616464726573735472756543757272656e63793a206163636f756e7420697320626c61636b6c697374656445524332303a207472616e7366657220616d6f756e7420657863656564732062616c616e63655472756543757272656e63793a20746f6b656e73206f776e657220697320626c61636b6c69737465645472756543757272656e63793a20726563697069656e7420697320626c61636b6c69737465645472756543757272656e63793a20696e76616c696420506f52207570646174656441745472756543757272656e63793a20636861696e5265736572766546656564206e6f74207365744275726e61626c65546f6b656e57697468426f756e64733a206d696e203e206d617845524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e63655472756543757272656e63793a206163636f756e74206973206120726564656d7074696f6e20616464726573735472756543757272656e63793a20626c61636b6c697374696e67206f6620726564656d7074696f6e2061646472657373206973206e6f7420616c6c6f77656445524332303a206275726e2066726f6d20746865207a65726f206164647265737345524332303a207472616e736665722066726f6d20746865207a65726f20616464726573735472756543757272656e63793a20556e657870656374656420646563696d616c73206f6620506f52206665656445524332303a20617070726f76652066726f6d20746865207a65726f20616464726573735472756543757272656e63793a2073656e64657220697320626c61636b6c69737465645472756543757272656e63793a20636861696e52657365727665486561727462656174206e6f74207365745472756543757272656e63793a2063616e6e6f74206275726e2066726f6d207468697320616464726573735472756543757272656e63793a20746f74616c20737570706c7920776f756c6420657863656564207265736572766573206166746572206d696e7445524332303a2064656372656173656420616c6c6f77616e63652062656c6f77207a65726f5472756543757272656e63793a20496e76616c696420616e737765722066726f6d20506f5220666565644275726e61626c65546f6b656e57697468426f756e64733a2065786365656473206d6178206275726e20626f756e64a2646970667358221220b6177f31b2e97a08840cb7cc499be2a5e85b60f8f9d2f59f217557bc5ff7a15f64736f6c634300060a0033","optimization_enabled":true,"verified_twin_address_hash":null,"is_verified":true,"compiler_settings":{"compilationTarget":{"TrueUSD.sol":"TrueUSD"},"evmVersion":"istanbul","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[]},"optimization_runs":200,"sourcify_repo_url":null,"decoded_constructor_args":null,"compiler_version":"0.6.10+commit.00c0fcaf","is_verified_via_verifier_alliance":true,"verified_at":"2024-07-03T10:06:29.740189Z","implementations":[],"proxy_type":null,"external_libraries":[],"creation_bytecode":"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","name":"TrueUSD","is_blueprint":false,"license_type":"none","is_fully_verified":false,"is_verified_via_eth_bytecode_db":true,"language":"solidity","evm_version":"istanbul","can_be_visualized_via_sol2uml":true,"is_verified_via_sourcify":false,"additional_sources":[],"certified":false,"conflicting_implementations":null,"abi":[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isBlacklisted","type":"bool"}],"name":"Blacklisted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"burner","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_blackListedUser","type":"address"},{"indexed":false,"internalType":"uint256","name":"_balance","type":"uint256"}],"name":"DestroyedBlackFunds","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldFeed","type":"address"},{"indexed":false,"internalType":"address","name":"newFeed","type":"address"}],"name":"NewChainReserveFeed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldHeartbeat","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newHeartbeat","type":"uint256"}],"name":"NewChainReserveHeartbeat","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[],"name":"ProofOfReserveDisabled","type":"event"},{"anonymous":false,"inputs":[],"name":"ProofOfReserveEnabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMin","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newMax","type":"uint256"}],"name":"SetBurnBounds","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"burnMax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnMin","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"canBurn","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"chainReserveFeed","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"chainReserveHeartbeat","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_blackListedUser","type":"address"}],"name":"destroyBlackFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"disableProofOfReserve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"enableProofOfReserve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proofOfReserveEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"_to","type":"address"}],"name":"reclaimEther","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"_to","type":"address"}],"name":"reclaimToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rounding","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"_isBlacklisted","type":"bool"}],"name":"setBlacklisted","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_min","type":"uint256"},{"internalType":"uint256","name":"_max","type":"uint256"}],"name":"setBurnBounds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"_canBurn","type":"bool"}],"name":"setCanBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newFeed","type":"address"}],"name":"setChainReserveFeed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newHeartbeat","type":"uint256"}],"name":"setChainReserveHeartbeat","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}],"is_changed_bytecode":false,"is_partially_verified":true,"constructor_args":null}