![ads](/images/gen/moonpay_20.png)
20M+ users trust MoonPay worldwide. Checkout with your preferred payment method.
![ads](/images/gen/cons_20.png)
Ready to onboard to Ethereum? With MetaMask Portfolio, you're in control.
![ads](/images/gen/nexo.png)
Get up to 0.5% cashback per purchase and receive daily interest.
![ads](/images/gen/cons_20.png)
Ready to simplify your web3 experience? Try the all-in-one web3 app trusted by millions worldwide.
Opt-in, make your first trade on Exchange Plus & receive random crypto rewards from 10,000 SHIB, to 0.01 BTC.
![ads](/images/gen/coinsgame_20a.png)
Everyday giveaways up to 100 ETH, Lucky Spins. Deposit BONUS 300% and Cashbacks!
![ads](/images/gen/celsiuscasino_20.png)
9 years old Licensed Crypto Casino, Instant Withdraw 24/7, 6000+ Slots available, Paypal Deposit, Instant Live Support 24/7, 30% Rakeback.
![ads](/images/gen/bcgames_20.png)
5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.
![ads](/images/gen/bcgames_20.png)
5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.
![ads](/images/gen/cw_20.png)
Play 100s of games anonymously with all major cryptos. Join CryptoWins & start winning!
![ads](/images/gen/cryptoslots.png)
Anonymous play on awesome games - sign up now for 25 free jackpot spins - worth $100s!
Overview
ETH Balance
Eth Value
$0.00Token Holdings
Could not find any matches!
- ERC-20 Tokens (22)0.5 TRBTellor Tribu... (TRB)0 CRVCurve DAO To... (CRV)$0.00@0.33760 HSCHashCoin (HSC)$0.00@0.00100 XYOXY Oracle (XYO)$0.46@0.00466 DAIDai Stableco... (DAI)$6.00@0.99990.02999704 MANADecentraland (MANA)$0.01@0.273312.746 USDTTether USD (USDT)$12.75@1.00290,424.837655 USDCUSDC (USDC)$290,398.99@0.9999172.15 Swap at LINKToken.ioaLINK (Swap a...)110 HiHAPY (Hi)10,827,907.4910996 MTRLMaterial700,000 TCHTeacher Coin3,999.99 TokenERC-20 TOKEN*[Suspicious]8,271 TokenERC-20 TOKEN*[Suspicious]3,999.99 TokenERC-20 TOKEN*[Suspicious]100,000 TokenERC-20 TOKEN*[Suspicious]4,214 TokenERC-20 TOKEN*[Suspicious]7,000 TokenERC-20 TOKEN*[Suspicious]350 TokenERC-20 TOKEN*[Suspicious]241.75 TokenERC-20 TOKEN*[Suspicious]7,000 TokenERC-20 TOKEN*[Unsafe]7,000 TokenERC-20 TOKEN*[Spam]NFT Tokens (8)NativePunks CollectionNativePunks CollectionERC-1155
More Info
Private Name Tags
ContractCreator
- Transactions
- Internal Transactions
- Token Transfers (ERC-20)
- NFT Transfers
- Contract
- Events
- Analytics
- Multichain Portfolio
- Filter by Tx Type:
- Tx
- Internal Tx
- ERC-20
- NFTs
Latest 25 from a total of 585 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|
Relay Tokens | 20295066 | 2024-07-13 4:01:35 | 39 days ago | 1720843295 | IN | 0 ETH$0.00 | 0.00046965 | 1.88764057 | ||||
Relay Tokens | 19627793 | 2024-04-10 21:03:59 | 132 days ago | 1712783039 | IN | 0 ETH$0.00 | 0.00450356 | 18.45774891 | ||||
Relay Tokens | 19572271 | 2024-04-03 2:28:59 | 140 days ago | 1712111339 | IN | 0 ETH$0.00 | 0.00526407 | 23.19947641 | ||||
Relay Tokens | 19572211 | 2024-04-03 2:16:47 | 140 days ago | 1712110607 | IN | 0 ETH$0.00 | 0.00593251 | 23.84632008 | ||||
Relay Tokens | 19571493 | 2024-04-02 23:52:23 | 140 days ago | 1712101943 | IN | 0 ETH$0.00 | 0.00541655 | 23.37934995 | ||||
Relay Tokens | 19571475 | 2024-04-02 23:48:47 | 140 days ago | 1712101727 | IN | 0 ETH$0.00 | 0.00563944 | 24.85507443 | ||||
Relay Tokens | 19571209 | 2024-04-02 22:54:59 | 140 days ago | 1712098499 | IN | 0 ETH$0.00 | 0.00680168 | 29.97750979 | ||||
Relay Tokens | 19570342 | 2024-04-02 19:59:59 | 140 days ago | 1712087999 | IN | 0 ETH$0.00 | 0.00985056 | 43.41503571 | ||||
Relay Tokens | 19567965 | 2024-04-02 11:57:59 | 140 days ago | 1712059079 | IN | 0 ETH$0.00 | 0.00561669 | 24.75350724 | ||||
Relay Tokens | 19567953 | 2024-04-02 11:55:35 | 140 days ago | 1712058935 | IN | 0 ETH$0.00 | 0.00558463 | 24.61353205 | ||||
Relay Tokens | 19567904 | 2024-04-02 11:45:35 | 140 days ago | 1712058335 | IN | 0 ETH$0.00 | 0.00638583 | 28.143214 | ||||
Relay Tokens | 19566183 | 2024-04-02 5:57:47 | 141 days ago | 1712037467 | IN | 0 ETH$0.00 | 0.00408399 | 17.62768438 | ||||
Relay Tokens | 19565201 | 2024-04-02 2:40:23 | 141 days ago | 1712025623 | IN | 0 ETH$0.00 | 0.00866559 | 35.5157525 | ||||
Relay Tokens | 19404374 | 2024-03-10 11:24:11 | 163 days ago | 1710069851 | IN | 0 ETH$0.00 | 0.01219965 | 50 | ||||
Relay Tokens | 19380197 | 2024-03-07 2:04:59 | 167 days ago | 1709777099 | IN | 0 ETH$0.00 | 0.01425136 | 58.40891038 | ||||
Relay Tokens | 19286643 | 2024-02-23 0:12:23 | 180 days ago | 1708647143 | IN | 0 ETH$0.00 | 0.0133814 | 54.84610608 | ||||
Relay Tokens | 19250609 | 2024-02-17 22:40:59 | 185 days ago | 1708209659 | IN | 0 ETH$0.00 | 0.00459432 | 20.24777684 | ||||
Relay Tokens | 19250336 | 2024-02-17 21:46:11 | 185 days ago | 1708206371 | IN | 0 ETH$0.00 | 0.00408875 | 18.01968875 | ||||
Relay Tokens | 19250194 | 2024-02-17 21:17:47 | 185 days ago | 1708204667 | IN | 0 ETH$0.00 | 0.00390683 | 17.21885177 | ||||
Relay Tokens | 19249876 | 2024-02-17 20:13:23 | 185 days ago | 1708200803 | IN | 0 ETH$0.00 | 0.00442017 | 18.11688407 | ||||
Relay Tokens | 18982230 | 2024-01-11 7:34:11 | 223 days ago | 1704958451 | IN | 0 ETH$0.00 | 0.00560471 | 22.5276257 | ||||
Relay Tokens | 18978221 | 2024-01-10 18:05:11 | 223 days ago | 1704909911 | IN | 0 ETH$0.00 | 0.01334787 | 53.65051657 | ||||
Relay Tokens | 18957141 | 2024-01-07 19:00:47 | 226 days ago | 1704654047 | IN | 0 ETH$0.00 | 0.00779422 | 30.56008606 | ||||
Relay Tokens | 18939805 | 2024-01-05 8:10:23 | 229 days ago | 1704442223 | IN | 0 ETH$0.00 | 0.0038213 | 14.98282129 | ||||
Relay Tokens | 18928963 | 2024-01-03 19:39:35 | 230 days ago | 1704310775 | IN | 0 ETH$0.00 | 0.00663798 | 26.52456492 |
View more zero value Internal Transactions in Advanced View mode
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0x4FA2EBF8...D0887f1c8 The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Source Code (Solidity)
- contract EternalStorage
- library AddressUtils
- - function isContract(address _addr)
- contract Proxy
- - function implementation()
- - function()
- contract UpgradeabilityStorage
- - function version()
- - function implementation()
- contract UpgradeabilityProxy is Pr ...
- - function _upgradeTo(uint256 version, ...
- contract UpgradeabilityOwnerStorag ...
- - function upgradeabilityOwner()
- - function setUpgradeabilityOwner(addre ...
- contract OwnedUpgradeabilityProxy ...
- - function transferProxyOwnership(addre ...
- - function upgradeTo(uint256 version, a ...
- - function upgradeToAndCall(uint256 ver ...
- contract EternalStorageProxy is Et ... *
/** *Submitted for verification at Etherscan.io on 2020-10-30 */ /** *Submitted for verification at Etherscan.io on 2020-10-30 */ // File: contracts/upgradeability/EternalStorage.sol pragma solidity 0.4.24; /** * @title EternalStorage * @dev This contract holds all the necessary state variables to carry out the storage of any contract. */ contract EternalStorage { mapping(bytes32 => uint256) internal uintStorage; mapping(bytes32 => string) internal stringStorage; mapping(bytes32 => address) internal addressStorage; mapping(bytes32 => bytes) internal bytesStorage; mapping(bytes32 => bool) internal boolStorage; mapping(bytes32 => int256) internal intStorage; } // File: openzeppelin-solidity/contracts/AddressUtils.sol pragma solidity ^0.4.24; /** * Utility library of inline functions on addresses */ library AddressUtils { /** * Returns whether the target address is a contract * @dev This function will return false if invoked during the constructor of a contract, * as the code is not actually created until after the constructor finishes. * @param _addr address to check * @return whether the target address is a contract */ function isContract(address _addr) internal view returns (bool) { uint256 size; // XXX Currently there is no better way to check if there is a contract in an address // than to check the size of the code at that address. // See https://ethereum.stackexchange.com/a/14016/36603 // for more details about how this works. // TODO Check this again before the Serenity release, because all addresses will be // contracts then. // solium-disable-next-line security/no-inline-assembly assembly { size := extcodesize(_addr) } return size > 0; } } // File: contracts/upgradeability/Proxy.sol pragma solidity 0.4.24; /** * @title Proxy * @dev Gives the possibility to delegate any call to a foreign implementation. */ contract Proxy { /** * @dev Tells the address of the implementation where every call will be delegated. * @return address of the implementation to which it will be delegated */ /* solcov ignore next */ function implementation() public view returns (address); /** * @dev Fallback function allowing to perform a delegatecall to the given implementation. * This function will return whatever the implementation call returns */ function() public payable { // solhint-disable-previous-line no-complex-fallback address _impl = implementation(); require(_impl != address(0)); assembly { /* 0x40 is the "free memory slot", meaning a pointer to next slot of empty memory. mload(0x40) loads the data in the free memory slot, so `ptr` is a pointer to the next slot of empty memory. It's needed because we're going to write the return data of delegatecall to the free memory slot. */ let ptr := mload(0x40) /* `calldatacopy` is copy calldatasize bytes from calldata First argument is the destination to which data is copied(ptr) Second argument specifies the start position of the copied data. Since calldata is sort of its own unique location in memory, 0 doesn't refer to 0 in memory or 0 in storage - it just refers to the zeroth byte of calldata. That's always going to be the zeroth byte of the function selector. Third argument, calldatasize, specifies how much data will be copied. calldata is naturally calldatasize bytes long (same thing as msg.data.length) */ calldatacopy(ptr, 0, calldatasize) /* delegatecall params explained: gas: the amount of gas to provide for the call. `gas` is an Opcode that gives us the amount of gas still available to execution _impl: address of the contract to delegate to ptr: to pass copied data calldatasize: loads the size of `bytes memory data`, same as msg.data.length 0, 0: These are for the `out` and `outsize` params. Because the output could be dynamic, these are set to 0, 0 so the output data will not be written to memory. The output data will be read using `returndatasize` and `returdatacopy` instead. result: This will be 0 if the call fails and 1 if it succeeds */ let result := delegatecall(gas, _impl, ptr, calldatasize, 0, 0) /* */ /* ptr current points to the value stored at 0x40, because we assigned it like ptr := mload(0x40). Because we use 0x40 as a free memory pointer, we want to make sure that the next time we want to allocate memory, we aren't overwriting anything important. So, by adding ptr and returndatasize, we get a memory location beyond the end of the data we will be copying to ptr. We place this in at 0x40, and any reads from 0x40 will now read from free memory */ mstore(0x40, add(ptr, returndatasize)) /* `returndatacopy` is an Opcode that copies the last return data to a slot. `ptr` is the slot it will copy to, 0 means copy from the beginning of the return data, and size is the amount of data to copy. `returndatasize` is an Opcode that gives us the size of the last return data. In this case, that is the size of the data returned from delegatecall */ returndatacopy(ptr, 0, returndatasize) /* if `result` is 0, revert. if `result` is 1, return `size` amount of data from `ptr`. This is the data that was copied to `ptr` from the delegatecall return data */ switch result case 0 { revert(ptr, returndatasize) } default { return(ptr, returndatasize) } } } } // File: contracts/upgradeability/UpgradeabilityStorage.sol pragma solidity 0.4.24; /** * @title UpgradeabilityStorage * @dev This contract holds all the necessary state variables to support the upgrade functionality */ contract UpgradeabilityStorage { // Version name of the current implementation uint256 internal _version; // Address of the current implementation address internal _implementation; /** * @dev Tells the version name of the current implementation * @return uint256 representing the name of the current version */ function version() external view returns (uint256) { return _version; } /** * @dev Tells the address of the current implementation * @return address of the current implementation */ function implementation() public view returns (address) { return _implementation; } } // File: contracts/upgradeability/UpgradeabilityProxy.sol pragma solidity 0.4.24; /** * @title UpgradeabilityProxy * @dev This contract represents a proxy where the implementation address to which it will delegate can be upgraded */ contract UpgradeabilityProxy is Proxy, UpgradeabilityStorage { /** * @dev This event will be emitted every time the implementation gets upgraded * @param version representing the version name of the upgraded implementation * @param implementation representing the address of the upgraded implementation */ event Upgraded(uint256 version, address indexed implementation); /** * @dev Upgrades the implementation address * @param version representing the version name of the new implementation to be set * @param implementation representing the address of the new implementation to be set */ function _upgradeTo(uint256 version, address implementation) internal { require(_implementation != implementation); // This additional check verifies that provided implementation is at least a contract require(AddressUtils.isContract(implementation)); // This additional check guarantees that new version will be at least greater than the privios one, // so it is impossible to reuse old versions, or use the last version twice require(version > _version); _version = version; _implementation = implementation; emit Upgraded(version, implementation); } } // File: contracts/upgradeability/UpgradeabilityOwnerStorage.sol pragma solidity 0.4.24; /** * @title UpgradeabilityOwnerStorage * @dev This contract keeps track of the upgradeability owner */ contract UpgradeabilityOwnerStorage { // Owner of the contract address internal _upgradeabilityOwner; /** * @dev Tells the address of the owner * @return the address of the owner */ function upgradeabilityOwner() public view returns (address) { return _upgradeabilityOwner; } /** * @dev Sets the address of the owner */ function setUpgradeabilityOwner(address newUpgradeabilityOwner) internal { _upgradeabilityOwner = newUpgradeabilityOwner; } } // File: contracts/upgradeability/OwnedUpgradeabilityProxy.sol pragma solidity 0.4.24; /** * @title OwnedUpgradeabilityProxy * @dev This contract combines an upgradeability proxy with basic authorization control functionalities */ contract OwnedUpgradeabilityProxy is UpgradeabilityOwnerStorage, UpgradeabilityProxy { /** * @dev Event to show ownership has been transferred * @param previousOwner representing the address of the previous owner * @param newOwner representing the address of the new owner */ event ProxyOwnershipTransferred(address previousOwner, address newOwner); /** * @dev the constructor sets the original owner of the contract to the sender account. */ constructor() public { setUpgradeabilityOwner(msg.sender); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyUpgradeabilityOwner() { require(msg.sender == upgradeabilityOwner()); /* solcov ignore next */ _; } /** * @dev Allows the current owner to transfer control of the contract to a newOwner. * @param newOwner The address to transfer ownership to. */ function transferProxyOwnership(address newOwner) external onlyUpgradeabilityOwner { require(newOwner != address(0)); emit ProxyOwnershipTransferred(upgradeabilityOwner(), newOwner); setUpgradeabilityOwner(newOwner); } /** * @dev Allows the upgradeability owner to upgrade the current version of the proxy. * @param version representing the version name of the new implementation to be set. * @param implementation representing the address of the new implementation to be set. */ function upgradeTo(uint256 version, address implementation) public onlyUpgradeabilityOwner { _upgradeTo(version, implementation); } /** * @dev Allows the upgradeability owner to upgrade the current version of the proxy and call the new implementation * to initialize whatever is needed through a low level call. * @param version representing the version name of the new implementation to be set. * @param implementation representing the address of the new implementation to be set. * @param data represents the msg.data to bet sent in the low level call. This parameter may include the function * signature of the implementation to be called with the needed payload */ function upgradeToAndCall(uint256 version, address implementation, bytes data) external payable onlyUpgradeabilityOwner { upgradeTo(version, implementation); // solhint-disable-next-line avoid-call-value require(address(this).call.value(msg.value)(data)); } } // File: contracts/upgradeability/EternalStorageProxy.sol pragma solidity 0.4.24; /** * @title EternalStorageProxy * @dev This proxy holds the storage of the token contract and delegates every call to the current implementation set. * Besides, it allows to upgrade the token's behaviour towards further implementations, and provides basic * authorization control functionalities */ // solhint-disable-next-line no-empty-blocks contract EternalStorageProxy is EternalStorage, OwnedUpgradeabilityProxy {}
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
[{"constant":false,"inputs":[{"name":"version","type":"uint256"},{"name":"implementation","type":"address"}],"name":"upgradeTo","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"version","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"implementation","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"upgradeabilityOwner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"version","type":"uint256"},{"name":"implementation","type":"address"},{"name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferProxyOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":false,"name":"previousOwner","type":"address"},{"indexed":false,"name":"newOwner","type":"address"}],"name":"ProxyOwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"version","type":"uint256"},{"indexed":true,"name":"implementation","type":"address"}],"name":"Upgraded","type":"event"}]
Deployed Bytecode
0x6080604052600436106100775763ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416633ad06d1681146100c257806354fd4d50146100e85780635c60da1b1461010f5780636fde820214610140578063a9c45fcb14610155578063f1739cae14610179575b600061008161019a565b9050600160a060020a038116151561009857600080fd5b60405136600082376000803683855af43d82016040523d6000833e8080156100be573d83f35b3d83fd5b3480156100ce57600080fd5b506100e6600435600160a060020a03602435166101a9565b005b3480156100f457600080fd5b506100fd6101d3565b60408051918252519081900360200190f35b34801561011b57600080fd5b5061012461019a565b60408051600160a060020a039092168252519081900360200190f35b34801561014c57600080fd5b506101246101d9565b6100e6600480359060248035600160a060020a0316916044359182019101356101e8565b34801561018557600080fd5b506100e6600160a060020a0360043516610250565b600854600160a060020a031690565b6101b16101d9565b600160a060020a031633146101c557600080fd5b6101cf82826102d8565b5050565b60075490565b600654600160a060020a031690565b6101f06101d9565b600160a060020a0316331461020457600080fd5b61020e84846101a9565b30600160a060020a03163483836040518083838082843782019150509250505060006040518083038185875af192505050151561024a57600080fd5b50505050565b6102586101d9565b600160a060020a0316331461026c57600080fd5b600160a060020a038116151561028157600080fd5b7f5a3e66efaa1e445ebd894728a69d6959842ea1e97bd79b892797106e270efcd96102aa6101d9565b60408051600160a060020a03928316815291841660208301528051918290030190a16102d58161037d565b50565b600854600160a060020a03828116911614156102f357600080fd5b6102fc816103ac565b151561030757600080fd5b600754821161031557600080fd5b600782905560088054600160a060020a03831673ffffffffffffffffffffffffffffffffffffffff1990911681179091556040805184815290517f4289d6195cf3c2d2174adf98d0e19d4d2d08887995b99cb7b100e7ffe795820e9181900360200190a25050565b6006805473ffffffffffffffffffffffffffffffffffffffff1916600160a060020a0392909216919091179055565b6000903b11905600a165627a7a72305820ae3fd294d84dbfc2de4a79453eb8740a34ab72fd30a021892afc5ad94deaf0e40029
Deployed Bytecode Sourcemap
12948:75:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2531:13;2547:16;:14;:16::i;:::-;2531:32;-1:-1:-1;;;;;;2582:19:0;;;;2574:28;;;;;;3040:4;3034:11;3821:12;3818:1;3813:3;3800:34;4752:1;4749;4735:12;4730:3;4723:5;4718:3;4705:49;5442:14;5437:3;5433:24;5427:4;5420:38;5952:14;5949:1;5944:3;5929:38;6234:6;6258:76;;;;6395:14;6390:3;6383:27;6258:76;6300:14;6295:3;6288:27;11441:145;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;11441:145:0;;;-1:-1:-1;;;;;11441:145:0;;;;;;;7047:85;;8:9:-1;5:2;;;30:1;27;20:12;5:2;7047:85:0;;;;;;;;;;;;;;;;;;;;7270:97;;8:9:-1;5:2;;;30:1;27;20:12;5:2;7270:97:0;;;;;;;;-1:-1:-1;;;;;7270:97:0;;;;;;;;;;;;;;9353:107;;8:9:-1;5:2;;;30:1;27;20:12;5:2;9353:107:0;;;;12171:321;;;;;;;;;-1:-1:-1;;;;;12171:321:0;;;;;;;;;;;;10897:250;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;10897:250:0;-1:-1:-1;;;;;10897:250:0;;;;;7270:97;7344:15;;-1:-1:-1;;;;;7344:15:0;7270:97;:::o;11441:145::-;10647:21;:19;:21::i;:::-;-1:-1:-1;;;;;10633:35:0;:10;:35;10625:44;;;;;;11543:35;11554:7;11563:14;11543:10;:35::i;:::-;11441:145;;:::o;7047:85::-;7116:8;;7047:85;:::o;9353:107::-;9432:20;;-1:-1:-1;;;;;9432:20:0;9353:107;:::o;12171:321::-;10647:21;:19;:21::i;:::-;-1:-1:-1;;;;;10633:35:0;:10;:35;10625:44;;;;;;12334:34;12344:7;12353:14;12334:9;:34::i;:::-;12450:4;-1:-1:-1;;;;;12442:18:0;12467:9;12478:4;;12442:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12434:50;;;;;;;;12171:321;;;;:::o;10897:250::-;10647:21;:19;:21::i;:::-;-1:-1:-1;;;;;10633:35:0;:10;:35;10625:44;;;;;;-1:-1:-1;;;;;10999:22:0;;;;10991:31;;;;;;11038:58;11064:21;:19;:21::i;:::-;11038:58;;;-1:-1:-1;;;;;11038:58:0;;;;;;;;;;;;;;;;;;;;;11107:32;11130:8;11107:22;:32::i;:::-;10897:250;:::o;8277:644::-;8366:15;;-1:-1:-1;;;;;8366:33:0;;;:15;;:33;;8358:42;;;;;;8516:39;8540:14;8516:23;:39::i;:::-;8508:48;;;;;;;;8781:8;;8771:18;;8763:27;;;;;;8803:8;:18;;;8832:15;:32;;-1:-1:-1;;;;;8832:32:0;;-1:-1:-1;;8832:32:0;;;;;;;;8880:33;;;;;;;;;;;;;;;;;8277:644;;:::o;9527:137::-;9611:20;:45;;-1:-1:-1;;9611:45:0;-1:-1:-1;;;;;9611:45:0;;;;;;;;;;9527:137::o;1171:589::-;1229:4;1713:18;;1746:8;;1171:589::o
Swarm Source
bzzr://ae3fd294d84dbfc2de4a79453eb8740a34ab72fd30a021892afc5ad94deaf0e4
Currently displaying ABI for the previous implementation contract at 0xa1ecfc2bec06e4b43ddd423b94fef84d0dbc8f5c, using the EIP-897 DelegateProxy concept.
Currently displaying ABI for the previous implementation contract at 0xa1ecfc2bec06e4b43ddd423b94fef84d0dbc8f5c, using the EIP-897 DelegateProxy concept.
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.
Address QR Code
My Address - Private Name Tag or Note
My Name Tag:
Private Note:
Please DO NOT store any passwords or private keys here.
The compiled contract might be susceptible to DirtyBytesArrayToStorage (low-severity), ABIDecodeTwoDimensionalArrayMemory (very low-severity), KeccakCaching (medium-severity), EmptyByteArrayCopy (medium-severity), DynamicArrayCleanup (medium-severity), ImplicitConstructorCallvalueCheck (very low-severity), TupleAssignmentMultiStackSlotComponents (very low-severity), MemoryArrayCreationOverflow (low-severity), privateCanBeOverridden (low-severity), SignedArrayStorageCopy (low/medium-severity), ABIEncoderV2StorageArrayWithMultiSlotElement (low-severity), DynamicConstructorArgumentsClippedABIV2 (very low-severity), UninitializedFunctionPointerInConstructor_0.4.x (very low-severity), IncorrectEventSignatureInLibraries_0.4.x (very low-severity), ABIEncoderV2PackedStorage_0.4.x (low-severity), ExpExponentCleanup (medium/high-severity), EventStructWrongData (very low-severity) Solidity Compiler Bugs.
Connect a Wallet
Connect a Wallet
Connect a Wallet
Address Cards
Before You Copy
This website uses cookies to improve your experience. By continuing to use this website, you agree to its Terms and Privacy Policy.