ETH Price: $3,609.12 (+9.33%)

Contract

0xF30Cf4ed712D3734161fDAab5B1DBb49Fd2D0E5c
 

Overview

ETH Balance

0 ETH

Eth Value

$0.00
Transaction Hash
Method
Block
From
To
Buy Voucher POL212807992024-11-27 18:13:351 hr ago1732731215IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0043301819.23423678
Buy Voucher212807282024-11-27 17:59:111 hr ago1732730351IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0055307124.18836157
Withdraw Rewards212807202024-11-27 17:57:351 hr ago1732730255IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0050393226.9157325
Unstake Claim To...212806232024-11-27 17:38:112 hrs ago1732729091IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.004516524.42410352
Buy Voucher POL212803472024-11-27 16:41:473 hrs ago1732725707IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0068648235.44271857
Sell Voucher_new212803102024-11-27 16:34:233 hrs ago1732725263IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0096568927.73973164
Buy Voucher212801012024-11-27 15:52:113 hrs ago1732722731IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0076425628.07816031
Withdraw Rewards212797242024-11-27 14:35:355 hrs ago1732718135IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0032227617.21323033
Unstake Claim To...212792882024-11-27 13:08:236 hrs ago1732712903IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.002957415.99288261
Buy Voucher POL212792032024-11-27 12:51:236 hrs ago1732711883IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0028830414.0529859
Unstake Claim To...212789032024-11-27 11:51:237 hrs ago1732708283IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.002509813.57239219
Buy Voucher212789012024-11-27 11:50:597 hrs ago1732708259IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0035205412.93418031
Unstake Claim To...212786462024-11-27 10:59:238 hrs ago1732705163IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0024538213.26967036
Sell Voucher_new212786262024-11-27 10:55:238 hrs ago1732704923IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0048317713.88039508
Buy Voucher POL212783642024-11-27 10:02:359 hrs ago1732701755IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.001913218.49829243
Buy Voucher212781162024-11-27 9:12:3510 hrs ago1732698755IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0027120510.21403342
Buy Voucher212780992024-11-27 9:09:1110 hrs ago1732698551IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0030378210.74348965
Buy Voucher POL212780902024-11-27 9:07:2310 hrs ago1732698443IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.00188959.45882023
Sell Voucher_new212776992024-11-27 7:48:5911 hrs ago1732693739IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0023411210.6992353
Buy Voucher212776882024-11-27 7:46:4711 hrs ago1732693607IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0024417310.90839828
Withdraw Rewards212776842024-11-27 7:45:5911 hrs ago1732693559IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0018861710.85514702
Unstake Claim To...212776822024-11-27 7:45:3511 hrs ago1732693535IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0021150711.43778485
Withdraw Rewards212776762024-11-27 7:44:2311 hrs ago1732693463IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0022548712.04360999
Buy Voucher212775192024-11-27 7:12:3512 hrs ago1732691555IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0023278410.39902125
Withdraw Rewards212775102024-11-27 7:10:4712 hrs ago1732691447IN
0xF30Cf4ed...9Fd2D0E5c
0 ETH0.0020087710.7291284
View all transactions

Latest 25 internal transactions (View All)

Advanced mode:
Parent Transaction Hash Block From To
212808412024-11-27 18:21:591 hr ago1732731719
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212808412024-11-27 18:21:591 hr ago1732731719
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212808412024-11-27 18:21:591 hr ago1732731719
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212808412024-11-27 18:21:591 hr ago1732731719
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212808412024-11-27 18:21:591 hr ago1732731719
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212808412024-11-27 18:21:591 hr ago1732731719
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212808412024-11-27 18:21:591 hr ago1732731719
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212808412024-11-27 18:21:591 hr ago1732731719
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807992024-11-27 18:13:351 hr ago1732731215
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807992024-11-27 18:13:351 hr ago1732731215
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807992024-11-27 18:13:351 hr ago1732731215
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807992024-11-27 18:13:351 hr ago1732731215
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807992024-11-27 18:13:351 hr ago1732731215
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807992024-11-27 18:13:351 hr ago1732731215
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807992024-11-27 18:13:351 hr ago1732731215
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807992024-11-27 18:13:351 hr ago1732731215
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807992024-11-27 18:13:351 hr ago1732731215
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807992024-11-27 18:13:351 hr ago1732731215
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807992024-11-27 18:13:351 hr ago1732731215
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807282024-11-27 17:59:111 hr ago1732730351
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807282024-11-27 17:59:111 hr ago1732730351
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807282024-11-27 17:59:111 hr ago1732730351
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807282024-11-27 17:59:111 hr ago1732730351
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807282024-11-27 17:59:111 hr ago1732730351
0xF30Cf4ed...9Fd2D0E5c
0 ETH
212807282024-11-27 17:59:111 hr ago1732730351
0xF30Cf4ed...9Fd2D0E5c
0 ETH
View All Internal Transactions
Loading...
Loading

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

