Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
0x60806040 | 10730308 | 1415 days ago | IN | Create: TrueAUD | 0 ETH | 0.22360083 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
TrueAUD
Compiler Version
v0.6.10+commit.00c0fcaf
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2020-08-25 */ // File: contracts/true-currencies-new/ProxyStorage.sol pragma solidity 0.6.10; // solhint-disable max-states-count, var-name-mixedcase /** * 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 **/ } // File: contracts/true-currencies-new/ClaimableOwnable.sol 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); } } // File: @openzeppelin/contracts/token/ERC20/IERC20.sol 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); } // File: @openzeppelin/contracts/GSN/Context.sol 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; } } // File: @openzeppelin/contracts/math/SafeMath.sol 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; } } // File: @openzeppelin/contracts/utils/Address.sol 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); } } } } // File: contracts/true-currencies-new/ERC20.sol /** * @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 override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view 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 { } } // File: contracts/true-currencies-new/ReclaimerToken.sol 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); } } // File: contracts/true-currencies-new/BurnableTokenWithBounds.sol 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); } } // File: contracts/true-currencies-new/GasRefund.sol pragma solidity 0.6.10; /** * @title Gas Reclaim Legacy * * Note: this contract does not affect any of the token logic. It merely * exists so the TokenController (owner) can reclaim the sponsored gas * * Previously TrueCurrency has a feature called "gas boost" which allowed * us to sponsor gas by setting non-empty storage slots to 1. * We are depricating this feature, but there is a bunch of gas saved * from years of sponsoring gas. This contract is meant to allow the owner * to take advantage of this leftover gas. Once all the slots are used, * this contract can be removed from TrueCurrency. * * Utilitzes the gas refund mechanism in EVM. Each time an non-empty * storage slot is set to 0, evm will refund 15,000 to the sender. * Also utilized the refund for selfdestruct, see gasRefund39 * */ abstract contract GasRefund { /** * @dev Refund 15,000 gas per slot. * @param amount number of slots to free */ function gasRefund15(uint256 amount) internal { // refund gas assembly { // get number of free slots let offset := sload(0xfffff) // make sure there are enough slots if lt(offset, amount) { amount := offset } if eq(amount, 0) { stop() } let location := add(offset, 0xfffff) let end := sub(location, amount) // loop until amount is reached // i = storage location for { } gt(location, end) { location := sub(location, 1) } { // set storage location to zero // this refunds 15,000 gas sstore(location, 0) } // store new number of free slots sstore(0xfffff, sub(offset, amount)) } } /** * @dev use smart contract self-destruct to refund gas * will refund 39,000 * amount gas */ function gasRefund39(uint256 amount) internal { assembly { // get amount of gas slots let offset := sload(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // make sure there are enough slots if lt(offset, amount) { amount := offset } if eq(amount, 0) { stop() } // first sheep pointer let location := sub(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, offset) // last sheep pointer let end := add(location, amount) for { } lt(location, end) { location := add(location, 1) } { // load sheep address let sheep := sload(location) // call selfdestruct on sheep pop(call(gas(), sheep, 0, 0, 0, 0, 0)) // clear sheep address sstore(location, 0) } sstore(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, sub(offset, amount)) } } /** * @dev Return the remaining sponsored gas slots */ function remainingGasRefundPool() public view returns (uint256 length) { assembly { length := sload(0xfffff) } } /** * @dev Return the remaining sheep slots */ function remainingSheepRefundPool() public view returns (uint256 length) { assembly { length := sload(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) } } } // File: contracts/true-currencies-new/TrueCurrency.sol 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, GasRefund { 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; } /** * @dev reclaim gas from legacy gas refund #1 * will refund 15,000 * amount gas to sender (minus exection cost) * If gas pool is empty, refund 39,000 * amount gas by calling selfdestruct */ function refundGas(uint256 amount) external onlyOwner { if (remainingGasRefundPool() > 0) { gasRefund15(amount); } else { gasRefund39(amount.div(3)); } } } // File: contracts/true-currencies-new/TrueAUD.sol pragma solidity 0.6.10; /** * title TrueAUD * @dev This is the top-level ERC20 contract, but most of the interesting functionality is * inherited - see the documentation on the corresponding contracts. */ contract TrueAUD is TrueCurrency { 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 "TrueAUD"; } function symbol() public override pure returns (string memory) { return "TAUD"; } }
Contract Security Audit
- 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":"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":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"refundGas","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"remainingGasRefundPool","outputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"remainingSheepRefundPool","outputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"stateMutability":"view","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"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
45925:502:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;761:26;;;:::i;:::-;;;;;;;;;;;;;;;;46225:96;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24850:169;;;;;;;;;;;;;;;;-1:-1:-1;24850:169:0;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;45436:211;;;;;;;;;;;;;;;;-1:-1:-1;45436:211:0;;:::i;:::-;;38601:209;;;:::i;23819:100::-;;;:::i;25493:321::-;;;;;;;;;;;;;;;;-1:-1:-1;25493:321:0;;;;;;;;;;;;;;;;;;:::i;46135:82::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;46036:91;;;:::i;1819:39::-;;;;;;;;;;;;;;;;-1:-1:-1;1819:39:0;;;;:::i;26223:218::-;;;;;;;;;;;;;;;;-1:-1:-1;26223:218:0;;;;;;;;;:::i;41274:325::-;;;;;;;;;;;;;;;;-1:-1:-1;41274:325:0;;;;;;;;;:::i;33472:83::-;;;;;;;;;;;;;;;;-1:-1:-1;33472:83:0;;:::i;5088:182::-;;;:::i;34143:239::-;;;;;;;;;;;;;;;;-1:-1:-1;34143:239:0;;;;;;;:::i;794:26::-;;;:::i;23982:119::-;;;;;;;;;;;;;;;;-1:-1:-1;23982:119:0;;;;:::i;42437:117::-;;;;;;;;;;;;;;;;-1:-1:-1;42437:117:0;;;;;;;;;;;:::i;38381:148::-;;;:::i;31937:174::-;;;;;;;;;;;;;;;;-1:-1:-1;31937:174:0;;;;;;;;;;;:::i;480:20::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;46329:95;;;:::i;31600:116::-;;;;;;;;;;;;;;;;-1:-1:-1;31600:116:0;;;;:::i;26944:269::-;;;;;;;;;;;;;;;;-1:-1:-1;26944:269:0;;;;;;;;;:::i;24314:175::-;;;;;;;;;;;;;;;;-1:-1:-1;24314:175:0;;;;;;;;;:::i;41864:322::-;;;;;;;;;;;;;;;;-1:-1:-1;41864:322:0;;;;;;;;;;;:::i;24552:151::-;;;;;;;;;;;;;;;;-1:-1:-1;24552:151:0;;;;;;;;;;;:::i;507:27::-;;;:::i;4887:104::-;;;;;;;;;;;;;;;;-1:-1:-1;4887:104:0;;;;:::i;761:26::-;;;;:::o;46225:96::-;46297:16;;;;;;;;;;;;;;;;;46225:96;:::o;24850:169::-;24933:4;24950:39;24959:12;:10;:12::i;:::-;24973:7;24982:6;24950:8;:39::i;:::-;-1:-1:-1;25007:4:0;24850:169;;;;:::o;45436:211::-;4463:5;;;;4449:10;:19;4441:42;;;;;-1:-1:-1;;;4441:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;45532:1:::1;45505:24;:22;:24::i;:::-;:28;45501:139;;;45550:19;45562:6;45550:11;:19::i;:::-;45501:139;;;45602:26;45614:13;:6:::0;45625:1:::1;45614:13;:10;:13;:::i;:::-;45602:11;:26::i;:::-;45436:211:::0;:::o;38601:209::-;38725:66;38719:73;;38694:109::o;23819:100::-;23899:12;;23819:100;:::o;25493:321::-;25599:4;25616:36;25626:6;25634:9;25645:6;25616:9;:36::i;:::-;25663:121;25672:6;25680:12;:10;:12::i;:::-;25694:89;25732:6;25694:89;;;;;;;;;;;;;;;;;:19;;;;;;;:11;:19;;;;;;25714:12;:10;:12::i;:::-;25694:33;;;;;;;;;;;;;-1:-1:-1;25694:33:0;;;:89;;:37;:89;:::i;:::-;25663:8;:121::i;:::-;-1:-1:-1;25802:4:0;25493:321;;;;;:::o;46135:82::-;46026:1;46135:82;:::o;46036:91::-;45991:2;46036:91;:::o;1819:39::-;;;;;;;;;;;;;;;:::o;26223:218::-;26311:4;26328:83;26337:12;:10;:12::i;:::-;26351:7;26360:50;26399:10;26360:11;:25;26372:12;:10;:12::i;:::-;26360:25;;;;;;;;;;;;;;;;;;-1:-1:-1;26360:25:0;;;:34;;;;;;;;;;;:50;:38;:50;:::i;41274:325::-;4463:5;;;;4449:10;:19;4441:42;;;;;-1:-1:-1;;;4441:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;41360:22:::1;::::0;::::1;;::::0;;;:13:::1;:22;::::0;;;;;::::1;;41359:23;41351:72;;;;-1:-1:-1::0;;;41351:72:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41443:28;41463:7;41443:19;:28::i;:::-;41442:29;41434:87;;;;-1:-1:-1::0;;;41434:87:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41532:22;41538:7;41547:6;41532:5;:22::i;:::-;41570:21;::::0;;;;;;;::::1;::::0;::::1;::::0;::::1;::::0;;;;;::::1;::::0;;::::1;41274:325:::0;;:::o;33472:83::-;33522:25;33528:10;33540:6;33522:5;:25::i;5088:182::-;4673:12;;;;4659:10;:26;4651:57;;;;;-1:-1:-1;;;4651:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;5182:12:::1;::::0;::::1;5175:5:::0;;5154:41:::1;::::0;5182:12:::1;::::0;;::::1;::::0;5175:5;;::::1;::::0;5154:41:::1;::::0;::::1;5214:12;::::0;;::::1;5206:20:::0;;;;;::::1;5214:12;::::0;::::1;5206:20;::::0;;;5237:25:::1;::::0;;5088:182::o;34143:239::-;4463:5;;;;4449:10;:19;4441:42;;;;;-1:-1:-1;;;4441:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;34240:4:::1;34232;:12;;34224:59;;;;-1:-1:-1::0;;;34224:59:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34294:7;:14:::0;;;34319:7:::1;:14:::0;;;34349:25:::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;::::1;::::0;;;;;;;;;::::1;34143:239:::0;;:::o;794:26::-;;;;:::o;23982:119::-;24075:18;;24048:7;24075:18;;;:9;:18;;;;;;;23982:119::o;42437:117::-;4463:5;;;;4449:10;:19;4441:42;;;;;-1:-1:-1;;;4441:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;42519:16:::1;::::0;;;::::1;;::::0;;;:7:::1;:16;::::0;;;;:27;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;42437:117::o;38381:148::-;38503:7;38497:14;;38472:50::o;31937:174::-;4463:5;;;;4449:10;:19;4441:42;;;;;-1:-1:-1;;;4441:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;32034:30:::1;::::0;;;;;32058:4:::1;32034:30;::::0;::::1;::::0;;;32016:15:::1;::::0;32034::::1;::::0;::::1;::::0;::::1;::::0;:30;;;;;::::1;::::0;;;;;;;;;:15;:30;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;32034:30:0;32075:28:::1;::::0;;;;;:14:::1;:28:::0;;::::1;;::::0;::::1;::::0;;;;;;;;;32034:30;;-1:-1:-1;32075:14:0;;::::1;::::0;::::1;::::0;:28;;;;;32034:30:::1;::::0;32075:28;;;;;;;;-1:-1:-1;32075:14:0;:28;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;;;;;31937:174:0:o;480:20::-;;;;;;:::o;46329:95::-;46403:13;;;;;;;;;;;;;;;;;46329:95;:::o;31600:116::-;4463:5;;;;4449:10;:19;4441:42;;;;;-1:-1:-1;;;4441:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;31673:35:::1;::::0;:12:::1;::::0;::::1;::::0;31686:21:::1;31673:35:::0;::::1;;;::::0;::::1;::::0;;;31686:21;31673:12;:35;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;31600:116:::0;:::o;26944:269::-;27037:4;27054:129;27063:12;:10;:12::i;:::-;27077:7;27086:96;27125:15;27086:96;;;;;;;;;;;;;;;;;:11;:25;27098:12;:10;:12::i;:::-;27086:25;;;;;;;;;;;;;;;;;;-1:-1:-1;27086:25:0;;;:34;;;;;;;;;;;:96;;:38;:96;:::i;24314:175::-;24400:4;24417:42;24427:12;:10;:12::i;:::-;24441:9;24452:6;24417:9;:42::i;41864:322::-;4463:5;;;;4449:10;:19;4441:42;;;;;-1:-1:-1;;;4441:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;40438:8:::1;41972:7;41964:16;;:44;;41956:120;;;;-1:-1:-1::0;;;41956:120:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42087:22;::::0;::::1;;::::0;;;:13:::1;:22;::::0;;;;;;;;:39;;;::::1;::::0;::::1;;::::0;;::::1;::::0;;;42142:36;;;;;;;::::1;::::0;;;;;;;;::::1;41864:322:::0;;:::o;24552:151::-;24668:18;;;;24641:7;24668:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;24552:151::o;507:27::-;;;;;;:::o;4887:104::-;4463:5;;;;4449:10;:19;4441:42;;;;;-1:-1:-1;;;4441:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;4960:12:::1;:23:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;4887:104::o;8702:106::-;8790:10;8702:106;:::o;43793:368::-;43931:20;;;;;;;:13;:20;;;;;;;;43930:21;43922:75;;;;-1:-1:-1;;;43922:75:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44017:22;;;;;;;:13;:22;;;;;;;;44016:23;;:38;;-1:-1:-1;44043:11:0;;44016:38;44008:94;;;;-1:-1:-1;;;44008:94:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44115:38;44130:5;44137:7;44146:6;44115:14;:38::i;:::-;43793:368;;;:::o;36067:938::-;36232:7;36226:14;36319:6;36311;36308:18;36305:2;;;36356:6;36346:16;;36305:2;36394:13;36391:2;;36427:6;36391:2;36490:7;36482:6;36478:20;36537:6;36527:8;36523:21;36640:250;36676:3;36666:8;36663:17;36640:250;;;36873:1;36863:8;36856:19;36726:1;36716:8;36712:16;36700:28;;36640:250;;;-1:-1:-1;;36967:19:0;36958:7;36951:36;36156:842::o;12280:132::-;12338:7;12365:39;12369:1;12372;12365:39;;;;;;;;;;;;;;;;;:3;:39::i;:::-;12358:46;12280:132;-1:-1:-1;;;12280:132:0:o;37131:1170::-;37272:66;37266:73;37416:6;37408;37405:18;37402:2;;;37453:6;37443:16;;37402:2;37491:13;37488:2;;37524:6;37488:2;37611:79;;37750:21;;;37787:385;37823:3;37813:8;37810:17;37787:385;;;37968:8;37962:15;38077:1;38074;38071;38068;38065;38058:5;38051;38046:33;38042:38;;38155:1;38145:8;38138:19;37873:1;37863:8;37859:16;37847:28;;37787:385;;;-1:-1:-1;;38263:19:0;38195:66;38188:95;37197:1097::o;42953:581::-;43103:21;;;;;;;:13;:21;;;;;;;;43102:22;43094:70;;;;-1:-1:-1;;;43094:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43184:24;;;;;;;:13;:24;;;;;;;;43183:25;43175:76;;;;-1:-1:-1;;;43175:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43268:30;43288:9;43268:19;:30::i;:::-;43264:263;;;43315:64;43331:6;43339:9;43350:28;43361:16;:6;40381;43361:16;:10;:16;:::i;:::-;43350:6;;:28;:10;:28;:::i;:::-;43315:15;:64::i;:::-;43394:46;43400:9;43411:28;43422:16;:6;40381;43422:16;:10;:16;:::i;:::-;43411:6;;:28;:10;:28;:::i;:::-;43394:5;:46::i;:::-;43264:263;;;43473:42;43489:6;43497:9;43508:6;43473:15;:42::i;10882:192::-;10968:7;11004:12;10996:6;;;;10988:29;;;;-1:-1:-1;;;10988:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;11040:5:0;;;10882:192::o;9979:181::-;10037:7;10069:5;;;10093:6;;;;10085:46;;;;;-1:-1:-1;;;10085:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;45037:169;45106:4;40438:8;45138:7;45130:16;;:43;:68;;;;-1:-1:-1;45177:16:0;;;:21;;45130:68;45123:75;45037:169;-1:-1:-1;;45037:169:0:o;28523:378::-;28607:21;;;28599:65;;;;;-1:-1:-1;;;28599:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;28677:49;28706:1;28710:7;28719:6;28677:20;:49::i;:::-;28754:12;;:24;;28771:6;28754:24;:16;:24;:::i;:::-;28739:12;:39;28810:18;;;;;;;:9;:18;;;;;;:30;;28833:6;28810:30;:22;:30;:::i;:::-;28789:18;;;;;;;:9;:18;;;;;;;;:51;;;;28856:37;;;;;;;28789:18;;;;28856:37;;;;;;;;;;28523:378;;:::o;44354:196::-;44439:16;;;;;;;:7;:16;;;;;;;;44431:72;;;;-1:-1:-1;;;44431:72:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44514:28;44526:7;44535:6;44514:11;:28::i;30091:346::-;30193:19;;;30185:68;;;;-1:-1:-1;;;30185:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30272:21;;;30264:68;;;;-1:-1:-1;;;30264:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30345:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;30397:32;;;;;;;;;;;;;;;;;30091:346;;;:::o;12908:278::-;12994:7;13029:12;13022:5;13014:28;;;;-1:-1:-1;;;13014:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13053:9;13069:1;13065;:5;;;;;;;12908:278;-1:-1:-1;;;;;12908:278:0:o;13651:130::-;13709:7;13736:37;13740:1;13743;13736:37;;;;;;;;;;;;;;;;;:3;:37::i;10443:136::-;10501:7;10528:43;10532:1;10535;10528:43;;;;;;;;;;;;;;;;;:3;:43::i;27703:539::-;27809:20;;;27801:70;;;;-1:-1:-1;;;27801:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27890:23;;;27882:71;;;;-1:-1:-1;;;27882:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27966:47;27987:6;27995:9;28006:6;27966:20;:47::i;:::-;28046:71;28068:6;28046:71;;;;;;;;;;;;;;;;;:17;;;;;;;:9;:17;;;;;;;:71;;:21;:71;:::i;:::-;28026:17;;;;;;;;:9;:17;;;;;;:91;;;;28151:20;;;;;;;:32;;28176:6;28151:32;:24;:32;:::i;:::-;28128:20;;;;;;;;:9;:20;;;;;;;;;:55;;;;28199:35;;;;;;;28128:20;;28199:35;;;;;;;;;;;;;27703:539;;;:::o;34690:334::-;34793:7;;34783:6;:17;;34775:75;;;;-1:-1:-1;;;34775:75:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34879:7;;34869:6;:17;;34861:77;;;;-1:-1:-1;;;34861:77:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34951:28;34963:7;34972:6;34951:11;:28::i;:::-;34995:21;;;;;;;;;;;;;;;;;;;;;;34690:334;;:::o;14266:166::-;14352:7;14388:12;14380:6;14372:29;;;;-1:-1:-1;;;14372:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14423:1;14419;:5;;;;;;;14266:166;-1:-1:-1;;;;14266:166:0:o;29233:418::-;29317:21;;;29309:67;;;;-1:-1:-1;;;29309:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29389:49;29410:7;29427:1;29431:6;29389:20;:49::i;:::-;29472:68;29495:6;29472:68;;;;;;;;;;;;;;;;;:18;;;;;;;:9;:18;;;;;;;:68;;:22;:68;:::i;:::-;29451:18;;;;;;;:9;:18;;;;;:89;29566:12;;:24;;29583:6;29566:24;:16;:24;:::i;:::-;29551:12;:39;29606:37;;;;;;;;29632:1;;29606:37;;;;;;;;;;;;;29233:418;;:::o
Swarm Source
ipfs://1c4b753619b81a79b832821f732ebe984645e3a172abcdd3bf33c11672209039
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.