Goerli Testnet

Contract

0x01268DB05965CeAc2a89566c42CD550ED7eE5ECD
Source Code
Transaction Hash
Method
Block
From
To
Value
Execute Signatur...94710812023-08-06 8:19:00125 days 23 hrs ago1691309940IN
0x01268D...D7eE5ECD
0 ETH0.00043883
Execute Signatur...94710652023-08-06 8:15:00125 days 23 hrs ago1691309700IN
0x01268D...D7eE5ECD
0 ETH0.0014626810
Execute Signatur...94451982023-08-01 15:04:12130 days 17 hrs ago1690902252IN
0x01268D...D7eE5ECD
0 ETH0.000174021.00078959
Execute Signatur...94448402023-08-01 13:30:24130 days 18 hrs ago1690896624IN
0x01268D...D7eE5ECD
0 ETH0.000173911.00016369
Execute Signatur...94448382023-08-01 13:30:00130 days 18 hrs ago1690896600IN
0x01268D...D7eE5ECD
0 ETH0.000173911.00018079
Execute Signatur...94447082023-08-01 12:54:36130 days 19 hrs ago1690894476IN
0x01268D...D7eE5ECD
0 ETH0.000173911.00022313
Execute Signatur...94446782023-08-01 12:47:48130 days 19 hrs ago1690894068IN
0x01268D...D7eE5ECD
0 ETH0.0014625810
Execute Signatur...94443982023-08-01 11:37:24130 days 20 hrs ago1690889844IN
0x01268D...D7eE5ECD
0 ETH0.000170781.0016298
Execute Signatur...94439592023-08-01 9:40:24130 days 22 hrs ago1690882824IN
0x01268D...D7eE5ECD
0 ETH0.000171361.00503149
Execute Signatur...94438822023-08-01 9:19:48130 days 22 hrs ago1690881588IN
0x01268D...D7eE5ECD
0 ETH0.000170831.0019982
Execute Signatur...94436862023-08-01 8:26:48130 days 23 hrs ago1690878408IN
0x01268D...D7eE5ECD
0 ETH0.000170491.000008
Execute Signatur...94436362023-08-01 8:13:00130 days 23 hrs ago1690877580IN
0x01268D...D7eE5ECD
0 ETH0.000170491.0000045
Execute Signatur...94434542023-08-01 7:26:12131 days 39 mins ago1690874772IN
0x01268D...D7eE5ECD
0 ETH0.000170481.00000027
Execute Signatur...94432762023-08-01 6:41:12131 days 1 hr ago1690872072IN
0x01268D...D7eE5ECD
0 ETH0.00017051.00000015
Execute Signatur...94431742023-08-01 6:15:12131 days 1 hr ago1690870512IN
0x01268D...D7eE5ECD
0 ETH0.00017051.00000006
Execute Signatur...94428922023-08-01 5:02:36131 days 3 hrs ago1690866156IN
0x01268D...D7eE5ECD
0 ETH0.000255731.50000001
Execute Signatur...94408862023-07-31 20:31:00131 days 11 hrs ago1690835460IN
0x01268D...D7eE5ECD
0 ETH0.0014626810
Execute Signatur...94408652023-07-31 20:26:12131 days 11 hrs ago1690835172IN
0x01268D...D7eE5ECD
0 ETH0.0014625810
Execute Signatur...94408622023-07-31 20:25:36131 days 11 hrs ago1690835136IN
0x01268D...D7eE5ECD
0 ETH0.0014626810
Execute Signatur...94408622023-07-31 20:25:36131 days 11 hrs ago1690835136IN
0x01268D...D7eE5ECD
0 ETH0.0014625810
Execute Signatur...94376572023-07-31 6:47:00132 days 1 hr ago1690786020IN
0x01268D...D7eE5ECD
0 ETH0.000173881.00000007
Execute Signatur...94376032023-07-31 6:34:12132 days 1 hr ago1690785252IN
0x01268D...D7eE5ECD
0 ETH0.000173881.00000012
Execute Signatur...94342542023-07-30 16:11:24132 days 15 hrs ago1690733484IN
0x01268D...D7eE5ECD
0 ETH0.000156241.00000005
Execute Signatur...94341962023-07-30 15:56:12132 days 16 hrs ago1690732572IN
0x01268D...D7eE5ECD
0 ETH0.000156241.00000005
Execute Signatur...94341632023-07-30 15:47:12132 days 16 hrs ago1690732032IN
0x01268D...D7eE5ECD
0 ETH0.000161511.00000007
View all transactions

Latest 25 internal transactions (View All)