Contract Name:
ValidatorShareProxy

Compiler Version
v0.5.17+commit.d19bba13

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, GNU GPLv3 license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2020-06-30
*/

// File: openzeppelin-solidity/contracts/ownership/Ownable.sol

pragma solidity ^0.5.2;

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev The Ownable constructor sets the original `owner` of the contract to the sender
     * account.
     */
    constructor () internal {
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), _owner);
    }

    /**
     * @return the address of the owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner());
        _;
    }

    /**
     * @return true if `msg.sender` is the owner of the contract.
     */
    function isOwner() public view returns (bool) {
        return msg.sender == _owner;
    }

    /**
     * @dev Allows the current owner to relinquish control of the contract.
     * It will not be possible to call the functions with the `onlyOwner`
     * modifier anymore.
     * @notice Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Allows the current owner to transfer control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0));
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: contracts/common/misc/ProxyStorage.sol

pragma solidity ^0.5.2;


contract ProxyStorage is Ownable {
    address internal proxyTo;
}

// File: contracts/common/misc/ERCProxy.sol

/*
 * SPDX-License-Identitifer:    MIT
 */

pragma solidity ^0.5.2;

// See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-897.md

interface ERCProxy {
    function proxyType() external pure returns (uint256 proxyTypeId);
    function implementation() external view returns (address codeAddr);
}

// File: contracts/common/misc/DelegateProxy.sol

pragma solidity ^0.5.2;



contract DelegateProxy is ERCProxy {
    function proxyType() external pure returns (uint256 proxyTypeId) {
        // Upgradeable proxy
        proxyTypeId = 2;
    }

    function implementation() external view returns (address);

    function delegatedFwd(address _dst, bytes memory _calldata) internal {
        // solium-disable-next-line security/no-inline-assembly
        assembly {
            let result := delegatecall(
                sub(gas, 10000),
                _dst,
                add(_calldata, 0x20),
                mload(_calldata),
                0,
                0
            )
            let size := returndatasize

            let ptr := mload(0x40)
            returndatacopy(ptr, 0, size)

            // revert instead of invalid() bc if the underlying call failed with invalid() it already wasted gas.
            // if the call returned error data, forward it
            switch result
                case 0 {
                    revert(ptr, size)
                }
                default {
                    return(ptr, size)
                }
        }
    }
}

// File: contracts/common/misc/UpgradableProxy.sol

pragma solidity ^0.5.2;


contract UpgradableProxy is DelegateProxy {
    event ProxyUpdated(address indexed _new, address indexed _old);
    event OwnerUpdate(address _new, address _old);

    bytes32 constant IMPLEMENTATION_SLOT = keccak256("matic.network.proxy.implementation");
    bytes32 constant OWNER_SLOT = keccak256("matic.network.proxy.owner");

    constructor(address _proxyTo) public {
        setOwner(msg.sender);
        setImplementation(_proxyTo);
    }

    function() external payable {
        // require(currentContract != 0, "If app code has not been set yet, do not call");
        // Todo: filter out some calls or handle in the end fallback
        delegatedFwd(loadImplementation(), msg.data);
    }

    modifier onlyProxyOwner() {
        require(loadOwner() == msg.sender, "NOT_OWNER");
        _;
    }

    function owner() external view returns(address) {
        return loadOwner();
    }

    function loadOwner() internal view returns(address) {
        address _owner;
        bytes32 position = OWNER_SLOT;
        assembly {
            _owner := sload(position)
        }
        return _owner;
    }

    function implementation() external view returns (address) {
        return loadImplementation();
    }

    function loadImplementation() internal view returns(address) {
        address _impl;
        bytes32 position = IMPLEMENTATION_SLOT;
        assembly {
            _impl := sload(position)
        }
        return _impl;
    }

    function transferOwnership(address newOwner) public onlyProxyOwner {
        require(newOwner != address(0), "ZERO_ADDRESS");
        emit OwnerUpdate(newOwner, loadOwner());
        setOwner(newOwner);
    }

    function setOwner(address newOwner) private {
        bytes32 position = OWNER_SLOT;
        assembly {
            sstore(position, newOwner)
        }
    }

    function updateImplementation(address _newProxyTo) public onlyProxyOwner {
        require(_newProxyTo != address(0x0), "INVALID_PROXY_ADDRESS");
        require(isContract(_newProxyTo), "DESTINATION_ADDRESS_IS_NOT_A_CONTRACT");

        emit ProxyUpdated(_newProxyTo, loadImplementation());
        
        setImplementation(_newProxyTo);
    }

    function updateAndCall(address _newProxyTo, bytes memory data) payable public onlyProxyOwner {
        updateImplementation(_newProxyTo);

        (bool success, bytes memory returnData) = address(this).call.value(msg.value)(data);
        require(success, string(returnData));
    }

    function setImplementation(address _newProxyTo) private {
        bytes32 position = IMPLEMENTATION_SLOT;
        assembly {
            sstore(position, _newProxyTo)
        }
    }
    
    function isContract(address _target) internal view returns (bool) {
        if (_target == address(0)) {
            return false;
        }

        uint256 size;
        assembly {
            size := extcodesize(_target)
        }
        return size > 0;
    }
}

