Contract

0x101D8b63A081dFfF2B1364864345b7F071b052ac

Source Code

Overview

ETH Balance

0 ETH

Eth Value

$0.00

Token Holdings

More Info

Private Name Tags

Add

ContractCreator

NEST Protocol: Deployer at txn 0xeee7022a8ee1d6c7dc5399637d989e750571f90b9fa5261a623943054815e9e0

Multichain Info

$0 (Multichain Portfolio)

No addresses found

Advanced Filter

Latest 3 from a total of 3 transactions

Transaction Hash	Method	Block		From		To	Value
0x1c4548b19d7946e77232c880e51b862989f2df963cfa3885ba532672c36c5f26	Change Mapping	10469604	2020-07-16 8:54:27	1388 days ago	1594889667	NEST Protocol: Deployer	IN	0x101D8b63...071b052ac	0.00199479	55
0x7fe97b09d7e7144c014a0edac83e2118538220dfff30e1a02ed565bb5439be01	Change Mapping	10449710	2020-07-13 7:02:27	1391 days ago	1594623747	NEST Protocol: Deployer	IN	0x101D8b63...071b052ac	0.00217908	60
0xeee7022a8ee1d6c7dc5399637d989e750571f90b9fa5261a623943054815e9e0	0x60806040	8340424	2019-08-13 5:53:15	1726 days ago	1565675595	NEST Protocol: Deployer	IN	Create: NEST_NodeSave	0.00111251	3

View more zero value Internal Transactions in Advanced View mode

Advanced mode:

Contract Source Code Verified (Exact Match)

Contract Name:

NEST_NodeSave

Compiler Version

v0.5.10+commit.5a6ea5b1

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, GNU GPLv3 license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2020-04-25
*/

pragma solidity ^0.5.10;

/**
 * @title Guardian node nest storage
 */
contract NEST_NodeSave {
    IBMapping mappingContract;                      
    IBNEST nestContract;                             
    
    /**
    * @dev Initialization method
    * @param map Mapping contract address
    */
    constructor (address map) public {
        mappingContract = IBMapping(address(map));              
        nestContract = IBNEST(address(mappingContract.checkAddress("nest")));            
    }
    
    /**
    * @dev Change mapping contract
    * @param map Mapping contract address
    */
    function changeMapping(address map) public onlyOwner {
        mappingContract = IBMapping(address(map));              
        nestContract = IBNEST(address(mappingContract.checkAddress("nest")));            
    }
    
    /**
    * @dev Transfer out nest
    * @param amount Transfer out quantity
    * @param to Transfer out target
    * @return Actual transfer out quantity
    */
    function turnOut(uint256 amount, address to) public onlyMiningCalculation returns(uint256) {
        uint256 leftNum = nestContract.balanceOf(address(this));
        if (leftNum >= amount) {
            nestContract.transfer(to, amount);
            return amount;
        } else {
            return 0;
        }
    }
    
    modifier onlyOwner(){
        require(mappingContract.checkOwners(msg.sender) == true);
        _;
    }

    modifier onlyMiningCalculation(){
        require(address(mappingContract.checkAddress("nodeAssignment")) == msg.sender);
        _;
    }
    
}

/**
 * @title Guardian node receives data
 */
contract NEST_NodeAssignmentData {
    using SafeMath for uint256;
    IBMapping mappingContract;              
    uint256 nodeAllAmount = 0;                                 
    mapping(address => uint256) nodeLatestAmount;               
    
    /**
    * @dev Initialization method
    * @param map Mapping contract address
    */
    constructor (address map) public {
        mappingContract = IBMapping(map); 
    }
    
    /**
    * @dev Change mapping contract
    * @param map Mapping contract address
    */
    function changeMapping(address map) public onlyOwner{
        mappingContract = IBMapping(map); 
    }
    
    //  Add nest
    function addNest(uint256 amount) public onlyNodeAssignment {
        nodeAllAmount = nodeAllAmount.add(amount);
    }
    
    //  View cumulative total
    function checkNodeAllAmount() public view returns (uint256) {
        return nodeAllAmount;
    }
    
    //  Record last received quantity
    function addNodeLatestAmount(address add ,uint256 amount) public onlyNodeAssignment {
        nodeLatestAmount[add] = amount;
    }
    
    //  View last received quantity
    function checkNodeLatestAmount(address add) public view returns (uint256) {
        return nodeLatestAmount[address(add)];
    }
    
    modifier onlyOwner(){
        require(mappingContract.checkOwners(msg.sender) == true);
        _;
    }
    
    modifier onlyNodeAssignment(){
        require(address(msg.sender) == address(mappingContract.checkAddress("nodeAssignment")));
        _;
    }
}