Advanced mode:
Parent Txn Hash Block From To Value
101884002023-12-10 7:12:1253 mins ago1702192332
0x01268D...D7eE5ECD
0 ETH
101884002023-12-10 7:12:1253 mins ago1702192332
0x01268D...D7eE5ECD
0 ETH
101881702023-12-10 6:12:121 hr 53 mins ago1702188732
0x01268D...D7eE5ECD
0 ETH
101881702023-12-10 6:12:121 hr 53 mins ago1702188732
0x01268D...D7eE5ECD
0 ETH
101879422023-12-10 5:12:242 hrs 53 mins ago1702185144
0x01268D...D7eE5ECD
0 ETH
101879422023-12-10 5:12:242 hrs 53 mins ago1702185144
0x01268D...D7eE5ECD
0 ETH
101877172023-12-10 4:12:123 hrs 53 mins ago1702181532
0x01268D...D7eE5ECD
0 ETH
101877172023-12-10 4:12:123 hrs 53 mins ago1702181532
0x01268D...D7eE5ECD
0 ETH
101874932023-12-10 3:12:244 hrs 53 mins ago1702177944
0x01268D...D7eE5ECD
0 ETH
101874932023-12-10 3:12:244 hrs 53 mins ago1702177944
0x01268D...D7eE5ECD
0 ETH
101872662023-12-10 2:12:245 hrs 53 mins ago1702174344
0x01268D...D7eE5ECD
0 ETH
101872662023-12-10 2:12:245 hrs 53 mins ago1702174344
0x01268D...D7eE5ECD
0 ETH
101870352023-12-10 1:12:126 hrs 53 mins ago1702170732
0x01268D...D7eE5ECD
0 ETH
101870352023-12-10 1:12:126 hrs 53 mins ago1702170732
0x01268D...D7eE5ECD
0 ETH
101867942023-12-10 0:13:007 hrs 53 mins ago1702167180
0x01268D...D7eE5ECD
0 ETH
101867942023-12-10 0:13:007 hrs 53 mins ago1702167180
0x01268D...D7eE5ECD
0 ETH
101865582023-12-09 23:12:248 hrs 53 mins ago1702163544
0x01268D...D7eE5ECD
0 ETH
101865582023-12-09 23:12:248 hrs 53 mins ago1702163544
0x01268D...D7eE5ECD
0 ETH
101863322023-12-09 22:12:129 hrs 53 mins ago1702159932
0x01268D...D7eE5ECD
0 ETH
101863322023-12-09 22:12:129 hrs 53 mins ago1702159932
0x01268D...D7eE5ECD
0 ETH
101861062023-12-09 21:12:1210 hrs 53 mins ago1702156332
0x01268D...D7eE5ECD
0 ETH
101861062023-12-09 21:12:1210 hrs 53 mins ago1702156332
0x01268D...D7eE5ECD
0 ETH
101858702023-12-09 20:12:2411 hrs 53 mins ago1702152744
0x01268D...D7eE5ECD
0 ETH
101858702023-12-09 20:12:2411 hrs 53 mins ago1702152744
0x01268D...D7eE5ECD
0 ETH
101856292023-12-09 19:12:2412 hrs 53 mins ago1702149144
0x01268D...D7eE5ECD
0 ETH
View All Internal Transactions
Loading...
Loading

Similar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0x9B5125...6b21ffbE
The constructor portion of the code might be different and could alter the actual behaviour of the contract

Contract Name:
EternalStorageProxy

Compiler Version
v0.4.24+commit.e67f0147

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license
/**
 *Submitted for verification at Etherscan.io on 2020-12-24
*/

/**
 *Submitted for verification at Etherscan.io on 2020-12-15
*/

// 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 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

0x6080604052600436106100775763ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416633ad06d1681146100c257806354fd4d50146100e85780635c60da1b1461010f5780636fde820214610140578063a9c45fcb14610155578063f1739cae14610179575b600061008161019a565b9050600160a060020a038116151561009857600080fd5b60405136600082376000803683855af43d82016040523d6000833e8080156100be573d83f35b3d83fd5b3480156100ce57600080fd5b506100e6600435600160a060020a03602435166101a9565b005b3480156100f457600080fd5b506100fd6101d3565b60408051918252519081900360200190f35b34801561011b57600080fd5b5061012461019a565b60408051600160a060020a039092168252519081900360200190f35b34801561014c57600080fd5b506101246101d9565b6100e6600480359060248035600160a060020a0316916044359182019101356101e8565b34801561018557600080fd5b506100e6600160a060020a0360043516610250565b600854600160a060020a031690565b6101b16101d9565b600160a060020a031633146101c557600080fd5b6101cf82826102d8565b5050565b60075490565b600654600160a060020a031690565b6101f06101d9565b600160a060020a0316331461020457600080fd5b61020e84846101a9565b30600160a060020a03163483836040518083838082843782019150509250505060006040518083038185875af192505050151561024a57600080fd5b50505050565b6102586101d9565b600160a060020a0316331461026c57600080fd5b600160a060020a038116151561028157600080fd5b7f5a3e66efaa1e445ebd894728a69d6959842ea1e97bd79b892797106e270efcd96102aa6101d9565b60408051600160a060020a03928316815291841660208301528051918290030190a16102d58161037d565b50565b600854600160a060020a03828116911614156102f357600080fd5b6102fc816103ac565b151561030757600080fd5b600754821161031557600080fd5b600782905560088054600160a060020a03831673ffffffffffffffffffffffffffffffffffffffff1990911681179091556040805184815290517f4289d6195cf3c2d2174adf98d0e19d4d2d08887995b99cb7b100e7ffe795820e9181900360200190a25050565b6006805473ffffffffffffffffffffffffffffffffffffffff1916600160a060020a0392909216919091179055565b6000903b11905600a165627a7a7230582078bac02704e0c07980df83f6082a0453ef0e0259d68860b6e0f2c5dc0d11c56c0029

Deployed Bytecode Sourcemap

12946: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://78bac02704e0c07980df83f6082a0453ef0e0259d68860b6e0f2c5dc0d11c56c

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Txn Hash Block Value Eth2 PubKey Valid
View All Deposits
[ Download: CSV Export  ]
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.