// File: contracts/common/governance/IGovernance.sol

pragma solidity ^0.5.2;

interface IGovernance {
    function update(address target, bytes calldata data) external;
}

// File: contracts/common/governance/Governable.sol

pragma solidity ^0.5.2;


contract Governable {
    IGovernance public governance;

    constructor(address _governance) public {
        governance = IGovernance(_governance);
    }

    modifier onlyGovernance() {
        require(
            msg.sender == address(governance),
            "Only governance contract is authorized"
        );
        _;
    }
}

// File: contracts/root/withdrawManager/IWithdrawManager.sol

pragma solidity ^0.5.2;

contract IWithdrawManager {
    function createExitQueue(address token) external;

    function verifyInclusion(
        bytes calldata data,
        uint8 offset,
        bool verifyTxInclusion
    ) external view returns (uint256 age);

    function addExitToQueue(
        address exitor,
        address childToken,
        address rootToken,
        uint256 exitAmountOrTokenId,
        bytes32 txHash,
        bool isRegularExit,
        uint256 priority
    ) external;

    function addInput(
        uint256 exitId,
        uint256 age,
        address utxoOwner,
        address token
    ) external;

    function challengeExit(
        uint256 exitId,
        uint256 inputId,
        bytes calldata challengeData,
        address adjudicatorPredicate
    ) external;
}

// File: contracts/common/Registry.sol

pragma solidity ^0.5.2;