/**
 * @title Guardian node assignment
 */
contract NEST_NodeAssignment {
    
    using SafeMath for uint256;
    IBMapping mappingContract;  
    IBNEST nestContract;                                   
    SuperMan supermanContract;                              
    NEST_NodeSave nodeSave;
    NEST_NodeAssignmentData nodeAssignmentData;

    /**
    * @dev Initialization method
    * @param map Mapping contract address
    */
    constructor (address map) public {
        mappingContract = IBMapping(map); 
        nestContract = IBNEST(address(mappingContract.checkAddress("nest")));
        supermanContract = SuperMan(address(mappingContract.checkAddress("nestNode")));
        nodeSave = NEST_NodeSave(address(mappingContract.checkAddress("nestNodeSave")));
        nodeAssignmentData = NEST_NodeAssignmentData(address(mappingContract.checkAddress("nodeAssignmentData")));
    }
    
    /**
    * @dev Change mapping contract
    * @param map Mapping contract address
    */
    function changeMapping(address map) public onlyOwner{
        mappingContract = IBMapping(map); 
        nestContract = IBNEST(address(mappingContract.checkAddress("nest")));
        supermanContract = SuperMan(address(mappingContract.checkAddress("nestNode")));
        nodeSave = NEST_NodeSave(address(mappingContract.checkAddress("nestNodeSave")));
        nodeAssignmentData = NEST_NodeAssignmentData(address(mappingContract.checkAddress("nodeAssignmentData")));
    }
    
    /**
    * @dev Deposit in nest
    * @param amount Quantity deposited in nest
    */
    function bookKeeping(uint256 amount) public {
        require(amount > 0);
        require(nestContract.balanceOf(address(msg.sender)) >= amount);
        require(nestContract.allowance(address(msg.sender), address(this)) >= amount);
        require(nestContract.transferFrom(address(msg.sender), address(nodeSave), amount));
        nodeAssignmentData.addNest(amount);
    }
    
    /**
    * @dev Guardian node collection
    */
    function nodeGet() public {
        require(address(msg.sender) == address(tx.origin));
        require(supermanContract.balanceOf(address(msg.sender)) > 0);
        uint256 allAmount = nodeAssignmentData.checkNodeAllAmount();
        uint256 amount = allAmount.sub(nodeAssignmentData.checkNodeLatestAmount(address(msg.sender)));
        uint256 getAmount = amount.mul(supermanContract.balanceOf(address(msg.sender))).div(1500);
        require(nestContract.balanceOf(address(nodeSave)) >= getAmount);
        nodeSave.turnOut(getAmount,address(msg.sender));
        nodeAssignmentData.addNodeLatestAmount(address(msg.sender),allAmount);
    }
    
    /**
    * @dev Transfer settlement
    * @param fromAdd Transfer out address
    * @param toAdd Transfer in address
    */
    function nodeCount(address fromAdd, address toAdd) public {
        require(address(supermanContract) == address(msg.sender));
        require(supermanContract.balanceOf(address(fromAdd)) > 0);
        uint256 allAmount = nodeAssignmentData.checkNodeAllAmount();
        
        uint256 amountFrom = allAmount.sub(nodeAssignmentData.checkNodeLatestAmount(address(fromAdd)));
        uint256 getAmountFrom = amountFrom.mul(supermanContract.balanceOf(address(fromAdd))).div(1500);
        require(nestContract.balanceOf(address(nodeSave)) >= getAmountFrom);
        nodeSave.turnOut(getAmountFrom,address(fromAdd));
        nodeAssignmentData.addNodeLatestAmount(address(fromAdd),allAmount);
        
        uint256 amountTo = allAmount.sub(nodeAssignmentData.checkNodeLatestAmount(address(toAdd)));
        uint256 getAmountTo = amountTo.mul(supermanContract.balanceOf(address(toAdd))).div(1500);
        require(nestContract.balanceOf(address(nodeSave)) >= getAmountTo);
        nodeSave.turnOut(getAmountTo,address(toAdd));
        nodeAssignmentData.addNodeLatestAmount(address(toAdd),allAmount);
    }
    
    //  Amount available to the guardian node
    function checkNodeNum() public view returns (uint256) {
         uint256 allAmount = nodeAssignmentData.checkNodeAllAmount();
         uint256 amount = allAmount.sub(nodeAssignmentData.checkNodeLatestAmount(address(msg.sender)));
         uint256 getAmount = amount.mul(supermanContract.balanceOf(address(msg.sender))).div(1500);
         return getAmount;
    }
    
    modifier onlyOwner(){
        require(mappingContract.checkOwners(msg.sender) == true);
        _;
    }
}


