ERC-20
Overview
Max Total Supply
2,400,000,000 CIX
Holders
76
Market
Price
$0.00 @ 0.000002 ETH (-7.81%)
Onchain Market Cap
$9,004,320.00
Circulating Supply Market Cap
$0.00
Other Info
Token Contract (WITH 18 Decimals)
Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
CIX
Compiler Version
v0.8.17+commit.8df45f5f
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2022-12-05 */ pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv( uint256 x, uint256 y, uint256 denominator, Rounding rounding ) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10**64) { value /= 10**64; result += 64; } if (value >= 10**32) { value /= 10**32; result += 32; } if (value >= 10**16) { value /= 10**16; result += 16; } if (value >= 10**8) { value /= 10**8; result += 8; } if (value >= 10**4) { value /= 10**4; result += 4; } if (value >= 10**2) { value /= 10**2; result += 2; } if (value >= 10**1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0); } } } pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } } pragma solidity ^0.8.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 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) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } pragma solidity ^0.8.0; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControl { /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {AccessControl-_setupRole}. */ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) external view returns (bool); /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {AccessControl-_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) external view returns (bytes32); /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) external; /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) external; /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) external; } pragma solidity ^0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. * * [WARNING] * ==== * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure * unusable. * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info. * * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an * array of EnumerableSet. * ==== */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping(bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; if (lastIndex != toDeleteIndex) { bytes32 lastValue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastValue; // Update the index for the moved value set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex } // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { return set._values[index]; } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function _values(Set storage set) private view returns (bytes32[] memory) { return set._values; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(Bytes32Set storage set) internal view returns (bytes32[] memory) { bytes32[] memory store = _values(set._inner); bytes32[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(AddressSet storage set) internal view returns (address[] memory) { bytes32[] memory store = _values(set._inner); address[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values in the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(UintSet storage set) internal view returns (uint256[] memory) { bytes32[] memory store = _values(set._inner); uint256[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } } pragma solidity ^0.8.0; /** * @dev Contract module that allows children to implement role-based access * control mechanisms. This is a lightweight version that doesn't allow enumerating role * members except through off-chain means by accessing the contract event logs. Some * applications may benefit from on-chain enumerability, for those cases see * {AccessControlEnumerable}. * * Roles are referred to by their `bytes32` identifier. These should be exposed * in the external API and be unique. The best way to achieve this is by * using `public constant` hash digests: * * ``` * bytes32 public constant MY_ROLE = keccak256("MY_ROLE"); * ``` * * Roles can be used to represent a set of permissions. To restrict access to a * function call, use {hasRole}: * * ``` * function foo() public { * require(hasRole(MY_ROLE, msg.sender)); * ... * } * ``` * * Roles can be granted and revoked dynamically via the {grantRole} and * {revokeRole} functions. Each role has an associated admin role, and only * accounts that have a role's admin role can call {grantRole} and {revokeRole}. * * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means * that only accounts with this role will be able to grant or revoke other * roles. More complex role relationships can be created by using * {_setRoleAdmin}. * * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to * grant and revoke this role. Extra precautions should be taken to secure * accounts that have been granted it. */ abstract contract AccessControl is Context, IAccessControl, ERC165 { struct RoleData { mapping(address => bool) members; bytes32 adminRole; } mapping(bytes32 => RoleData) private _roles; bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; /** * @dev Modifier that checks that an account has a specific role. Reverts * with a standardized message including the required role. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ * * _Available since v4.1._ */ modifier onlyRole(bytes32 role) { _checkRole(role); _; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId); } /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) public view virtual override returns (bool) { return _roles[role].members[account]; } /** * @dev Revert with a standard message if `_msgSender()` is missing `role`. * Overriding this function changes the behavior of the {onlyRole} modifier. * * Format of the revert message is described in {_checkRole}. * * _Available since v4.6._ */ function _checkRole(bytes32 role) internal view virtual { _checkRole(role, _msgSender()); } /** * @dev Revert with a standard message if `account` is missing `role`. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ */ function _checkRole(bytes32 role, address account) internal view virtual { if (!hasRole(role, account)) { revert( string( abi.encodePacked( "AccessControl: account ", Strings.toHexString(account), " is missing role ", Strings.toHexString(uint256(role), 32) ) ) ); } } /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) { return _roles[role].adminRole; } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleGranted} event. */ function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _grantRole(role, account); } /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleRevoked} event. */ function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _revokeRole(role, account); } /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been revoked `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. * * May emit a {RoleRevoked} event. */ function renounceRole(bytes32 role, address account) public virtual override { require(account == _msgSender(), "AccessControl: can only renounce roles for self"); _revokeRole(role, account); } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. Note that unlike {grantRole}, this function doesn't perform any * checks on the calling account. * * May emit a {RoleGranted} event. * * [WARNING] * ==== * This function should only be called from the constructor when setting * up the initial roles for the system. * * Using this function in any other way is effectively circumventing the admin * system imposed by {AccessControl}. * ==== * * NOTE: This function is deprecated in favor of {_grantRole}. */ function _setupRole(bytes32 role, address account) internal virtual { _grantRole(role, account); } /** * @dev Sets `adminRole` as ``role``'s admin role. * * Emits a {RoleAdminChanged} event. */ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { bytes32 previousAdminRole = getRoleAdmin(role); _roles[role].adminRole = adminRole; emit RoleAdminChanged(role, previousAdminRole, adminRole); } /** * @dev Grants `role` to `account`. * * Internal function without access restriction. * * May emit a {RoleGranted} event. */ function _grantRole(bytes32 role, address account) internal virtual { if (!hasRole(role, account)) { _roles[role].members[account] = true; emit RoleGranted(role, account, _msgSender()); } } /** * @dev Revokes `role` from `account`. * * Internal function without access restriction. * * May emit a {RoleRevoked} event. */ function _revokeRole(bytes32 role, address account) internal virtual { if (hasRole(role, account)) { _roles[role].members[account] = false; emit RoleRevoked(role, account, _msgSender()); } } } /** * SourceUnit: /Users/sami/Documents/GitHub/CIX/contracts/CIX.sol */ ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT // OpenZeppelin Contracts v4.4.1 (access/IAccessControlEnumerable.sol) pragma solidity ^0.8.0; ////import "./IAccessControl.sol"; /** * @dev External interface of AccessControlEnumerable declared to support ERC165 detection. */ interface IAccessControlEnumerable is IAccessControl { /** * @dev Returns one of the accounts that have `role`. `index` must be a * value between 0 and {getRoleMemberCount}, non-inclusive. * * Role bearers are not sorted in any particular way, and their ordering may * change at any point. * * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure * you perform all queries on the same block. See the following * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] * for more information. */ function getRoleMember(bytes32 role, uint256 index) external view returns (address); /** * @dev Returns the number of accounts that have `role`. Can be used * together with {getRoleMember} to enumerate all bearers of a role. */ function getRoleMemberCount(bytes32 role) external view returns (uint256); } pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @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); /** * @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 `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, 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 `from` to `to` 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 from, address to, uint256 amount ) external returns (bool); } pragma solidity ^0.8.0; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); } pragma solidity ^0.8.0; /** * @dev Extension of {AccessControl} that allows enumerating the members of each role. */ abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl { using EnumerableSet for EnumerableSet.AddressSet; mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IAccessControlEnumerable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev Returns one of the accounts that have `role`. `index` must be a * value between 0 and {getRoleMemberCount}, non-inclusive. * * Role bearers are not sorted in any particular way, and their ordering may * change at any point. * * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure * you perform all queries on the same block. See the following * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] * for more information. */ function getRoleMember(bytes32 role, uint256 index) public view virtual override returns (address) { return _roleMembers[role].at(index); } /** * @dev Returns the number of accounts that have `role`. Can be used * together with {getRoleMember} to enumerate all bearers of a role. */ function getRoleMemberCount(bytes32 role) public view virtual override returns (uint256) { return _roleMembers[role].length(); } /** * @dev Overload {_grantRole} to track enumerable memberships */ function _grantRole(bytes32 role, address account) internal virtual override { super._grantRole(role, account); _roleMembers[role].add(account); } /** * @dev Overload {_revokeRole} to track enumerable memberships */ function _revokeRole(bytes32 role, address account) internal virtual override { super._revokeRole(role, account); _roleMembers[role].remove(account); } } pragma solidity ^0.8.0; /** * @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.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead 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}. */ contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @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 this function is * overridden; * * 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 view virtual override 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: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address to, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _transfer(owner, to, 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}. * * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on * `transferFrom`. This is semantically equivalent to an infinite approval. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _approve(owner, 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}. * * NOTE: Does not update the allowance if the current allowance * is the maximum `uint256`. * * Requirements: * * - `from` and `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. * - the caller must have allowance for ``from``'s tokens of at least * `amount`. */ function transferFrom( address from, address to, uint256 amount ) public virtual override returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, amount); _transfer(from, to, amount); 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) { address owner = _msgSender(); _approve(owner, spender, allowance(owner, spender) + 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) { address owner = _msgSender(); uint256 currentAllowance = allowance(owner, spender); require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(owner, spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `amount` of tokens from `from` to `to`. * * This 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: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. */ function _transfer( address from, address to, uint256 amount ) internal virtual { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(from, to, amount); uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[from] = fromBalance - amount; // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by // decrementing then incrementing. _balances[to] += amount; } emit Transfer(from, to, amount); _afterTokenTransfer(from, to, 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: * * - `account` 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 += amount; unchecked { // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above. _balances[account] += amount; } emit Transfer(address(0), account, amount); _afterTokenTransfer(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); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; // Overflow not possible: amount <= accountBalance <= totalSupply. _totalSupply -= amount; } emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This 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 Updates `owner` s allowance for `spender` based on spent `amount`. * * Does not update the allowance amount in case of infinite allowance. * Revert if not enough allowance is available. * * Might emit an {Approval} event. */ function _spendAllowance( address owner, address spender, uint256 amount ) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { require(currentAllowance >= amount, "ERC20: insufficient allowance"); unchecked { _approve(owner, spender, currentAllowance - 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 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]. */ function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual {} } pragma solidity ^0.8.9; contract CIX is ERC20, AccessControlEnumerable { bytes32 public constant BURNER = bytes32(uint256(1)); bytes32 public constant MINTER = bytes32(uint256(2)); constructor( address admin, address minter, address burner ) ERC20("Centurion Invest Token", "CIX") { _grantRole(DEFAULT_ADMIN_ROLE, admin); _grantRole(BURNER, burner); _grantRole(MINTER, minter); _mint(_msgSender(), 2400000000 * 10**uint256(decimals())); } function burn(address account, uint256 amount) external onlyRole(BURNER) { require( _msgSender() == account, "ERC20: burn account different from message sender" ); _burn(account, amount); } function mint(address to, uint256 amount) external onlyRole(MINTER) { _mint(to, amount); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"admin","type":"address"},{"internalType":"address","name":"minter","type":"address"},{"internalType":"address","name":"burner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","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":[],"name":"BURNER","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"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":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"to","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":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000003aae94c45ca9b9020bc405bc1a4d76ab9bf1908f0000000000000000000000003aae94c45ca9b9020bc405bc1a4d76ab9bf1908f0000000000000000000000003aae94c45ca9b9020bc405bc1a4d76ab9bf1908f
-----Decoded View---------------
Arg [0] : admin (address): 0x3aaE94c45CA9B9020bC405Bc1a4D76aB9Bf1908F
Arg [1] : minter (address): 0x3aaE94c45CA9B9020bC405Bc1a4D76aB9Bf1908F
Arg [2] : burner (address): 0x3aaE94c45CA9B9020bC405Bc1a4D76aB9Bf1908F
-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000003aae94c45ca9b9020bc405bc1a4d76ab9bf1908f
Arg [1] : 0000000000000000000000003aae94c45ca9b9020bc405bc1a4d76ab9bf1908f
Arg [2] : 0000000000000000000000003aae94c45ca9b9020bc405bc1a4d76ab9bf1908f
Deployed Bytecode Sourcemap
61769:874:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46720:214;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50550:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52901:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61823:52;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51670:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53682:295;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37733:131;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38174:147;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51512:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39318:218;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54386:238;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62536:104;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51841:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47533:153;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36206:147;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50769:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62281:247;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;35311:49;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55127:436;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52174:193;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47860:142;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38614:149;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52430:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61882:52;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46720:214;46805:4;46844:42;46829:57;;;:11;:57;;;;:97;;;;46890:36;46914:11;46890:23;:36::i;:::-;46829:97;46822:104;;46720:214;;;:::o;50550:100::-;50604:13;50637:5;50630:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50550:100;:::o;52901:201::-;52984:4;53001:13;53017:12;:10;:12::i;:::-;53001:28;;53040:32;53049:5;53056:7;53065:6;53040:8;:32::i;:::-;53090:4;53083:11;;;52901:201;;;;:::o;61823:52::-;61872:1;61856:19;;61823:52;:::o;51670:108::-;51731:7;51758:12;;51751:19;;51670:108;:::o;53682:295::-;53813:4;53830:15;53848:12;:10;:12::i;:::-;53830:30;;53871:38;53887:4;53893:7;53902:6;53871:15;:38::i;:::-;53920:27;53930:4;53936:2;53940:6;53920:9;:27::i;:::-;53965:4;53958:11;;;53682:295;;;;;:::o;37733:131::-;37807:7;37834:6;:12;37841:4;37834:12;;;;;;;;;;;:22;;;37827:29;;37733:131;;;:::o;38174:147::-;38257:18;38270:4;38257:12;:18::i;:::-;35802:16;35813:4;35802:10;:16::i;:::-;38288:25:::1;38299:4;38305:7;38288:10;:25::i;:::-;38174:147:::0;;;:::o;51512:93::-;51570:5;51595:2;51588:9;;51512:93;:::o;39318:218::-;39425:12;:10;:12::i;:::-;39414:23;;:7;:23;;;39406:83;;;;;;;;;;;;:::i;:::-;;;;;;;;;39502:26;39514:4;39520:7;39502:11;:26::i;:::-;39318:218;;:::o;54386:238::-;54474:4;54491:13;54507:12;:10;:12::i;:::-;54491:28;;54530:64;54539:5;54546:7;54583:10;54555:25;54565:5;54572:7;54555:9;:25::i;:::-;:38;;;;:::i;:::-;54530:8;:64::i;:::-;54612:4;54605:11;;;54386:238;;;;:::o;62536:104::-;61931:1;61915:19;;35802:16;35813:4;35802:10;:16::i;:::-;62615:17:::1;62621:2;62625:6;62615:5;:17::i;:::-;62536:104:::0;;;:::o;51841:127::-;51915:7;51942:9;:18;51952:7;51942:18;;;;;;;;;;;;;;;;51935:25;;51841:127;;;:::o;47533:153::-;47623:7;47650:28;47672:5;47650:12;:18;47663:4;47650:18;;;;;;;;;;;:21;;:28;;;;:::i;:::-;47643:35;;47533:153;;;;:::o;36206:147::-;36292:4;36316:6;:12;36323:4;36316:12;;;;;;;;;;;:20;;:29;36337:7;36316:29;;;;;;;;;;;;;;;;;;;;;;;;;36309:36;;36206:147;;;;:::o;50769:104::-;50825:13;50858:7;50851:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50769:104;:::o;62281:247::-;61872:1;61856:19;;35802:16;35813:4;35802:10;:16::i;:::-;62403:7:::1;62387:23;;:12;:10;:12::i;:::-;:23;;;62365:122;;;;;;;;;;;;:::i;:::-;;;;;;;;;62498:22;62504:7;62513:6;62498:5;:22::i;:::-;62281:247:::0;;;:::o;35311:49::-;35356:4;35311:49;;;:::o;55127:436::-;55220:4;55237:13;55253:12;:10;:12::i;:::-;55237:28;;55276:24;55303:25;55313:5;55320:7;55303:9;:25::i;:::-;55276:52;;55367:15;55347:16;:35;;55339:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;55460:60;55469:5;55476:7;55504:15;55485:16;:34;55460:8;:60::i;:::-;55551:4;55544:11;;;;55127:436;;;;:::o;52174:193::-;52253:4;52270:13;52286:12;:10;:12::i;:::-;52270:28;;52309;52319:5;52326:2;52330:6;52309:9;:28::i;:::-;52355:4;52348:11;;;52174:193;;;;:::o;47860:142::-;47940:7;47967:27;:12;:18;47980:4;47967:18;;;;;;;;;;;:25;:27::i;:::-;47960:34;;47860:142;;;:::o;38614:149::-;38698:18;38711:4;38698:12;:18::i;:::-;35802:16;35813:4;35802:10;:16::i;:::-;38729:26:::1;38741:4;38747:7;38729:11;:26::i;:::-;38614:149:::0;;;:::o;52430:151::-;52519:7;52546:11;:18;52558:5;52546:18;;;;;;;;;;;;;;;:27;52565:7;52546:27;;;;;;;;;;;;;;;;52539:34;;52430:151;;;;:::o;61882:52::-;61931:1;61915:19;;61882:52;:::o;40915:238::-;40999:22;41007:4;41013:7;40999;:22::i;:::-;40994:152;;41070:4;41038:6;:12;41045:4;41038:12;;;;;;;;;;;:20;;:29;41059:7;41038:29;;;;;;;;;;;;;;;;:36;;;;;;;;;;;;;;;;;;41121:12;:10;:12::i;:::-;41094:40;;41112:7;41094:40;;41106:4;41094:40;;;;;;;;;;40994:152;40915:238;;:::o;28679:152::-;28749:4;28773:50;28778:3;:10;;28814:5;28798:23;;28790:32;;28773:4;:50::i;:::-;28766:57;;28679:152;;;;:::o;35910:204::-;35995:4;36034:32;36019:47;;;:11;:47;;;;:87;;;;36070:36;36094:11;36070:23;:36::i;:::-;36019:87;36012:94;;35910:204;;;:::o;17206:98::-;17259:7;17286:10;17279:17;;17206:98;:::o;59154:380::-;59307:1;59290:19;;:5;:19;;;59282:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;59388:1;59369:21;;:7;:21;;;59361:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;59472:6;59442:11;:18;59454:5;59442:18;;;;;;;;;;;;;;;:27;59461:7;59442:27;;;;;;;;;;;;;;;:36;;;;59510:7;59494:32;;59503:5;59494:32;;;59519:6;59494:32;;;;;;:::i;:::-;;;;;;;;59154:380;;;:::o;59825:453::-;59960:24;59987:25;59997:5;60004:7;59987:9;:25::i;:::-;59960:52;;60047:17;60027:16;:37;60023:248;;60109:6;60089:16;:26;;60081:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;60193:51;60202:5;60209:7;60237:6;60218:16;:25;60193:8;:51::i;:::-;60023:248;59949:329;59825:453;;;:::o;56033:840::-;56180:1;56164:18;;:4;:18;;;56156:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;56257:1;56243:16;;:2;:16;;;56235:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;56312:38;56333:4;56339:2;56343:6;56312:20;:38::i;:::-;56363:19;56385:9;:15;56395:4;56385:15;;;;;;;;;;;;;;;;56363:37;;56434:6;56419:11;:21;;56411:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;56551:6;56537:11;:20;56519:9;:15;56529:4;56519:15;;;;;;;;;;;;;;;:38;;;;56754:6;56737:9;:13;56747:2;56737:13;;;;;;;;;;;;;;;;:23;;;;;;;;;;;56804:2;56789:26;;56798:4;56789:26;;;56808:6;56789:26;;;;;;:::i;:::-;;;;;;;;56828:37;56848:4;56854:2;56858:6;56828:19;:37::i;:::-;56145:728;56033:840;;;:::o;36657:105::-;36724:30;36735:4;36741:12;:10;:12::i;:::-;36724:10;:30::i;:::-;36657:105;:::o;48095:169::-;48183:31;48200:4;48206:7;48183:16;:31::i;:::-;48225;48248:7;48225:12;:18;48238:4;48225:18;;;;;;;;;;;:22;;:31;;;;:::i;:::-;;48095:169;;:::o;48358:174::-;48447:32;48465:4;48471:7;48447:17;:32::i;:::-;48490:34;48516:7;48490:12;:18;48503:4;48490:18;;;;;;;;;;;:25;;:34;;;;:::i;:::-;;48358:174;;:::o;57160:548::-;57263:1;57244:21;;:7;:21;;;57236:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;57314:49;57343:1;57347:7;57356:6;57314:20;:49::i;:::-;57392:6;57376:12;;:22;;;;;;;:::i;:::-;;;;;;;;57569:6;57547:9;:18;57557:7;57547:18;;;;;;;;;;;;;;;;:28;;;;;;;;;;;57623:7;57602:37;;57619:1;57602:37;;;57632:6;57602:37;;;;;;:::i;:::-;;;;;;;;57652:48;57680:1;57684:7;57693:6;57652:19;:48::i;:::-;57160:548;;:::o;29975:158::-;30049:7;30100:22;30104:3;:10;;30116:5;30100:3;:22::i;:::-;30092:31;;30069:56;;29975:158;;;;:::o;58041:675::-;58144:1;58125:21;;:7;:21;;;58117:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;58197:49;58218:7;58235:1;58239:6;58197:20;:49::i;:::-;58259:22;58284:9;:18;58294:7;58284:18;;;;;;;;;;;;;;;;58259:43;;58339:6;58321:14;:24;;58313:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;58458:6;58441:14;:23;58420:9;:18;58430:7;58420:18;;;;;;;;;;;;;;;:44;;;;58575:6;58559:12;;:22;;;;;;;;;;;58636:1;58610:37;;58619:7;58610:37;;;58640:6;58610:37;;;;;;:::i;:::-;;;;;;;;58660:48;58680:7;58697:1;58701:6;58660:19;:48::i;:::-;58106:610;58041:675;;:::o;29504:117::-;29567:7;29594:19;29602:3;:10;;29594:7;:19::i;:::-;29587:26;;29504:117;;;:::o;22410:414::-;22473:4;22495:21;22505:3;22510:5;22495:9;:21::i;:::-;22490:327;;22533:3;:11;;22550:5;22533:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22716:3;:11;;:18;;;;22694:3;:12;;:19;22707:5;22694:19;;;;;;;;;;;:40;;;;22756:4;22749:11;;;;22490:327;22800:5;22793:12;;22410:414;;;;;:::o;14264:157::-;14349:4;14388:25;14373:40;;;:11;:40;;;;14366:47;;14264:157;;;:::o;60878:125::-;;;;:::o;61607:124::-;;;;:::o;37052:492::-;37141:22;37149:4;37155:7;37141;:22::i;:::-;37136:401;;37329:28;37349:7;37329:19;:28::i;:::-;37430:38;37458:4;37450:13;;37465:2;37430:19;:38::i;:::-;37234:257;;;;;;;;;:::i;:::-;;;;;;;;;;;;;37180:345;;;;;;;;;;;:::i;:::-;;;;;;;;37136:401;37052:492;;:::o;41333:239::-;41417:22;41425:4;41431:7;41417;:22::i;:::-;41413:152;;;41488:5;41456:6;:12;41463:4;41456:12;;;;;;;;;;;:20;;:29;41477:7;41456:29;;;;;;;;;;;;;;;;:37;;;;;;;;;;;;;;;;;;41540:12;:10;:12::i;:::-;41513:40;;41531:7;41513:40;;41525:4;41513:40;;;;;;;;;;41413:152;41333:239;;:::o;29007:158::-;29080:4;29104:53;29112:3;:10;;29148:5;29132:23;;29124:32;;29104:7;:53::i;:::-;29097:60;;29007:158;;;;:::o;25184:120::-;25251:7;25278:3;:11;;25290:5;25278:18;;;;;;;;:::i;:::-;;;;;;;;;;25271:25;;25184:120;;;;:::o;24721:109::-;24777:7;24804:3;:11;;:18;;;;24797:25;;24721:109;;;:::o;24506:129::-;24579:4;24626:1;24603:3;:12;;:19;24616:5;24603:19;;;;;;;;;;;;:24;;24596:31;;24506:129;;;;:::o;16473:151::-;16531:13;16564:52;16592:4;16576:22;;14628:2;16564:52;;:11;:52::i;:::-;16557:59;;16473:151;;;:::o;15869:447::-;15944:13;15970:19;16015:1;16006:6;16002:1;:10;;;;:::i;:::-;:14;;;;:::i;:::-;15992:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15970:47;;16028:15;:6;16035:1;16028:9;;;;;;;;:::i;:::-;;;;;:15;;;;;;;;;;;16054;:6;16061:1;16054:9;;;;;;;;:::i;:::-;;;;;:15;;;;;;;;;;;16085:9;16110:1;16101:6;16097:1;:10;;;;:::i;:::-;:14;;;;:::i;:::-;16085:26;;16080:131;16117:1;16113;:5;16080:131;;;16152:8;16169:3;16161:5;:11;16152:21;;;;;;;:::i;:::-;;;;;16140:6;16147:1;16140:9;;;;;;;;:::i;:::-;;;;;:33;;;;;;;;;;;16198:1;16188:11;;;;;16120:3;;;;:::i;:::-;;;16080:131;;;;16238:1;16229:5;:10;16221:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;16301:6;16287:21;;;15869:447;;;;:::o;23000:1420::-;23066:4;23184:18;23205:3;:12;;:19;23218:5;23205:19;;;;;;;;;;;;23184:40;;23255:1;23241:10;:15;23237:1176;;23616:21;23653:1;23640:10;:14;;;;:::i;:::-;23616:38;;23669:17;23710:1;23689:3;:11;;:18;;;;:22;;;;:::i;:::-;23669:42;;23745:13;23732:9;:26;23728:405;;23779:17;23799:3;:11;;23811:9;23799:22;;;;;;;;:::i;:::-;;;;;;;;;;23779:42;;23953:9;23924:3;:11;;23936:13;23924:26;;;;;;;;:::i;:::-;;;;;;;;;:38;;;;24064:10;24038:3;:12;;:23;24051:9;24038:23;;;;;;;;;;;:36;;;;23760:373;23728:405;24214:3;:11;;:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;24309:3;:12;;:19;24322:5;24309:19;;;;;;;;;;;24302:26;;;24352:4;24345:11;;;;;;;23237:1176;24396:5;24389:12;;;23000:1420;;;;;:::o;88:117:1:-;197:1;194;187:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:246::-;1879:1;1889:113;1903:6;1900:1;1897:13;1889:113;;;1988:1;1983:3;1979:11;1973:18;1969:1;1964:3;1960:11;1953:39;1925:2;1922:1;1918:10;1913:15;;1889:113;;;2036:1;2027:6;2022:3;2018:16;2011:27;1860:184;1798:246;;;:::o;2050:102::-;2091:6;2142:2;2138:7;2133:2;2126:5;2122:14;2118:28;2108:38;;2050:102;;;:::o;2158:377::-;2246:3;2274:39;2307:5;2274:39;:::i;:::-;2329:71;2393:6;2388:3;2329:71;:::i;:::-;2322:78;;2409:65;2467:6;2462:3;2455:4;2448:5;2444:16;2409:65;:::i;:::-;2499:29;2521:6;2499:29;:::i;:::-;2494:3;2490:39;2483:46;;2250:285;2158:377;;;;:::o;2541:313::-;2654:4;2692:2;2681:9;2677:18;2669:26;;2741:9;2735:4;2731:20;2727:1;2716:9;2712:17;2705:47;2769:78;2842:4;2833:6;2769:78;:::i;:::-;2761:86;;2541:313;;;;:::o;2860:126::-;2897:7;2937:42;2930:5;2926:54;2915:65;;2860:126;;;:::o;2992:96::-;3029:7;3058:24;3076:5;3058:24;:::i;:::-;3047:35;;2992:96;;;:::o;3094:122::-;3167:24;3185:5;3167:24;:::i;:::-;3160:5;3157:35;3147:63;;3206:1;3203;3196:12;3147:63;3094:122;:::o;3222:139::-;3268:5;3306:6;3293:20;3284:29;;3322:33;3349:5;3322:33;:::i;:::-;3222:139;;;;:::o;3367:77::-;3404:7;3433:5;3422:16;;3367:77;;;:::o;3450:122::-;3523:24;3541:5;3523:24;:::i;:::-;3516:5;3513:35;3503:63;;3562:1;3559;3552:12;3503:63;3450:122;:::o;3578:139::-;3624:5;3662:6;3649:20;3640:29;;3678:33;3705:5;3678:33;:::i;:::-;3578:139;;;;:::o;3723:474::-;3791:6;3799;3848:2;3836:9;3827:7;3823:23;3819:32;3816:119;;;3854:79;;:::i;:::-;3816:119;3974:1;3999:53;4044:7;4035:6;4024:9;4020:22;3999:53;:::i;:::-;3989:63;;3945:117;4101:2;4127:53;4172:7;4163:6;4152:9;4148:22;4127:53;:::i;:::-;4117:63;;4072:118;3723:474;;;;;:::o;4203:77::-;4240:7;4269:5;4258:16;;4203:77;;;:::o;4286:118::-;4373:24;4391:5;4373:24;:::i;:::-;4368:3;4361:37;4286:118;;:::o;4410:222::-;4503:4;4541:2;4530:9;4526:18;4518:26;;4554:71;4622:1;4611:9;4607:17;4598:6;4554:71;:::i;:::-;4410:222;;;;:::o;4638:118::-;4725:24;4743:5;4725:24;:::i;:::-;4720:3;4713:37;4638:118;;:::o;4762:222::-;4855:4;4893:2;4882:9;4878:18;4870:26;;4906:71;4974:1;4963:9;4959:17;4950:6;4906:71;:::i;:::-;4762:222;;;;:::o;4990:619::-;5067:6;5075;5083;5132:2;5120:9;5111:7;5107:23;5103:32;5100:119;;;5138:79;;:::i;:::-;5100:119;5258:1;5283:53;5328:7;5319:6;5308:9;5304:22;5283:53;:::i;:::-;5273:63;;5229:117;5385:2;5411:53;5456:7;5447:6;5436:9;5432:22;5411:53;:::i;:::-;5401:63;;5356:118;5513:2;5539:53;5584:7;5575:6;5564:9;5560:22;5539:53;:::i;:::-;5529:63;;5484:118;4990:619;;;;;:::o;5615:122::-;5688:24;5706:5;5688:24;:::i;:::-;5681:5;5678:35;5668:63;;5727:1;5724;5717:12;5668:63;5615:122;:::o;5743:139::-;5789:5;5827:6;5814:20;5805:29;;5843:33;5870:5;5843:33;:::i;:::-;5743:139;;;;:::o;5888:329::-;5947:6;5996:2;5984:9;5975:7;5971:23;5967:32;5964:119;;;6002:79;;:::i;:::-;5964:119;6122:1;6147:53;6192:7;6183:6;6172:9;6168:22;6147:53;:::i;:::-;6137:63;;6093:117;5888:329;;;;:::o;6223:474::-;6291:6;6299;6348:2;6336:9;6327:7;6323:23;6319:32;6316:119;;;6354:79;;:::i;:::-;6316:119;6474:1;6499:53;6544:7;6535:6;6524:9;6520:22;6499:53;:::i;:::-;6489:63;;6445:117;6601:2;6627:53;6672:7;6663:6;6652:9;6648:22;6627:53;:::i;:::-;6617:63;;6572:118;6223:474;;;;;:::o;6703:86::-;6738:7;6778:4;6771:5;6767:16;6756:27;;6703:86;;;:::o;6795:112::-;6878:22;6894:5;6878:22;:::i;:::-;6873:3;6866:35;6795:112;;:::o;6913:214::-;7002:4;7040:2;7029:9;7025:18;7017:26;;7053:67;7117:1;7106:9;7102:17;7093:6;7053:67;:::i;:::-;6913:214;;;;:::o;7133:329::-;7192:6;7241:2;7229:9;7220:7;7216:23;7212:32;7209:119;;;7247:79;;:::i;:::-;7209:119;7367:1;7392:53;7437:7;7428:6;7417:9;7413:22;7392:53;:::i;:::-;7382:63;;7338:117;7133:329;;;;:::o;7468:474::-;7536:6;7544;7593:2;7581:9;7572:7;7568:23;7564:32;7561:119;;;7599:79;;:::i;:::-;7561:119;7719:1;7744:53;7789:7;7780:6;7769:9;7765:22;7744:53;:::i;:::-;7734:63;;7690:117;7846:2;7872:53;7917:7;7908:6;7897:9;7893:22;7872:53;:::i;:::-;7862:63;;7817:118;7468:474;;;;;:::o;7948:118::-;8035:24;8053:5;8035:24;:::i;:::-;8030:3;8023:37;7948:118;;:::o;8072:222::-;8165:4;8203:2;8192:9;8188:18;8180:26;;8216:71;8284:1;8273:9;8269:17;8260:6;8216:71;:::i;:::-;8072:222;;;;:::o;8300:474::-;8368:6;8376;8425:2;8413:9;8404:7;8400:23;8396:32;8393:119;;;8431:79;;:::i;:::-;8393:119;8551:1;8576:53;8621:7;8612:6;8601:9;8597:22;8576:53;:::i;:::-;8566:63;;8522:117;8678:2;8704:53;8749:7;8740:6;8729:9;8725:22;8704:53;:::i;:::-;8694:63;;8649:118;8300:474;;;;;:::o;8780:180::-;8828:77;8825:1;8818:88;8925:4;8922:1;8915:15;8949:4;8946:1;8939:15;8966:320;9010:6;9047:1;9041:4;9037:12;9027:22;;9094:1;9088:4;9084:12;9115:18;9105:81;;9171:4;9163:6;9159:17;9149:27;;9105:81;9233:2;9225:6;9222:14;9202:18;9199:38;9196:84;;9252:18;;:::i;:::-;9196:84;9017:269;8966:320;;;:::o;9292:234::-;9432:34;9428:1;9420:6;9416:14;9409:58;9501:17;9496:2;9488:6;9484:15;9477:42;9292:234;:::o;9532:366::-;9674:3;9695:67;9759:2;9754:3;9695:67;:::i;:::-;9688:74;;9771:93;9860:3;9771:93;:::i;:::-;9889:2;9884:3;9880:12;9873:19;;9532:366;;;:::o;9904:419::-;10070:4;10108:2;10097:9;10093:18;10085:26;;10157:9;10151:4;10147:20;10143:1;10132:9;10128:17;10121:47;10185:131;10311:4;10185:131;:::i;:::-;10177:139;;9904:419;;;:::o;10329:180::-;10377:77;10374:1;10367:88;10474:4;10471:1;10464:15;10498:4;10495:1;10488:15;10515:191;10555:3;10574:20;10592:1;10574:20;:::i;:::-;10569:25;;10608:20;10626:1;10608:20;:::i;:::-;10603:25;;10651:1;10648;10644:9;10637:16;;10672:3;10669:1;10666:10;10663:36;;;10679:18;;:::i;:::-;10663:36;10515:191;;;;:::o;10712:236::-;10852:34;10848:1;10840:6;10836:14;10829:58;10921:19;10916:2;10908:6;10904:15;10897:44;10712:236;:::o;10954:366::-;11096:3;11117:67;11181:2;11176:3;11117:67;:::i;:::-;11110:74;;11193:93;11282:3;11193:93;:::i;:::-;11311:2;11306:3;11302:12;11295:19;;10954:366;;;:::o;11326:419::-;11492:4;11530:2;11519:9;11515:18;11507:26;;11579:9;11573:4;11569:20;11565:1;11554:9;11550:17;11543:47;11607:131;11733:4;11607:131;:::i;:::-;11599:139;;11326:419;;;:::o;11751:224::-;11891:34;11887:1;11879:6;11875:14;11868:58;11960:7;11955:2;11947:6;11943:15;11936:32;11751:224;:::o;11981:366::-;12123:3;12144:67;12208:2;12203:3;12144:67;:::i;:::-;12137:74;;12220:93;12309:3;12220:93;:::i;:::-;12338:2;12333:3;12329:12;12322:19;;11981:366;;;:::o;12353:419::-;12519:4;12557:2;12546:9;12542:18;12534:26;;12606:9;12600:4;12596:20;12592:1;12581:9;12577:17;12570:47;12634:131;12760:4;12634:131;:::i;:::-;12626:139;;12353:419;;;:::o;12778:223::-;12918:34;12914:1;12906:6;12902:14;12895:58;12987:6;12982:2;12974:6;12970:15;12963:31;12778:223;:::o;13007:366::-;13149:3;13170:67;13234:2;13229:3;13170:67;:::i;:::-;13163:74;;13246:93;13335:3;13246:93;:::i;:::-;13364:2;13359:3;13355:12;13348:19;;13007:366;;;:::o;13379:419::-;13545:4;13583:2;13572:9;13568:18;13560:26;;13632:9;13626:4;13622:20;13618:1;13607:9;13603:17;13596:47;13660:131;13786:4;13660:131;:::i;:::-;13652:139;;13379:419;;;:::o;13804:221::-;13944:34;13940:1;13932:6;13928:14;13921:58;14013:4;14008:2;14000:6;13996:15;13989:29;13804:221;:::o;14031:366::-;14173:3;14194:67;14258:2;14253:3;14194:67;:::i;:::-;14187:74;;14270:93;14359:3;14270:93;:::i;:::-;14388:2;14383:3;14379:12;14372:19;;14031:366;;;:::o;14403:419::-;14569:4;14607:2;14596:9;14592:18;14584:26;;14656:9;14650:4;14646:20;14642:1;14631:9;14627:17;14620:47;14684:131;14810:4;14684:131;:::i;:::-;14676:139;;14403:419;;;:::o;14828:179::-;14968:31;14964:1;14956:6;14952:14;14945:55;14828:179;:::o;15013:366::-;15155:3;15176:67;15240:2;15235:3;15176:67;:::i;:::-;15169:74;;15252:93;15341:3;15252:93;:::i;:::-;15370:2;15365:3;15361:12;15354:19;;15013:366;;;:::o;15385:419::-;15551:4;15589:2;15578:9;15574:18;15566:26;;15638:9;15632:4;15628:20;15624:1;15613:9;15609:17;15602:47;15666:131;15792:4;15666:131;:::i;:::-;15658:139;;15385:419;;;:::o;15810:224::-;15950:34;15946:1;15938:6;15934:14;15927:58;16019:7;16014:2;16006:6;16002:15;15995:32;15810:224;:::o;16040:366::-;16182:3;16203:67;16267:2;16262:3;16203:67;:::i;:::-;16196:74;;16279:93;16368:3;16279:93;:::i;:::-;16397:2;16392:3;16388:12;16381:19;;16040:366;;;:::o;16412:419::-;16578:4;16616:2;16605:9;16601:18;16593:26;;16665:9;16659:4;16655:20;16651:1;16640:9;16636:17;16629:47;16693:131;16819:4;16693:131;:::i;:::-;16685:139;;16412:419;;;:::o;16837:222::-;16977:34;16973:1;16965:6;16961:14;16954:58;17046:5;17041:2;17033:6;17029:15;17022:30;16837:222;:::o;17065:366::-;17207:3;17228:67;17292:2;17287:3;17228:67;:::i;:::-;17221:74;;17304:93;17393:3;17304:93;:::i;:::-;17422:2;17417:3;17413:12;17406:19;;17065:366;;;:::o;17437:419::-;17603:4;17641:2;17630:9;17626:18;17618:26;;17690:9;17684:4;17680:20;17676:1;17665:9;17661:17;17654:47;17718:131;17844:4;17718:131;:::i;:::-;17710:139;;17437:419;;;:::o;17862:225::-;18002:34;17998:1;17990:6;17986:14;17979:58;18071:8;18066:2;18058:6;18054:15;18047:33;17862:225;:::o;18093:366::-;18235:3;18256:67;18320:2;18315:3;18256:67;:::i;:::-;18249:74;;18332:93;18421:3;18332:93;:::i;:::-;18450:2;18445:3;18441:12;18434:19;;18093:366;;;:::o;18465:419::-;18631:4;18669:2;18658:9;18654:18;18646:26;;18718:9;18712:4;18708:20;18704:1;18693:9;18689:17;18682:47;18746:131;18872:4;18746:131;:::i;:::-;18738:139;;18465:419;;;:::o;18890:181::-;19030:33;19026:1;19018:6;19014:14;19007:57;18890:181;:::o;19077:366::-;19219:3;19240:67;19304:2;19299:3;19240:67;:::i;:::-;19233:74;;19316:93;19405:3;19316:93;:::i;:::-;19434:2;19429:3;19425:12;19418:19;;19077:366;;;:::o;19449:419::-;19615:4;19653:2;19642:9;19638:18;19630:26;;19702:9;19696:4;19692:20;19688:1;19677:9;19673:17;19666:47;19730:131;19856:4;19730:131;:::i;:::-;19722:139;;19449:419;;;:::o;19874:220::-;20014:34;20010:1;20002:6;19998:14;19991:58;20083:3;20078:2;20070:6;20066:15;20059:28;19874:220;:::o;20100:366::-;20242:3;20263:67;20327:2;20322:3;20263:67;:::i;:::-;20256:74;;20339:93;20428:3;20339:93;:::i;:::-;20457:2;20452:3;20448:12;20441:19;;20100:366;;;:::o;20472:419::-;20638:4;20676:2;20665:9;20661:18;20653:26;;20725:9;20719:4;20715:20;20711:1;20700:9;20696:17;20689:47;20753:131;20879:4;20753:131;:::i;:::-;20745:139;;20472:419;;;:::o;20897:221::-;21037:34;21033:1;21025:6;21021:14;21014:58;21106:4;21101:2;21093:6;21089:15;21082:29;20897:221;:::o;21124:366::-;21266:3;21287:67;21351:2;21346:3;21287:67;:::i;:::-;21280:74;;21363:93;21452:3;21363:93;:::i;:::-;21481:2;21476:3;21472:12;21465:19;;21124:366;;;:::o;21496:419::-;21662:4;21700:2;21689:9;21685:18;21677:26;;21749:9;21743:4;21739:20;21735:1;21724:9;21720:17;21713:47;21777:131;21903:4;21777:131;:::i;:::-;21769:139;;21496:419;;;:::o;21921:148::-;22023:11;22060:3;22045:18;;21921:148;;;;:::o;22075:173::-;22215:25;22211:1;22203:6;22199:14;22192:49;22075:173;:::o;22254:402::-;22414:3;22435:85;22517:2;22512:3;22435:85;:::i;:::-;22428:92;;22529:93;22618:3;22529:93;:::i;:::-;22647:2;22642:3;22638:12;22631:19;;22254:402;;;:::o;22662:390::-;22768:3;22796:39;22829:5;22796:39;:::i;:::-;22851:89;22933:6;22928:3;22851:89;:::i;:::-;22844:96;;22949:65;23007:6;23002:3;22995:4;22988:5;22984:16;22949:65;:::i;:::-;23039:6;23034:3;23030:16;23023:23;;22772:280;22662:390;;;;:::o;23058:167::-;23198:19;23194:1;23186:6;23182:14;23175:43;23058:167;:::o;23231:402::-;23391:3;23412:85;23494:2;23489:3;23412:85;:::i;:::-;23405:92;;23506:93;23595:3;23506:93;:::i;:::-;23624:2;23619:3;23615:12;23608:19;;23231:402;;;:::o;23639:967::-;24021:3;24043:148;24187:3;24043:148;:::i;:::-;24036:155;;24208:95;24299:3;24290:6;24208:95;:::i;:::-;24201:102;;24320:148;24464:3;24320:148;:::i;:::-;24313:155;;24485:95;24576:3;24567:6;24485:95;:::i;:::-;24478:102;;24597:3;24590:10;;23639:967;;;;;:::o;24612:180::-;24660:77;24657:1;24650:88;24757:4;24754:1;24747:15;24781:4;24778:1;24771:15;24798:410;24838:7;24861:20;24879:1;24861:20;:::i;:::-;24856:25;;24895:20;24913:1;24895:20;:::i;:::-;24890:25;;24950:1;24947;24943:9;24972:30;24990:11;24972:30;:::i;:::-;24961:41;;25151:1;25142:7;25138:15;25135:1;25132:22;25112:1;25105:9;25085:83;25062:139;;25181:18;;:::i;:::-;25062:139;24846:362;24798:410;;;;:::o;25214:180::-;25262:77;25259:1;25252:88;25359:4;25356:1;25349:15;25383:4;25380:1;25373:15;25400:171;25439:3;25462:24;25480:5;25462:24;:::i;:::-;25453:33;;25508:4;25501:5;25498:15;25495:41;;25516:18;;:::i;:::-;25495:41;25563:1;25556:5;25552:13;25545:20;;25400:171;;;:::o;25577:182::-;25717:34;25713:1;25705:6;25701:14;25694:58;25577:182;:::o;25765:366::-;25907:3;25928:67;25992:2;25987:3;25928:67;:::i;:::-;25921:74;;26004:93;26093:3;26004:93;:::i;:::-;26122:2;26117:3;26113:12;26106:19;;25765:366;;;:::o;26137:419::-;26303:4;26341:2;26330:9;26326:18;26318:26;;26390:9;26384:4;26380:20;26376:1;26365:9;26361:17;26354:47;26418:131;26544:4;26418:131;:::i;:::-;26410:139;;26137:419;;;:::o;26562:194::-;26602:4;26622:20;26640:1;26622:20;:::i;:::-;26617:25;;26656:20;26674:1;26656:20;:::i;:::-;26651:25;;26700:1;26697;26693:9;26685:17;;26724:1;26718:4;26715:11;26712:37;;;26729:18;;:::i;:::-;26712:37;26562:194;;;;:::o;26762:180::-;26810:77;26807:1;26800:88;26907:4;26904:1;26897:15;26931:4;26928:1;26921:15
Swarm Source
ipfs://7892d3a88df8d65f9611b6505f0f78c8692332206425f96b38abe6f67ee26af7
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.