contract Registry is Governable {
    // @todo hardcode constants
    bytes32 private constant WETH_TOKEN = keccak256("wethToken");
    bytes32 private constant DEPOSIT_MANAGER = keccak256("depositManager");
    bytes32 private constant STAKE_MANAGER = keccak256("stakeManager");
    bytes32 private constant VALIDATOR_SHARE = keccak256("validatorShare");
    bytes32 private constant WITHDRAW_MANAGER = keccak256("withdrawManager");
    bytes32 private constant CHILD_CHAIN = keccak256("childChain");
    bytes32 private constant STATE_SENDER = keccak256("stateSender");
    bytes32 private constant SLASHING_MANAGER = keccak256("slashingManager");

    address public erc20Predicate;
    address public erc721Predicate;

    mapping(bytes32 => address) public contractMap;
    mapping(address => address) public rootToChildToken;
    mapping(address => address) public childToRootToken;
    mapping(address => bool) public proofValidatorContracts;
    mapping(address => bool) public isERC721;

    enum Type {Invalid, ERC20, ERC721, Custom}
    struct Predicate {
        Type _type;
    }
    mapping(address => Predicate) public predicates;

    event TokenMapped(address indexed rootToken, address indexed childToken);
    event ProofValidatorAdded(address indexed validator, address indexed from);
    event ProofValidatorRemoved(address indexed validator, address indexed from);
    event PredicateAdded(address indexed predicate, address indexed from);
    event PredicateRemoved(address indexed predicate, address indexed from);
    event ContractMapUpdated(bytes32 indexed key, address indexed previousContract, address indexed newContract);

    constructor(address _governance) public Governable(_governance) {}

    function updateContractMap(bytes32 _key, address _address) external onlyGovernance {
        emit ContractMapUpdated(_key, contractMap[_key], _address);
        contractMap[_key] = _address;
    }

    /**
     * @dev Map root token to child token
     * @param _rootToken Token address on the root chain
     * @param _childToken Token address on the child chain
     * @param _isERC721 Is the token being mapped ERC721
     */
    function mapToken(
        address _rootToken,
        address _childToken,
        bool _isERC721
    ) external onlyGovernance {
        require(_rootToken != address(0x0) && _childToken != address(0x0), "INVALID_TOKEN_ADDRESS");
        rootToChildToken[_rootToken] = _childToken;
        childToRootToken[_childToken] = _rootToken;
        isERC721[_rootToken] = _isERC721;
        IWithdrawManager(contractMap[WITHDRAW_MANAGER]).createExitQueue(_rootToken);
        emit TokenMapped(_rootToken, _childToken);
    }

    function addErc20Predicate(address predicate) public onlyGovernance {
        require(predicate != address(0x0), "Can not add null address as predicate");
        erc20Predicate = predicate;
        addPredicate(predicate, Type.ERC20);
    }

    function addErc721Predicate(address predicate) public onlyGovernance {
        erc721Predicate = predicate;
        addPredicate(predicate, Type.ERC721);
    }

    function addPredicate(address predicate, Type _type) public onlyGovernance {
        require(predicates[predicate]._type == Type.Invalid, "Predicate already added");
        predicates[predicate]._type = _type;
        emit PredicateAdded(predicate, msg.sender);
    }

    function removePredicate(address predicate) public onlyGovernance {
        require(predicates[predicate]._type != Type.Invalid, "Predicate does not exist");
        delete predicates[predicate];
        emit PredicateRemoved(predicate, msg.sender);
    }

    function getValidatorShareAddress() public view returns (address) {
        return contractMap[VALIDATOR_SHARE];
    }

    function getWethTokenAddress() public view returns (address) {
        return contractMap[WETH_TOKEN];
    }

    function getDepositManagerAddress() public view returns (address) {
        return contractMap[DEPOSIT_MANAGER];
    }

    function getStakeManagerAddress() public view returns (address) {
        return contractMap[STAKE_MANAGER];
    }

    function getSlashingManagerAddress() public view returns (address) {
        return contractMap[SLASHING_MANAGER];
    }

    function getWithdrawManagerAddress() public view returns (address) {
        return contractMap[WITHDRAW_MANAGER];
    }

    function getChildChainAndStateSender() public view returns (address, address) {
        return (contractMap[CHILD_CHAIN], contractMap[STATE_SENDER]);
    }

    function isTokenMapped(address _token) public view returns (bool) {
        return rootToChildToken[_token] != address(0x0);
    }

    function isTokenMappedAndIsErc721(address _token) public view returns (bool) {
        require(isTokenMapped(_token), "TOKEN_NOT_MAPPED");
        return isERC721[_token];
    }

    function isTokenMappedAndGetPredicate(address _token) public view returns (address) {
        if (isTokenMappedAndIsErc721(_token)) {
            return erc721Predicate;
        }
        return erc20Predicate;
    }

    function isChildTokenErc721(address childToken) public view returns (bool) {
        address rootToken = childToRootToken[childToken];
        require(rootToken != address(0x0), "Child token is not mapped");
        return isERC721[rootToken];
    }
}

// File: contracts/staking/validatorShare/ValidatorShareProxy.sol

pragma solidity ^0.5.2;