/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
interface IERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address who) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);

    function transfer(address to, uint256 value) external returns (bool);

    function approve(address spender, uint256 value) external returns (bool);

    function transferFrom(address from, address to, uint256 value) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
    
}

/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
 * Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 *
 * This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
 * all accounts just by listening to said events. Note that this isn't required by the specification, and other
 * compliant implementations may not do it.
 */
contract SuperMan is IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowed;
    
    IBMapping mappingContract;  //映射合约

    uint256 private _totalSupply = 1500;
    string public name = "NestNode";
    string public symbol = "NN";
    uint8 public decimals = 0;

    constructor (address map) public {
    	_balances[msg.sender] = _totalSupply;
    	mappingContract = IBMapping(map); 
    }
    
    function changeMapping(address map) public onlyOwner{
        mappingContract = IBMapping(map);
    }
    
    /**
    * @dev Total number of tokens in existence
    */
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    /**
    * @dev Gets the balance of the specified address.
    * @param owner The address to query the balance of.
    * @return An uint256 representing the amount owned by the passed address.
    */
    function balanceOf(address owner) public view returns (uint256) {
        return _balances[owner];
    }

    /**
     * @dev Function to check the amount of tokens that an owner allowed to a spender.
     * @param owner address The address which owns the funds.
     * @param spender address The address which will spend the funds.
     * @return A uint256 specifying the amount of tokens still available for the spender.
     */
    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowed[owner][spender];
    }

    /**
    * @dev Transfer token for a specified address
    * @param to The address to transfer to.
    * @param value The amount to be transferred.
    */
    function transfer(address to, uint256 value) public returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    /**
     * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
     * Beware that changing an allowance with this method brings the risk that someone may use both the old
     * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
     * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     */
    function approve(address spender, uint256 value) public returns (bool) {
        require(spender != address(0));

        _allowed[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }

    /**
     * @dev Transfer tokens from one address to another.
     * Note that while this function emits an Approval event, this is not required as per the specification,
     * and other compliant implementations may not emit the event.
     * @param from address The address which you want to send tokens from
     * @param to address The address which you want to transfer to
     * @param value uint256 the amount of tokens to be transferred
     */
    function transferFrom(address from, address to, uint256 value) public returns (bool) {
        _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
        _transfer(from, to, value);
        emit Approval(from, msg.sender, _allowed[from][msg.sender]);
        return true;
    }

    /**
     * @dev Increase the amount of tokens that an owner allowed to a spender.
     * approve should be called when allowed_[_spender] == 0. To increment
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * Emits an Approval event.
     * @param spender The address which will spend the funds.
     * @param addedValue The amount of tokens to increase the allowance by.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        require(spender != address(0));

        _allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
        emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
        return true;
    }

    /**
     * @dev Decrease the amount of tokens that an owner allowed to a spender.
     * approve should be called when allowed_[_spender] == 0. To decrement
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * Emits an Approval event.
     * @param spender The address which will spend the funds.
     * @param subtractedValue The amount of tokens to decrease the allowance by.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        require(spender != address(0));

        _allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
        emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
        return true;
    }

    /**
    * @dev Transfer token for a specified addresses
    * @param from The address to transfer from.
    * @param to The address to transfer to.
    * @param value The amount to be transferred.
    */
    function _transfer(address from, address to, uint256 value) internal {
        require(to != address(0));
        
        NEST_NodeAssignment nodeAssignment = NEST_NodeAssignment(address(mappingContract.checkAddress("nodeAssignment")));
        nodeAssignment.nodeCount(from, to);
        
        _balances[from] = _balances[from].sub(value);
        _balances[to] = _balances[to].add(value);
        emit Transfer(from, to, value);
        
        
    }
    
    modifier onlyOwner(){
        require(mappingContract.checkOwners(msg.sender) == true);
        _;
    }
}

