Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

 contract ProxyStorage  contract ClaimableOwnable is Proxy ...    - function transferOwnership(address ne ...    - function claimOwnership() interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address sender, ...    - function _msgSender()    - function _msgData() library SafeMath    - function add(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b, st ...    - function mul(uint256 a, uint256 b)    - function div(uint256 a, uint256 b)    - function div(uint256 a, uint256 b, st ...    - function mod(uint256 a, uint256 b)    - function mod(uint256 a, uint256 b, st ... library Address    - function isContract(address account)    - function sendValue(address payable re ...    - function functionCall(address target, ...    - function functionCall(address target, ...    - function functionCallWithValue(addres ...    - function functionCallWithValue(addres ...    - function _functionCallWithValue(addre ...    - function name()    - function symbol()    - function decimals()    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address sender, ...    - function increaseAllowance(address sp ...    - function decreaseAllowance(address sp ...    - function _transfer(address sender, ad ...    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _approve(address owner, addr ...    - function _beforeTokenTransfer(address ...    - function reclaimEther(address payable ...    - function reclaimToken(IERC20 token, a ...    - function burn(uint256 amount)    - function setBurnBounds(uint256 _min, ...    - function _burn(address account, uint2 ...    - function mint(address account, uint25 ...    - function setBlacklisted(address accou ...    - function setCanBurn(address account, ...    - function _transfer(    - function _approve(    - function _burn(address account, uint2 ...    - function isRedemptionAddress(address ...    - function delegateTotalSupply()    - function delegateBalanceOf(address wh ...    - function delegateTransfer(    - function delegateAllowance(address ow ...    - function delegateTransferFrom(    - function delegateApprove(    - function delegateIncreaseApproval(    - function delegateDecreaseApproval(    - function _transfer(    - function requireNotAutosweepAddress(a ...  contract TrueUSD is TrueCurrencyWi ... *    - function decimals()    - function rounding()    - function name()    - function symbol()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-02-23
*/

/**
 *Submitted for verification at Etherscan.io on 2020-09-25
*/

/**
 *  :::==== :::====  :::  === :::===== :::  === :::===  :::====
 *  :::==== :::  === :::  === :::      :::  === :::     :::  ===
 *    ===   =======  ===  === ======   ===  ===  =====  ===  ===
 *    ===   === ===  ===  === ===      ===  ===     === ===  ===
 *    ===   ===  ===  ======  ========  ======  ======  =======
 */

pragma solidity 0.6.10;

/**
 * Defines the storage layout of the token implementation contract. Any
 * newly declared state variables in future upgrades should be appended
 * to the bottom. Never remove state variables from this list, however variables
 * can be renamed. Please add _Deprecated to deprecated variables.
 */
contract ProxyStorage {
    address public owner;
    address public pendingOwner;

    bool initialized;

    address balances_Deprecated;
    address allowances_Deprecated;

    uint256 _totalSupply;

    bool private paused_Deprecated = false;
    address private globalPause_Deprecated;

    uint256 public burnMin = 0;
    uint256 public burnMax = 0;

    address registry_Deprecated;

    string name_Deprecated;
    string symbol_Deprecated;

    uint256[] gasRefundPool_Deprecated;
    uint256 private redemptionAddressCount_Deprecated;
    uint256 minimumGasPriceForFutureRefunds_Deprecated;

    mapping(address => uint256) _balances;
    mapping(address => mapping(address => uint256)) _allowances;
    mapping(bytes32 => mapping(address => uint256)) attributes_Deprecated;

    // reward token storage
    mapping(address => address) finOps_Deprecated;
    mapping(address => mapping(address => uint256)) finOpBalances_Deprecated;
    mapping(address => uint256) finOpSupply_Deprecated;

    // true reward allocation
    // proportion: 1000 = 100%
    struct RewardAllocation {
        uint256 proportion;
        address finOp;
    }
    mapping(address => RewardAllocation[]) _rewardDistribution_Deprecated;
    uint256 maxRewardProportion_Deprecated = 1000;

    mapping(address => bool) isBlacklisted;
    mapping(address => bool) public canBurn;

    /* Additionally, we have several keccak-based storage locations.
     * If you add more keccak-based storage mappings, such as mappings, you must document them here.
     * If the length of the keccak input is the same as an existing mapping, it is possible there could be a preimage collision.
     * A preimage collision can be used to attack the contract by treating one storage location as another,
     * which would always be a critical issue.
     * Carefully examine future keccak-based storage to ensure there can be no preimage collisions.
     *******************************************************************************************************
     ** length     input                                                         usage
     *******************************************************************************************************
     ** 19         "trueXXX.proxy.owner"                                         Proxy Owner
     ** 27         "trueXXX.pending.proxy.owner"                                 Pending Proxy Owner
     ** 28         "trueXXX.proxy.implementation"                                Proxy Implementation
     ** 32         uint256(11)                                                   gasRefundPool_Deprecated
     ** 64         uint256(address),uint256(14)                                  balanceOf
     ** 64         uint256(address),keccak256(uint256(address),uint256(15))      allowance
     ** 64         uint256(address),keccak256(bytes32,uint256(16))               attributes
     **/
}

pragma solidity 0.6.10;

/**
 * @title ClamableOwnable
 * @dev The ClamableOwnable contract is a copy of Claimable Contract by Zeppelin.
 * and provides basic authorization control functions. Inherits storage layout of
 * ProxyStorage.
 */
contract ClaimableOwnable is ProxyStorage {
    /**
     * @dev emitted when ownership is transferred
     * @param previousOwner previous owner of this contract
     * @param newOwner new owner of this contract
     */
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev sets the original `owner` of the contract to the sender
     * at construction. Must then be reinitialized
     */
    constructor() public {
        owner = msg.sender;
        emit OwnershipTransferred(address(0), owner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(msg.sender == owner, "only Owner");
        _;
    }

    /**
     * @dev Modifier throws if called by any account other than the pendingOwner.
     */
    modifier onlyPendingOwner() {
        require(msg.sender == pendingOwner, "only pending owner");
        _;
    }

    /**
     * @dev Allows the current owner to set the pendingOwner address.
     * @param newOwner The address to transfer ownership to.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        pendingOwner = newOwner;
    }

    /**
     * @dev Allows the pendingOwner address to finalize the transfer.
     */
    function claimOwnership() public onlyPendingOwner {
        emit OwnershipTransferred(owner, pendingOwner);
        owner = pendingOwner;
        pendingOwner = address(0);
    }
}

pragma solidity ^0.6.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

pragma solidity ^0.6.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

pragma solidity ^0.6.2;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

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

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

/**
 * @notice This is a copy of openzeppelin ERC20 contract with removed state variables.
 * Removing state variables has been necessary due to proxy pattern usage.
 * Changes to Openzeppelin ERC20 https://github.com/OpenZeppelin/openzeppelin-contracts/blob/de99bccbfd4ecd19d7369d01b070aa72c64423c9/contracts/token/ERC20/ERC20.sol:
 * - Remove state variables _name, _symbol, _decimals
 * - Use state variables _balances, _allowances, _totalSupply from ProxyStorage
 * - Remove constructor
 * - Solidity version changed from ^0.6.0 to 0.6.10
 * - Contract made abstract
 *
 * See also: ClaimableOwnable.sol and ProxyStorage.sol
 */

pragma solidity 0.6.10;

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
abstract contract ERC20 is ClaimableOwnable, Context, IERC20 {
    using SafeMath for uint256;
    using Address for address;

    /**
     * @dev Returns the name of the token.
     */
    function name() public virtual pure returns (string memory);

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public virtual pure returns (string memory);

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
     * called.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public virtual pure returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    // solhint-disable-next-line no-empty-blocks
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}

pragma solidity 0.6.10;

/**
 * @title ReclaimerToken
 * @dev ERC20 token which allows owner to reclaim ERC20 tokens
 * or ether sent to this contract
 */
abstract contract ReclaimerToken is ERC20 {
    /**
     * @dev send all eth balance in the contract to another address
     * @param _to address to send eth balance to
     */
    function reclaimEther(address payable _to) external onlyOwner {
        _to.transfer(address(this).balance);
    }

    /**
     * @dev send all token balance of an arbitrary erc20 token
     * in the contract to another address
     * @param token token to reclaim
     * @param _to address to send eth balance to
     */
    function reclaimToken(IERC20 token, address _to) external onlyOwner {
        uint256 balance = token.balanceOf(address(this));
        token.transfer(_to, balance);
    }
}

pragma solidity 0.6.10;

/**
 * @title BurnableTokenWithBounds
 * @dev Burning functions as redeeming money from the system.
 * The platform will keep track of who burns coins,
 * and will send them back the equivalent amount of money (rounded down to the nearest cent).
 */
abstract contract BurnableTokenWithBounds is ReclaimerToken {
    /**
     * @dev Emitted when `value` tokens are burnt from one account (`burner`)
     * @param burner address which burned tokens
     * @param value amount of tokens burned
     */
    event Burn(address indexed burner, uint256 value);

    /**
     * @dev Emitted when new burn bounds were set
     * @param newMin new minimum burn amount
     * @param newMax new maximum burn amount
     * @notice `newMin` should never be greater than `newMax`
     */
    event SetBurnBounds(uint256 newMin, uint256 newMax);

    /**
     * @dev Destroys `amount` tokens from `msg.sender`, reducing the
     * total supply.
     * @param amount amount of tokens to burn
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     * Emits a {Burn} event with `burner` set to `msg.sender`
     *
     * Requirements
     *
     * - `msg.sender` must have at least `amount` tokens.
     *
     */
    function burn(uint256 amount) external {
        _burn(msg.sender, amount);
    }

    /**
     * @dev Change the minimum and maximum amount that can be burned at once.
     * Burning may be disabled by setting both to 0 (this will not be done
     * under normal operation, but we can't add checks to disallow it without
     * losing a lot of flexibility since burning could also be as good as disabled
     * by setting the minimum extremely high, and we don't want to lock
     * in any particular cap for the minimum)
     * @param _min minimum amount that can be burned at once
     * @param _max maximum amount that can be burned at once
     */
    function setBurnBounds(uint256 _min, uint256 _max) external onlyOwner {
        require(_min <= _max, "BurnableTokenWithBounds: min > max");
        burnMin = _min;
        burnMax = _max;
        emit SetBurnBounds(_min, _max);
    }

    /**
     * @dev Checks if amount is within allowed burn bounds and
     * destroys `amount` tokens from `account`, reducing the
     * total supply.
     * @param account account to burn tokens for
     * @param amount amount of tokens to burn
     *
     * Emits a {Burn} event
     */
    function _burn(address account, uint256 amount) internal virtual override {
        require(amount >= burnMin, "BurnableTokenWithBounds: below min burn bound");
        require(amount <= burnMax, "BurnableTokenWithBounds: exceeds max burn bound");

        super._burn(account, amount);
        emit Burn(account, amount);
    }
}

pragma solidity 0.6.10;

/**
 * @title TrueCurrency
 * @dev TrueCurrency is an ERC20 with blacklist & redemption addresses
 *
 * TrueCurrency is a compliant stablecoin with blacklist and redemption
 * addresses. Only the owner can blacklist accounts. Redemption addresses
 * are assigned automatically to the first 0x100000 addresses. Sending
 * tokens to the redemption address will trigger a burn operation. Only
 * the owner can mint or blacklist accounts.
 *
 * This contract is owned by the TokenController, which manages token
 * minting & admin functionality. See TokenController.sol
 *
 * See also: BurnableTokenWithBounds.sol
 *
 * ~~~~ Features ~~~~
 *
 * Redemption Addresses
 * - The first 0x100000 addresses are redemption addresses
 * - Tokens sent to redemption addresses are burned
 * - Redemptions are tracked off-chain
 * - Cannot mint tokens to redemption addresses
 *
 * Blacklist
 * - Owner can blacklist accounts in accordance with local regulatory bodies
 * - Only a court order will merit a blacklist; blacklisting is extremely rare
 *
 * Burn Bounds & CanBurn
 * - Owner can set min & max burn amounts
 * - Only accounts flagged in canBurn are allowed to burn tokens
 * - canBurn prevents tokens from being sent to the incorrect address
 *
 * Reclaimer Token
 * - ERC20 Tokens and Ether sent to this contract can be reclaimed by the owner
 */
abstract contract TrueCurrency is BurnableTokenWithBounds {
    uint256 constant CENT = 10**16;
    uint256 constant REDEMPTION_ADDRESS_COUNT = 0x100000;

    /**
     * @dev Emitted when account blacklist status changes
     */
    event Blacklisted(address indexed account, bool isBlacklisted);

    /**
     * @dev Emitted when `value` tokens are minted for `to`
     * @param to address to mint tokens for
     * @param value amount of tokens to be minted
     */
    event Mint(address indexed to, uint256 value);

    /**
     * @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     * @param account address to mint tokens for
     * @param amount amount of tokens to be minted
     *
     * Emits a {Mint} event
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` cannot be blacklisted.
     * - `account` cannot be a redemption address.
     */
    function mint(address account, uint256 amount) external onlyOwner {
        require(!isBlacklisted[account], "TrueCurrency: account is blacklisted");
        require(!isRedemptionAddress(account), "TrueCurrency: account is a redemption address");
        _mint(account, amount);
        emit Mint(account, amount);
    }

    /**
     * @dev Set blacklisted status for the account.
     * @param account address to set blacklist flag for
     * @param _isBlacklisted blacklist flag value
     *
     * Requirements:
     *
     * - `msg.sender` should be owner.
     */
    function setBlacklisted(address account, bool _isBlacklisted) external onlyOwner {
        require(uint256(account) >= REDEMPTION_ADDRESS_COUNT, "TrueCurrency: blacklisting of redemption address is not allowed");
        isBlacklisted[account] = _isBlacklisted;
        emit Blacklisted(account, _isBlacklisted);
    }

    /**
     * @dev Set canBurn status for the account.
     * @param account address to set canBurn flag for
     * @param _canBurn canBurn flag value
     *
     * Requirements:
     *
     * - `msg.sender` should be owner.
     */
    function setCanBurn(address account, bool _canBurn) external onlyOwner {
        canBurn[account] = _canBurn;
    }

    /**
     * @dev Check if neither account is blacklisted before performing transfer
     * If transfer recipient is a redemption address, burns tokens
     * @notice Transfer to redemption address will burn tokens with a 1 cent precision
     * @param sender address of sender
     * @param recipient address of recipient
     * @param amount amount of tokens to transfer
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual override {
        require(!isBlacklisted[sender], "TrueCurrency: sender is blacklisted");
        require(!isBlacklisted[recipient], "TrueCurrency: recipient is blacklisted");

        if (isRedemptionAddress(recipient)) {
            super._transfer(sender, recipient, amount.sub(amount.mod(CENT)));
            _burn(recipient, amount.sub(amount.mod(CENT)));
        } else {
            super._transfer(sender, recipient, amount);
        }
    }

    /**
     * @dev Requere neither accounts to be blacklisted before approval
     * @param owner address of owner giving approval
     * @param spender address of spender to approve for
     * @param amount amount of tokens to approve
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal override {
        require(!isBlacklisted[owner], "TrueCurrency: tokens owner is blacklisted");
        require(!isBlacklisted[spender] || amount == 0, "TrueCurrency: tokens spender is blacklisted");

        super._approve(owner, spender, amount);
    }

    /**
     * @dev Check if tokens can be burned at address before burning
     * @param account account to burn tokens from
     * @param amount amount of tokens to burn
     */
    function _burn(address account, uint256 amount) internal override {
        require(canBurn[account], "TrueCurrency: cannot burn from this address");
        super._burn(account, amount);
    }

    /**
     * @dev First 0x100000-1 addresses (0x0000000000000000000000000000000000000001 to 0x00000000000000000000000000000000000fffff)
     * are the redemption addresses.
     * @param account address to check is a redemption address
     *
     * All transfers to redemption address will trigger token burn.
     *
     * @notice For transfer to succeed, canBurn must be true for redemption address
     *
     * @return is `account` a redemption address
     */
    function isRedemptionAddress(address account) internal pure returns (bool) {
        return uint256(account) < REDEMPTION_ADDRESS_COUNT && uint256(account) != 0;
    }
}

pragma solidity 0.6.10;

/**
 * @title DelegateERC20
 * Accept forwarding delegation calls from the old TrueUSD (V1) contract.
 * This way the all the ERC20 functions in the old contract still works
 * (except Burn).
 *
 * The original contract is at 0x8dd5fbCe2F6a956C3022bA3663759011Dd51e73E.
 * Lines 497-574 on-chain call these delegate functions to forward calls
 * This gives the delegate contract the power to change the state of the TrueUSD
 * contract. The owner of this contract is the TrueUSD TokenController
 * at 0x0000000000075efbee23fe2de1bd0b7690883cc9.
 *
 * Our audits for TrueCurrency can be found here: github.com/trusttoken/audits
 */
abstract contract DelegateERC20 is TrueCurrency {
    // require msg.sender is the delegate smart contract
    modifier onlyDelegateFrom() {
        revert("DelegateERC20: TrueUSD (V1) is not supported");
        _;
    }

    /**
     * @dev Delegate call to get total supply
     * @return Total supply
     */
    function delegateTotalSupply() public view returns (uint256) {
        return totalSupply();
    }

    /**
     * @dev Delegate call to get balance
     * @param who Address to get balance for
     * @return balance of account
     */
    function delegateBalanceOf(address who) public view returns (uint256) {
        return balanceOf(who);
    }

    /**
     * @dev Delegate call to transfer
     * @param to address to transfer to
     * @param value amount to transfer
     * @param origSender original msg.sender on delegate contract
     * @return success
     */
    function delegateTransfer(
        address to,
        uint256 value,
        address origSender
    ) public onlyDelegateFrom returns (bool) {
        _transfer(origSender, to, value);
        return true;
    }

    /**
     * @dev Delegate call to get allowance
     * @param owner account owner
     * @param spender account to check allowance for
     * @return allowance
     */
    function delegateAllowance(address owner, address spender) public view returns (uint256) {
        return allowance(owner, spender);
    }

    /**
     * @dev Delegate call to transfer from
     * @param from account to transfer funds from
     * @param to account to transfer funds to
     * @param value value to transfer
     * @param origSender original msg.sender on delegate contract
     * @return success
     */
    function delegateTransferFrom(
        address from,
        address to,
        uint256 value,
        address origSender
    ) public onlyDelegateFrom returns (bool) {
        // ERC20 transferFrom with _msgSender() replaced by origSender
        _transfer(from, to, value);
        _approve(from, origSender, _allowances[from][origSender].sub(value, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Delegate call to approve
     * @param spender account to approve for
     * @param value amount to approve
     * @param origSender original msg.sender on delegate contract
     * @return success
     */
    function delegateApprove(
        address spender,
        uint256 value,
        address origSender
    ) public onlyDelegateFrom returns (bool) {
        _approve(origSender, spender, value);
        return true;
    }

    /**
     * @dev Delegate call to increase approval
     * @param spender account to increase approval for
     * @param addedValue amount of approval to add
     * @param origSender original msg.sender on delegate contract
     * @return success
     */
    function delegateIncreaseApproval(
        address spender,
        uint256 addedValue,
        address origSender
    ) public onlyDelegateFrom returns (bool) {
        // ERC20 increaseAllowance() with _msgSender() replaced by origSender
        _approve(origSender, spender, _allowances[origSender][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Delegate call to decrease approval
     * @param spender spender to decrease approval for
     * @param subtractedValue value to subtract from approval
     * @param origSender original msg.sender on delegate contract
     * @return success
     */
    function delegateDecreaseApproval(
        address spender,
        uint256 subtractedValue,
        address origSender
    ) public onlyDelegateFrom returns (bool) {
        // ERC20 decreaseAllowance() with _msgSender() replaced by origSender
        _approve(origSender, spender, _allowances[origSender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }
}

pragma solidity 0.6.10;

/**
 * @dev Contract that prevents addresses that were previously using autosweep addresses from
 * making transfers on them.
 *
 * In older versions TrueCurrencies had a feature called Autosweep.
 * Given a single deposit address, it was possible to generate 16^5-1 autosweep addresses.
 * E.g. having deposit address 0xc257274276a4e539741ca11b590b9447b26a8051, you could generate
 * - 0xc257274276a4e539741ca11b590b9447b2600000
 * - 0xc257274276a4e539741ca11b590b9447b2600001
 * - ...
 * - 0xc257274276a4e539741ca11b590b9447b26fffff
 * Every transfer to an autosweep address resulted as a transfer to deposit address.
 * This feature got deprecated, but there were 4 addresses that still actively using the feature.
 *
 * This contract will reject a transfer to these 4*(16^5-1) addresses to prevent accidental token freeze.
 */
abstract contract TrueCurrencyWithLegacyAutosweep is DelegateERC20 {
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal override {
        requireNotAutosweepAddress(recipient, 0x33091DE8341533468D13A80C5A670f4f47cC649f);
        requireNotAutosweepAddress(recipient, 0x50E2719208914764087e68C32bC5AaC321f5B04d);
        requireNotAutosweepAddress(recipient, 0x71d69e5481A9B7Be515E20B38a3f62Dab7170D78);
        requireNotAutosweepAddress(recipient, 0x90fdaA85D52dB6065D466B86f16bF840D514a488);

        super._transfer(sender, recipient, amount);
    }

    function requireNotAutosweepAddress(address recipient, address depositAddress) internal pure {
        return
          require(uint256(recipient) >> 20 != uint256(depositAddress) >> 20 || recipient == depositAddress, "Autosweep is disabled");
    }
}

pragma solidity 0.6.10;

/**
 * @title TrueUSD
 * @dev This is the top-level ERC20 contract, but most of the interesting functionality is
 * inherited - see the documentation on the corresponding contracts.
 */
contract TrueUSD is TrueCurrencyWithLegacyAutosweep {
    uint8 constant DECIMALS = 18;
    uint8 constant ROUNDING = 2;

    function decimals() public override pure returns (uint8) {
        return DECIMALS;
    }

    function rounding() public pure returns (uint8) {
        return ROUNDING;
    }

    function name() public override pure returns (string memory) {
        return "TrueUSD";
    }

    function symbol() public override pure returns (string memory) {
        return "TUSD";
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"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":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"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":"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":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"delegateAllowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"address","name":"origSender","type":"address"}],"name":"delegateApprove","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"who","type":"address"}],"name":"delegateBalanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"},{"internalType":"address","name":"origSender","type":"address"}],"name":"delegateDecreaseApproval","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"},{"internalType":"address","name":"origSender","type":"address"}],"name":"delegateIncreaseApproval","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"delegateTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"address","name":"origSender","type":"address"}],"name":"delegateTransfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"address","name":"origSender","type":"address"}],"name":"delegateTransferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":[{"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":[],"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"}]

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

47858:521:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1054:26;;;:::i;:::-;;;;;;;;;;;;;;;;48177:96;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24817:169;;;;;;;;;;;;;;;;-1:-1:-1;24817:169:0;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;43191:140;;;;;;;;;;;;;;;;-1:-1:-1;43191:140:0;;;;;;;;;;;:::i;23770:108::-;;;:::i;25460:321::-;;;;;;;;;;;;;;;;-1:-1:-1;25460:321:0;;;;;;;;;;;;;;;;;;:::i;44304:227::-;;;;;;;;;;;;;;;;-1:-1:-1;44304:227:0;;;;;;;;;;;;;;;;;;:::i;48087:82::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;47988:91;;;:::i;2112:39::-;;;;;;;;;;;;;;;;-1:-1:-1;2112:39:0;;;;:::i;26190:218::-;;;;;;;;;;;;;;;;-1:-1:-1;26190:218:0;;;;;;;;;:::i;37252:325::-;;;;;;;;;;;;;;;;-1:-1:-1;37252:325:0;;;;;;;;;:::i;:::-;;33306:83;;;;;;;;;;;;;;;;-1:-1:-1;33306:83:0;;:::i;42440:110::-;;;;;;;;;;;;;;;;-1:-1:-1;42440:110:0;;;;:::i;43629:435::-;;;;;;;;;;;;;;;;-1:-1:-1;43629:435:0;;;;;;;;;;;;;;;;;;;;;;;:::i;5316:182::-;;;:::i;33977:239::-;;;;;;;;;;;;;;;;-1:-1:-1;33977:239:0;;;;;;;:::i;1087:26::-;;;:::i;23941:127::-;;;;;;;;;;;;;;;;-1:-1:-1;23941:127:0;;;;:::i;42191:100::-;;;:::i;38415:117::-;;;;;;;;;;;;;;;;-1:-1:-1;38415:117:0;;;;;;;;;;;:::i;31841:174::-;;;;;;;;;;;;;;;;-1:-1:-1;31841:174:0;;;;;;;;;;;:::i;773:20::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;48281:95;;;:::i;31504:116::-;;;;;;;;;;;;;;;;-1:-1:-1;31504:116:0;;;;:::i;26911:269::-;;;;;;;;;;;;;;;;-1:-1:-1;26911:269:0;;;;;;;;;:::i;24281:175::-;;;;;;;;;;;;;;;;-1:-1:-1;24281:175:0;;;;;;;;;:::i;37842:322::-;;;;;;;;;;;;;;;;-1:-1:-1;37842:322:0;;;;;;;;;;;:::i;24519:151::-;;;;;;;;;;;;;;;;-1:-1:-1;24519:151:0;;;;;;;;;;;:::i;800:27::-;;;:::i;5115:104::-;;;;;;;;;;;;;;;;-1:-1:-1;5115:104:0;;;;:::i;1054:26::-;;;;:::o;48177:96::-;48249:16;;;;;;;;;;;;;;;;;48177:96;:::o;24817:169::-;24900:4;24917:39;24926:12;:10;:12::i;:::-;24940:7;24949:6;24917:8;:39::i;:::-;-1:-1:-1;24974:4:0;24817:169;;;;:::o;43191:140::-;43271:7;43298:25;43308:5;43315:7;43298:9;:25::i;:::-;43291:32;43191:140;-1:-1:-1;;;43191:140:0:o;23770:108::-;23858:12;;23770:108;:::o;25460:321::-;25566:4;25583:36;25593:6;25601:9;25612:6;25583:9;:36::i;:::-;25630:121;25639:6;25647:12;:10;:12::i;:::-;25661:89;25699:6;25661:89;;;;;;;;;;;;;;;;;:19;;;;;;;:11;:19;;;;;;25681:12;:10;:12::i;:::-;25661:33;;;;;;;;;;;;;-1:-1:-1;25661:33:0;;;:89;;:37;:89;:::i;:::-;25630:8;:121::i;:::-;-1:-1:-1;25769:4:0;25460:321;;;;;:::o;44304:227::-;44448:4;42015:54;;-1:-1:-1;;;42015:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48087:82;47978:1;48087:82;:::o;47988:91::-;47943:2;47988:91;:::o;2112:39::-;;;;;;;;;;;;;;;:::o;26190:218::-;26278:4;26295:83;26304:12;:10;:12::i;:::-;26318:7;26327:50;26366:10;26327:11;:25;26339:12;:10;:12::i;:::-;26327:25;;;;;;;;;;;;;;;;;;-1:-1:-1;26327:25:0;;;:34;;;;;;;;;;;:50;:38;:50;:::i;37252:325::-;4691:5;;;;4677:10;:19;4669:42;;;;;-1:-1:-1;;;4669:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;37338:22:::1;::::0;::::1;;::::0;;;:13:::1;:22;::::0;;;;;::::1;;37337:23;37329:72;;;;-1:-1:-1::0;;;37329:72:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37421:28;37441:7;37421:19;:28::i;:::-;37420:29;37412:87;;;;-1:-1:-1::0;;;37412:87:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37510:22;37516:7;37525:6;37510:5;:22::i;:::-;37548:21;::::0;;;;;;;::::1;::::0;::::1;::::0;::::1;::::0;;;;;::::1;::::0;;::::1;37252:325:::0;;:::o;33306:83::-;33356:25;33362:10;33374:6;33356:5;:25::i;:::-;33306:83;:::o;42440:110::-;42501:7;42528:14;42538:3;42528:9;:14::i;:::-;42521:21;42440:110;-1:-1:-1;;42440:110:0:o;5316:182::-;4901:12;;;;4887:10;:26;4879:57;;;;;-1:-1:-1;;;4879:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;5410:12:::1;::::0;::::1;5403:5:::0;;5382:41:::1;::::0;5410:12:::1;::::0;;::::1;::::0;5403:5;;::::1;::::0;5382:41:::1;::::0;::::1;5442:12;::::0;;::::1;5434:20:::0;;;;;::::1;5442:12;::::0;::::1;5434:20;::::0;;;5465:25:::1;::::0;;5316:182::o;33977:239::-;4691:5;;;;4677:10;:19;4669:42;;;;;-1:-1:-1;;;4669:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;34074:4:::1;34066;:12;;34058:59;;;;-1:-1:-1::0;;;34058:59:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34128:7;:14:::0;;;34153:7:::1;:14:::0;;;34183:25:::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;::::1;::::0;;;;;;;;;::::1;33977:239:::0;;:::o;1087:26::-;;;;:::o;23941:127::-;24042:18;;24015:7;24042:18;;;:9;:18;;;;;;;23941:127::o;42191:100::-;42243:7;42270:13;:11;:13::i;:::-;42263:20;;42191:100;:::o;38415:117::-;4691:5;;;;4677:10;:19;4669:42;;;;;-1:-1:-1;;;4669:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;38497:16:::1;::::0;;;::::1;;::::0;;;:7:::1;:16;::::0;;;;:27;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;38415:117::o;31841:174::-;4691:5;;;;4677:10;:19;4669:42;;;;;-1:-1:-1;;;4669:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;31938:30:::1;::::0;;;;;31962:4:::1;31938:30;::::0;::::1;::::0;;;31920:15:::1;::::0;31938::::1;::::0;::::1;::::0;::::1;::::0;:30;;;;;::::1;::::0;;;;;;;;;:15;:30;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;31938:30:0;31979:28:::1;::::0;;;;;:14:::1;:28:::0;;::::1;;::::0;::::1;::::0;;;;;;;;;31938:30;;-1:-1:-1;31979:14:0;;::::1;::::0;::::1;::::0;:28;;;;;31938:30:::1;::::0;31979:28;;;;;;;;-1:-1:-1;31979:14:0;:28;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;;;;;31841:174:0:o;773:20::-;;;;;;:::o;48281:95::-;48355:13;;;;;;;;;;;;;;;;;48281:95;:::o;31504:116::-;4691:5;;;;4677:10;:19;4669:42;;;;;-1:-1:-1;;;4669:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;31577:35:::1;::::0;:12:::1;::::0;::::1;::::0;31590:21:::1;31577:35:::0;::::1;;;::::0;::::1;::::0;;;31590:21;31577:12;:35;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;31504:116:::0;:::o;26911:269::-;27004:4;27021:129;27030:12;:10;:12::i;:::-;27044:7;27053:96;27092:15;27053:96;;;;;;;;;;;;;;;;;:11;:25;27065:12;:10;:12::i;:::-;27053:25;;;;;;;;;;;;;;;;;;-1:-1:-1;27053:25:0;;;:34;;;;;;;;;;;:96;;:38;:96;:::i;24281:175::-;24367:4;24384:42;24394:12;:10;:12::i;:::-;24408:9;24419:6;24384:9;:42::i;37842:322::-;4691:5;;;;4677:10;:19;4669:42;;;;;-1:-1:-1;;;4669:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;36416:8:::1;37950:7;37942:16;;:44;;37934:120;;;;-1:-1:-1::0;;;37934:120:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38065:22;::::0;::::1;;::::0;;;:13:::1;:22;::::0;;;;;;;;:39;;;::::1;::::0;::::1;;::::0;;::::1;::::0;;;38120:36;;;;;;;::::1;::::0;;;;;;;;::::1;37842:322:::0;;:::o;24519:151::-;24635:18;;;;24608:7;24635:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;24519:151::o;800:27::-;;;;;;:::o;5115:104::-;4691:5;;;;4677:10;:19;4669:42;;;;;-1:-1:-1;;;4669:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;5188:12:::1;:23:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;5115:104::o;8815:106::-;8903:10;8815:106;:::o;39771:368::-;39909:20;;;;;;;:13;:20;;;;;;;;39908:21;39900:75;;;;-1:-1:-1;;;39900:75:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39995:22;;;;;;;:13;:22;;;;;;;;39994:23;;:38;;-1:-1:-1;40021:11:0;;39994:38;39986:94;;;;-1:-1:-1;;;39986:94:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40093:38;40108:5;40115:7;40124:6;40093:14;:38::i;:::-;39771:368;;;:::o;46820:553::-;46953:81;46980:9;46991:42;46953:26;:81::i;:::-;47045;47072:9;47083:42;47045:26;:81::i;:::-;47137;47164:9;47175:42;47137:26;:81::i;:::-;47229;47256:9;47267:42;47229:26;:81::i;:::-;47323:42;47339:6;47347:9;47358:6;47323:15;:42::i;10939:192::-;11025:7;11061:12;11053:6;;;;11045:29;;;;-1:-1:-1;;;11045:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;11097:5:0;;;10939:192::o;10036:181::-;10094:7;10126:5;;;10150:6;;;;10142:46;;;;;-1:-1:-1;;;10142:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;41015:169;41084:4;36416:8;41116:7;41108:16;;:43;:68;;;;-1:-1:-1;;41155:16:0;;:21;;;41015:169::o;28490:378::-;28574:21;;;28566:65;;;;;-1:-1:-1;;;28566:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;28644:49;28673:1;28677:7;28686:6;28644:20;:49::i;:::-;28721:12;;:24;;28738:6;28721:24;:16;:24;:::i;:::-;28706:12;:39;28777:18;;;;;;;:9;:18;;;;;;:30;;28800:6;28777:30;:22;:30;:::i;:::-;28756:18;;;;;;;:9;:18;;;;;;;;:51;;;;28823:37;;;;;;;28756:18;;;;28823:37;;;;;;;;;;28490:378;;:::o;40332:196::-;40417:16;;;;;;;:7;:16;;;;;;;;40409:72;;;;-1:-1:-1;;;40409:72:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40492:28;40504:7;40513:6;40492:11;:28::i;30058:346::-;30160:19;;;30152:68;;;;-1:-1:-1;;;30152:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30239:21;;;30231:68;;;;-1:-1:-1;;;30231:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30312:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;30364:32;;;;;;;;;;;;;;;;;30058:346;;;:::o;47381:252::-;47566:2;47547:14;47539:23;;:29;;47533:2;47519:9;47511:18;;:24;;:57;;:88;;;;47585:14;47572:27;;:9;:27;;;47511:88;47503:122;;;;;-1:-1:-1;;;47503:122:0;;;;;;;;;;;;;;;;;;;;;;;;;;;38931:581;39081:21;;;;;;;:13;:21;;;;;;;;39080:22;39072:70;;;;-1:-1:-1;;;39072:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39162:24;;;;;;;:13;:24;;;;;;;;39161:25;39153:76;;;;-1:-1:-1;;;39153:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39246:30;39266:9;39246:19;:30::i;:::-;39242:263;;;39293:64;39309:6;39317:9;39328:28;39339:16;:6;36359;39339:16;:10;:16;:::i;:::-;39328:6;;:28;:10;:28;:::i;:::-;39293:15;:64::i;:::-;39372:46;39378:9;39389:28;39400:16;:6;36359;39400:16;:10;:16;:::i;:::-;39389:6;;:28;:10;:28;:::i;:::-;39372:5;:46::i;:::-;39242:263;;;39451:42;39467:6;39475:9;39486:6;39451:15;:42::i;34524:334::-;34627:7;;34617:6;:17;;34609:75;;;;-1:-1:-1;;;34609:75:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34713:7;;34703:6;:17;;34695:77;;;;-1:-1:-1;;;34695:77:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34785:28;34797:7;34806:6;34785:11;:28::i;:::-;34829:21;;;;;;;;;;;;;;;;;;;;;;34524:334;;:::o;13708:130::-;13766:7;13793:37;13797:1;13800;13793:37;;;;;;;;;;;;;;;;;:3;:37::i;10500:136::-;10558:7;10585:43;10589:1;10592;10585:43;;;;;;;;;;;;;;;;;:3;:43::i;27670:539::-;27776:20;;;27768:70;;;;-1:-1:-1;;;27768:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27857:23;;;27849:71;;;;-1:-1:-1;;;27849:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27933:47;27954:6;27962:9;27973:6;27933:20;:47::i;:::-;28013:71;28035:6;28013:71;;;;;;;;;;;;;;;;;:17;;;;;;;:9;:17;;;;;;;:71;;:21;:71;:::i;:::-;27993:17;;;;;;;;:9;:17;;;;;;:91;;;;28118:20;;;;;;;:32;;28143:6;28118:32;:24;:32;:::i;:::-;28095:20;;;;;;;;:9;:20;;;;;;;;;:55;;;;28166:35;;;;;;;28095:20;;28166:35;;;;;;;;;;;;;27670:539;;;:::o;29200:418::-;29284:21;;;29276:67;;;;-1:-1:-1;;;29276:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29356:49;29377:7;29394:1;29398:6;29356:20;:49::i;:::-;29439:68;29462:6;29439:68;;;;;;;;;;;;;;;;;:18;;;;;;;:9;:18;;;;;;;:68;;:22;:68;:::i;:::-;29418:18;;;;;;;:9;:18;;;;;:89;29533:12;;:24;;29550:6;29533:24;:16;:24;:::i;:::-;29518:12;:39;29573:37;;;;;;;;29599:1;;29573:37;;;;;;;;;;;;;29200:418;;:::o;14323:166::-;14409:7;14445:12;14437:6;14429:29;;;;-1:-1:-1;;;14429:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14480:1;14476;:5;;;;;;;14323:166;-1:-1:-1;;;;14323:166:0:o

ipfs://7d1c009fdf9b090c8909e4e1e27806a03c8b87c695de6c5887a311a432beae53