contract ValidatorShareProxy is UpgradableProxy {
    constructor(address _registry) public UpgradableProxy(_registry) {}

    function loadImplementation() internal view returns (address) {
        return Registry(super.loadImplementation()).getValidatorShareAddress();
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_registry","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_new","type":"address"},{"indexed":false,"internalType":"address","name":"_old","type":"address"}],"name":"OwnerUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_new","type":"address"},{"indexed":true,"internalType":"address","name":"_old","type":"address"}],"name":"ProxyUpdated","type":"event"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"constant":true,"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"proxyType","outputs":[{"internalType":"uint256","name":"proxyTypeId","type":"uint256"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_newProxyTo","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"updateAndCall","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_newProxyTo","type":"address"}],"name":"updateImplementation","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

Deployed Bytecode

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

Deployed Bytecode Sourcemap

14333:284:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4800:44;4813:20;:18;:20::i;:::-;4835:8;;4800:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;4800:12:0;;-1:-1:-1;;;4800:44:0:i;:::-;14333:284;6037:353;;8:9:-1;5:2;;;30:1;27;20:12;5:2;6037:353:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;6037:353:0;-1:-1:-1;;;;;6037:353:0;;:::i;2950:129::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2950:129:0;;;:::i;:::-;;;;;;;;;;;;;;;;5292:104;;8:9:-1;5:2;;;30:1;27;20:12;5:2;5292:104:0;;;:::i;:::-;;;;-1:-1:-1;;;;;5292:104:0;;;;;;;;;;;;;;4972:85;;8:9:-1;5:2;;;30:1;27;20:12;5:2;4972:85:0;;;:::i;6398:288::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;6398:288:0;;;;;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;6398:288:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;6398:288:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;6398:288:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;6398:288:0;;-1:-1:-1;6398:288:0;;-1:-1:-1;;;;;6398:288:0:i;5646:212::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;5646:212:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;5646:212:0;-1:-1:-1;;;;;5646:212:0;;:::i;14463:151::-;14516:7;14552:26;:24;:26::i;:::-;-1:-1:-1;;;;;14543:61:0;;:63;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;14543:63:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;14543:63:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;14543:63:0;;-1:-1:-1;14463:151:0;:::o;3153:892::-;3518:1;3498;3469:9;3463:16;3439:4;3428:9;3424:20;3401:4;3376:5;3371:3;3367:15;3336:198;3560:14;3607:4;3601:11;3649:4;3646:1;3641:3;3626:28;3852:6;3876:66;;;;4003:4;3998:3;3991:17;3876:66;3918:4;3913:3;3906:17;6037:353;4920:10;4905:11;:9;:11::i;:::-;-1:-1:-1;;;;;4905:25:0;;4897:47;;;;;-1:-1:-1;;;4897:47:0;;;;;;;;;;;;-1:-1:-1;;;4897:47:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;6129:27:0;;6121:61;;;;;-1:-1:-1;;;6121:61:0;;;;;;;;;;;;-1:-1:-1;;;6121:61:0;;;;;;;;;;;;;;;6201:23;6212:11;6201:10;:23::i;:::-;6193:73;;;;-1:-1:-1;;;6193:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6310:20;:18;:20::i;:::-;-1:-1:-1;;;;;6284:47:0;6297:11;-1:-1:-1;;;;;6284:47:0;;;;;;;;;;;6352:30;6370:11;6352:17;:30::i;:::-;6037:353;:::o;2950:129::-;3070:1;;2950:129::o;5292:104::-;5341:7;5368:20;:18;:20::i;:::-;5361:27;;5292:104;:::o;4972:85::-;5011:7;5038:11;:9;:11::i;6398:288::-;4920:10;4905:11;:9;:11::i;:::-;-1:-1:-1;;;;;4905:25:0;;4897:47;;;;;-1:-1:-1;;;4897:47:0;;;;;;;;;;;;-1:-1:-1;;;4897:47:0;;;;;;;;;;;;;;;6502:33;6523:11;6502:20;:33::i;:::-;6549:12;6563:23;6598:4;-1:-1:-1;;;;;6590:18:0;6615:9;6626:4;6590:41;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;6590:41:0;;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;6548:83:0;;;;6650:7;6666:10;6642:36;;;;;-1:-1:-1;;;6642:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;6642:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4955:1;;6398:288;;:::o;5646:212::-;4920:10;4905:11;:9;:11::i;:::-;-1:-1:-1;;;;;4905:25:0;;4897:47;;;;;-1:-1:-1;;;4897:47:0;;;;;;;;;;;;-1:-1:-1;;;4897:47:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;5732:22:0;;5724:47;;;;;-1:-1:-1;;;5724:47:0;;;;;;;;;;;;-1:-1:-1;;;5724:47:0;;;;;;;;;;;;;;;5787:34;5799:8;5809:11;:9;:11::i;:::-;5787:34;;;-1:-1:-1;;;;;5787:34:0;;;;;;;;;;;;;;;;;;;;;;;;5832:18;5841:8;5832;:18::i;5404:234::-;5456:7;5476:13;5500:16;4346:47;;;;;;;;;;;;;;;;;;5582:15;;-1:-1:-1;;;;5404:234:0;:::o;5065:219::-;4430:38;;;-1:-1:-1;;;4430:38:0;;;;;;;;;;;;5227:15;5065:219;:::o;6893:274::-;6953:4;-1:-1:-1;;;;;6974:21:0;;6970:66;;-1:-1:-1;7019:5:0;7012:12;;6970:66;-1:-1:-1;7103:20:0;;7151:8;;6893:274;;;;:::o;6694:187::-;6761:16;4346:47;;;;;;;;;;;;;;;;;;6834:29;;;;-1:-1:-1;;6819:55:0:o;5866:163::-;4430:38;;;-1:-1:-1;;;4430:38:0;;;;;;;;;;;;5985:26;5970:52::o

Swarm Source

bzzr://4e58170e48279b1cb90d113d92d52be59f280dddbca7b51d796c43ef066a09b0

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

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

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
Loading...
Loading
[ Download: CSV Export  ]

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