/**
 * @title SafeMath
 * @dev Math operations with safety checks that revert on error
 */
library SafeMath {
    int256 constant private INT256_MIN = -2**255;

    /**
    * @dev Multiplies two unsigned integers, reverts on overflow.
    */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // 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-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b);

        return c;
    }

    /**
    * @dev Multiplies two signed integers, reverts on overflow.
    */
    function mul(int256 a, int256 b) internal pure returns (int256) {
        // 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-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        require(!(a == -1 && b == INT256_MIN)); // This is the only case of overflow not detected by the check below

        int256 c = a * b;
        require(c / a == b);

        return c;
    }

    /**
    * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
    */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
    * @dev Integer division of two signed integers truncating the quotient, reverts on division by zero.
    */
    function div(int256 a, int256 b) internal pure returns (int256) {
        require(b != 0); // Solidity only automatically asserts when dividing by 0
        require(!(b == -1 && a == INT256_MIN)); // This is the only case of overflow

        int256 c = a / b;

        return c;
    }

    /**
    * @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
    */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a);
        uint256 c = a - b;

        return c;
    }

    /**
    * @dev Subtracts two signed integers, reverts on overflow.
    */
    function sub(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a - b;
        require((b >= 0 && c <= a) || (b < 0 && c > a));

        return c;
    }

    /**
    * @dev Adds two unsigned integers, reverts on overflow.
    */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a);

        return c;
    }

    /**
    * @dev Adds two signed integers, reverts on overflow.
    */
    function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a + b;
        require((b >= 0 && c >= a) || (b < 0 && c < a));

        return c;
    }

    /**
    * @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
    * reverts when dividing by zero.
    */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0);
        return a % b;
    }
}

contract IBMapping {
	function checkAddress(string memory name) public view returns (address contractAddress);
	function checkOwners(address man) public view returns (bool);
}

contract IBNEST {
    function totalSupply() public view returns (uint supply);
    function balanceOf( address who ) public view returns (uint value);
    function allowance( address owner, address spender ) public view returns (uint _allowance);

    function transfer( address to, uint256 value) external;
    function transferFrom( address from, address to, uint value) public returns (bool ok);
    function approve( address spender, uint value ) public returns (bool ok);

    event Transfer( address indexed from, address indexed to, uint value);
    event Approval( address indexed owner, address indexed spender, uint value);
    
    function balancesStart() public view returns(uint256);
    function balancesGetBool(uint256 num) public view returns(bool);
    function balancesGetNext(uint256 num) public view returns(uint256);
    function balancesGetValue(uint256 num) public view returns(address, uint256);
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"constant":false,"inputs":[{"name":"amount","type":"uint256"},{"name":"to","type":"address"}],"name":"turnOut","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"map","type":"address"}],"name":"changeMapping","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"map","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

0x608060405234801561001057600080fd5b50600436106100365760003560e01c80630addec081461003b578063a781e7f814610079575b600080fd5b6100676004803603604081101561005157600080fd5b50803590602001356001600160a01b03166100a1565b60408051918252519081900360200190f35b61009f6004803603602081101561008f57600080fd5b50356001600160a01b031661024a565b005b60008054604080516347f3bf4360e11b8152602060048201819052600e60248301526d1b9bd919505cdcda59db9b595b9d60921b6044830152915133936001600160a01b031692638fe77e869260648082019391829003018186803b15801561010957600080fd5b505afa15801561011d573d6000803e3d6000fd5b505050506040513d602081101561013357600080fd5b50516001600160a01b03161461014857600080fd5b600154604080516370a0823160e01b815230600482015290516000926001600160a01b0316916370a08231916024808301926020929190829003018186803b15801561019357600080fd5b505afa1580156101a7573d6000803e3d6000fd5b505050506040513d60208110156101bd57600080fd5b5051905083811061023e576001546040805163a9059cbb60e01b81526001600160a01b038681166004830152602482018890529151919092169163a9059cbb91604480830192600092919082900301818387803b15801561021d57600080fd5b505af1158015610231573d6000803e3d6000fd5b5050505083915050610244565b60009150505b92915050565b6000546040805163a3bf06f160e01b815233600482015290516001600160a01b039092169163a3bf06f191602480820192602092909190829003018186803b15801561029557600080fd5b505afa1580156102a9573d6000803e3d6000fd5b505050506040513d60208110156102bf57600080fd5b505115156001146102cf57600080fd5b600080546001600160a01b0319166001600160a01b038381169190911791829055604080516347f3bf4360e11b8152602060048083018290526024830152631b995cdd60e21b604483015291519390921692638fe77e86926064808201939291829003018186803b15801561034357600080fd5b505afa158015610357573d6000803e3d6000fd5b505050506040513d602081101561036d57600080fd5b5051600180546001600160a01b0319166001600160a01b039092169190911790555056fea265627a7a7230582063f2877c310dbd6c9c30c5ffe40e0c2e36759e0c901d4f848a509bc3053cce5f64736f6c634300050a0032

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000005e7db2ffc5b2c7c47103e4f21c702bc402603fbf

-----Decoded View---------------
Arg [0] : map (address): 0x5E7db2FFc5b2c7C47103e4F21C702bc402603fBf

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000005e7db2ffc5b2c7c47103e4f21c702bc402603fbf

Deployed Bytecode Sourcemap

76:1550:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;76:1550:0;;;;;;;;;;;;;;;;;;;;;;;;1022:327;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;1022:327:0;;;;;;-1:-1:-1;;;;;1022:327:0;;:::i;:::-;;;;;;;;;;;;;;;;621:218;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;621:218:0;-1:-1:-1;;;;;621:218:0;;:::i;:::-;;1022:327;1104:7;1535:15;;:46;;;-1:-1:-1;;;1535:46:0;;;;;;;;;;;;;;-1:-1:-1;;;1535:46:0;;;;;;1586:10;;-1:-1:-1;;;;;1535:15:0;;:28;;:46;;;;;;;;;;;:15;:46;;;5:2:-1;;;;30:1;27;20:12;5:2;1535:46:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;1535:46:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;1535:46:0;-1:-1:-1;;;;;1527:69:0;;1519:78;;;;;;1142:12;;:37;;;-1:-1:-1;;;1142:37:0;;1173:4;1142:37;;;;;;1124:15;;-1:-1:-1;;;;;1142:12:0;;:22;;:37;;;;;;;;;;;;;;:12;:37;;;5:2:-1;;;;30:1;27;20:12;5:2;1142:37:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;1142:37:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;1142:37:0;;-1:-1:-1;1194:17:0;;;1190:152;;1228:12;;:33;;;-1:-1:-1;;;1228:33:0;;-1:-1:-1;;;;;1228:33:0;;;;;;;;;;;;;;;:12;;;;;:21;;:33;;;;;:12;;:33;;;;;;;:12;;:33;;;5:2:-1;;;;30:1;27;20:12;5:2;1228:33:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;1228:33:0;;;;1283:6;1276:13;;;;;1190:152;1329:1;1322:8;;;1608:1;1022:327;;;;:::o;621:218::-;1400:15;;:39;;;-1:-1:-1;;;1400:39:0;;1428:10;1400:39;;;;;;-1:-1:-1;;;;;1400:15:0;;;;:27;;:39;;;;;;;;;;;;;;;:15;:39;;;5:2:-1;;;;30:1;27;20:12;5:2;1400:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;1400:39:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;1400:39:0;:47;;1443:4;1400:47;1392:56;;;;;;685:15;:41;;-1:-1:-1;;;;;;685:41:0;-1:-1:-1;;;;;685:41:0;;;;;;;;;;;781:36;;;-1:-1:-1;;;781:36:0;;;;;;;;;;;;;;-1:-1:-1;;;781:36:0;;;;;;:15;;;;;:28;;:36;;;;;;;;;;;;:15;:36;;;5:2:-1;;;;30:1;27;20:12;5:2;781:36:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;781:36:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;781:36:0;751:12;:68;;-1:-1:-1;;;;;;751:68:0;-1:-1:-1;;;;;751:68:0;;;;;;;;;-1:-1:-1;621:218:0:o

Swarm Source

bzzr://63f2877c310dbd6c9c30c5ffe40e0c2e36759e0c901d4f848a509bc3053cce5f

Block		Transaction	Difficulty	Gas Used	Reward

View All Blocks Produced

Block		Uncle Number	Difficulty	Gas Used	Reward

View All Uncles

Validator Index	Block		Amount

View All Withdrawals

Transaction Hash	Block		Value	Eth2 PubKey	Valid

View All Deposits

Multichain Portfolio | 25 Chains

Display all chains •

Last updated: less than 1 sec ago

Chain	Token	Portfolio %	Price	Amount	Value

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.

Tools & Services