Goerli Testnet

Contract

0x7850ec290A2e2F40B82Ed962eaf30591bb5f5C96
Transaction Hash
Method
Block
From
To
Value
Deposit ERC20For...106627342024-03-12 8:24:4816 days ago1710231888IN
0x7850ec29...1bb5f5C96
0 ETH0.000151221.00000001
Deposit ERC20For...106627332024-03-12 8:24:1216 days ago1710231852IN
0x7850ec29...1bb5f5C96
0 ETH0.000151221.00000001
Deposit ERC20For...106627242024-03-12 8:18:2416 days ago1710231504IN
0x7850ec29...1bb5f5C96
0 ETH0.000151221.00000001
Deposit ERC20For...106627212024-03-12 8:16:0016 days ago1710231360IN
0x7850ec29...1bb5f5C96
0 ETH0.000151221.00000001
Deposit ERC20For...106627142024-03-12 8:10:3616 days ago1710231036IN
0x7850ec29...1bb5f5C96
0 ETH0.000151221.00000001
Deposit ERC20For...106597542024-03-10 18:19:3618 days ago1710094776IN
0x7850ec29...1bb5f5C96
0 ETH0.000839265.92450205
Deposit ERC20For...106594792024-03-10 15:15:1218 days ago1710083712IN
0x7850ec29...1bb5f5C96
0 ETH0.000149881.05794735
Deposit ERC20For...106553732024-03-09 10:14:4819 days ago1709979288IN
0x7850ec29...1bb5f5C96
0 ETH0.000170531.164559
Deposit ERC20For...106538292024-03-09 1:37:2419 days ago1709948244IN
0x7850ec29...1bb5f5C96
0 ETH0.000587444.01163399
Deposit ERC20For...106422692024-03-06 10:16:0022 days ago1709720160IN
0x7850ec29...1bb5f5C96
0 ETH0.000424092.89607909
Deposit ERC20For...106356092024-03-04 22:38:3624 days ago1709591916IN
0x7850ec29...1bb5f5C96
0 ETH0.00057943.83115933
Deposit ERC20For...106286582024-03-03 11:51:3625 days ago1709466696IN
0x7850ec29...1bb5f5C96
0 ETH0.000427963.02156812
Deposit ERC20For...106073302024-02-28 5:13:1229 days ago1709097192IN
0x7850ec29...1bb5f5C96
0 ETH0.000151220.99999999
Deposit ERC20For...106073122024-02-28 5:08:2429 days ago1709096904IN
0x7850ec29...1bb5f5C96
0 ETH0.000151220.99999999
Deposit ERC20For...106072412024-02-28 4:48:3629 days ago1709095716IN
0x7850ec29...1bb5f5C96
0 ETH0.000151220.99999999
Deposit ERC20For...106068382024-02-28 2:50:2429 days ago1709088624IN
0x7850ec29...1bb5f5C96
0 ETH0.000151221
Deposit ERC20For...106043342024-02-27 14:17:3630 days ago1709043456IN
0x7850ec29...1bb5f5C96
0 ETH0.000151220.99997741
Deposit ERC20For...105731792024-02-21 12:55:4836 days ago1708520148IN
0x7850ec29...1bb5f5C96
0 ETH0.000556233.67792059
Deposit ERC20For...105634872024-02-19 17:16:1238 days ago1708362972IN
0x7850ec29...1bb5f5C96
0 ETH0.000098450.65101762
Deposit ERC20For...105629322024-02-19 14:45:0038 days ago1708353900IN
0x7850ec29...1bb5f5C96
0 ETH0.000378092.50000001
Deposit ERC20For...105627082024-02-19 13:44:1238 days ago1708350252IN
0x7850ec29...1bb5f5C96
0 ETH0.000512663.50097171
Deposit ERC20For...105479712024-02-16 18:13:0041 days ago1708107180IN
0x7850ec29...1bb5f5C96
0 ETH0.000413382.82251569
Deposit ERC20For...105402772024-02-15 7:21:2442 days ago1707981684IN
0x7850ec29...1bb5f5C96
0 ETH0.000043540.28797064
Deposit ERC20For...105306452024-02-13 11:50:4844 days ago1707825048IN
0x7850ec29...1bb5f5C96
0 ETH0.000291751.92912848
Deposit ERC20For...104996512024-02-07 13:07:3650 days ago1707311256IN
0x7850ec29...1bb5f5C96
0 ETH0.000317932.24398201
View all transactions

Latest 25 internal transactions (View All)

Advanced mode:
Parent Txn Hash Block From To Value
106627342024-03-12 8:24:4816 days ago1710231888
0x7850ec29...1bb5f5C96
0 ETH
106627342024-03-12 8:24:4816 days ago1710231888
0x7850ec29...1bb5f5C96
0 ETH
106627342024-03-12 8:24:4816 days ago1710231888
0x7850ec29...1bb5f5C96
0 ETH
106627342024-03-12 8:24:4816 days ago1710231888
0x7850ec29...1bb5f5C96
0 ETH
106627342024-03-12 8:24:4816 days ago1710231888
0x7850ec29...1bb5f5C96
0 ETH
106627332024-03-12 8:24:1216 days ago1710231852
0x7850ec29...1bb5f5C96
0 ETH
106627332024-03-12 8:24:1216 days ago1710231852
0x7850ec29...1bb5f5C96
0 ETH
106627332024-03-12 8:24:1216 days ago1710231852
0x7850ec29...1bb5f5C96
0 ETH
106627332024-03-12 8:24:1216 days ago1710231852
0x7850ec29...1bb5f5C96
0 ETH
106627332024-03-12 8:24:1216 days ago1710231852
0x7850ec29...1bb5f5C96
0 ETH
106627242024-03-12 8:18:2416 days ago1710231504
0x7850ec29...1bb5f5C96
0 ETH
106627242024-03-12 8:18:2416 days ago1710231504
0x7850ec29...1bb5f5C96
0 ETH
106627242024-03-12 8:18:2416 days ago1710231504
0x7850ec29...1bb5f5C96
0 ETH
106627242024-03-12 8:18:2416 days ago1710231504
0x7850ec29...1bb5f5C96
0 ETH
106627242024-03-12 8:18:2416 days ago1710231504
0x7850ec29...1bb5f5C96
0 ETH
106627212024-03-12 8:16:0016 days ago1710231360
0x7850ec29...1bb5f5C96
0 ETH
106627212024-03-12 8:16:0016 days ago1710231360
0x7850ec29...1bb5f5C96
0 ETH
106627212024-03-12 8:16:0016 days ago1710231360
0x7850ec29...1bb5f5C96
0 ETH
106627212024-03-12 8:16:0016 days ago1710231360
0x7850ec29...1bb5f5C96
0 ETH
106627212024-03-12 8:16:0016 days ago1710231360
0x7850ec29...1bb5f5C96
0 ETH
106627142024-03-12 8:10:3616 days ago1710231036
0x7850ec29...1bb5f5C96
0 ETH
106627142024-03-12 8:10:3616 days ago1710231036
0x7850ec29...1bb5f5C96
0 ETH
106627142024-03-12 8:10:3616 days ago1710231036
0x7850ec29...1bb5f5C96
0 ETH
106627142024-03-12 8:10:3616 days ago1710231036
0x7850ec29...1bb5f5C96
0 ETH
106627142024-03-12 8:10:3616 days ago1710231036
0x7850ec29...1bb5f5C96
0 ETH
View All Internal Transactions
Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
DepositManagerProxy

Compiler Version
v0.5.11+commit.c082d0b4

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-07-24
*/

/**
 *Submitted for verification at Etherscan.io on 2020-05-31
*/

// 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: solidity-rlp/contracts/RLPReader.sol

/*
* @author Hamdi Allam [email protected]
* Please reach out with any questions or concerns
*/
pragma solidity ^0.5.0;

library RLPReader {
    uint8 constant STRING_SHORT_START = 0x80;
    uint8 constant STRING_LONG_START  = 0xb8;
    uint8 constant LIST_SHORT_START   = 0xc0;
    uint8 constant LIST_LONG_START    = 0xf8;
    uint8 constant WORD_SIZE = 32;

    struct RLPItem {
        uint len;
        uint memPtr;
    }

    struct Iterator {
        RLPItem item;   // Item that's being iterated over.
        uint nextPtr;   // Position of the next item in the list.
    }

    /*
    * @dev Returns the next element in the iteration. Reverts if it has not next element.
    * @param self The iterator.
    * @return The next element in the iteration.
    */
    function next(Iterator memory self) internal pure returns (RLPItem memory) {
        require(hasNext(self));

        uint ptr = self.nextPtr;
        uint itemLength = _itemLength(ptr);
        self.nextPtr = ptr + itemLength;

        return RLPItem(itemLength, ptr);
    }

    /*
    * @dev Returns true if the iteration has more elements.
    * @param self The iterator.
    * @return true if the iteration has more elements.
    */
    function hasNext(Iterator memory self) internal pure returns (bool) {
        RLPItem memory item = self.item;
        return self.nextPtr < item.memPtr + item.len;
    }

    /*
    * @param item RLP encoded bytes
    */
    function toRlpItem(bytes memory item) internal pure returns (RLPItem memory) {
        uint memPtr;
        assembly {
            memPtr := add(item, 0x20)
        }

        return RLPItem(item.length, memPtr);
    }

    /*
    * @dev Create an iterator. Reverts if item is not a list.
    * @param self The RLP item.
    * @return An 'Iterator' over the item.
    */
    function iterator(RLPItem memory self) internal pure returns (Iterator memory) {
        require(isList(self));

        uint ptr = self.memPtr + _payloadOffset(self.memPtr);
        return Iterator(self, ptr);
    }

    /*
    * @param item RLP encoded bytes
    */
    function rlpLen(RLPItem memory item) internal pure returns (uint) {
        return item.len;
    }

    /*
    * @param item RLP encoded bytes
    */
    function payloadLen(RLPItem memory item) internal pure returns (uint) {
        return item.len - _payloadOffset(item.memPtr);
    }

    /*
    * @param item RLP encoded list in bytes
    */
    function toList(RLPItem memory item) internal pure returns (RLPItem[] memory) {
        require(isList(item));

        uint items = numItems(item);
        RLPItem[] memory result = new RLPItem[](items);

        uint memPtr = item.memPtr + _payloadOffset(item.memPtr);
        uint dataLen;
        for (uint i = 0; i < items; i++) {
            dataLen = _itemLength(memPtr);
            result[i] = RLPItem(dataLen, memPtr); 
            memPtr = memPtr + dataLen;
        }

        return result;
    }

    // @return indicator whether encoded payload is a list. negate this function call for isData.
    function isList(RLPItem memory item) internal pure returns (bool) {
        if (item.len == 0) return false;

        uint8 byte0;
        uint memPtr = item.memPtr;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < LIST_SHORT_START)
            return false;
        return true;
    }

    /** RLPItem conversions into data types **/

    // @returns raw rlp encoding in bytes
    function toRlpBytes(RLPItem memory item) internal pure returns (bytes memory) {
        bytes memory result = new bytes(item.len);
        if (result.length == 0) return result;
        
        uint ptr;
        assembly {
            ptr := add(0x20, result)
        }

        copy(item.memPtr, ptr, item.len);
        return result;
    }

    // any non-zero byte is considered true
    function toBoolean(RLPItem memory item) internal pure returns (bool) {
        require(item.len == 1);
        uint result;
        uint memPtr = item.memPtr;
        assembly {
            result := byte(0, mload(memPtr))
        }

        return result == 0 ? false : true;
    }

    function toAddress(RLPItem memory item) internal pure returns (address) {
        // 1 byte for the length prefix
        require(item.len == 21);

        return address(toUint(item));
    }

    function toUint(RLPItem memory item) internal pure returns (uint) {
        require(item.len > 0 && item.len <= 33);

        uint offset = _payloadOffset(item.memPtr);
        uint len = item.len - offset;

        uint result;
        uint memPtr = item.memPtr + offset;
        assembly {
            result := mload(memPtr)

            // shfit to the correct location if neccesary
            if lt(len, 32) {
                result := div(result, exp(256, sub(32, len)))
            }
        }

        return result;
    }

    // enforces 32 byte length
    function toUintStrict(RLPItem memory item) internal pure returns (uint) {
        // one byte prefix
        require(item.len == 33);

        uint result;
        uint memPtr = item.memPtr + 1;
        assembly {
            result := mload(memPtr)
        }

        return result;
    }

    function toBytes(RLPItem memory item) internal pure returns (bytes memory) {
        require(item.len > 0);

        uint offset = _payloadOffset(item.memPtr);
        uint len = item.len - offset; // data length
        bytes memory result = new bytes(len);

        uint destPtr;
        assembly {
            destPtr := add(0x20, result)
        }

        copy(item.memPtr + offset, destPtr, len);
        return result;
    }

    /*
    * Private Helpers
    */

    // @return number of payload items inside an encoded list.
    function numItems(RLPItem memory item) private pure returns (uint) {
        if (item.len == 0) return 0;

        uint count = 0;
        uint currPtr = item.memPtr + _payloadOffset(item.memPtr);
        uint endPtr = item.memPtr + item.len;
        while (currPtr < endPtr) {
           currPtr = currPtr + _itemLength(currPtr); // skip over an item
           count++;
        }

        return count;
    }

    // @return entire rlp item byte length
    function _itemLength(uint memPtr) private pure returns (uint) {
        uint itemLen;
        uint byte0;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < STRING_SHORT_START)
            itemLen = 1;
        
        else if (byte0 < STRING_LONG_START)
            itemLen = byte0 - STRING_SHORT_START + 1;

        else if (byte0 < LIST_SHORT_START) {
            assembly {
                let byteLen := sub(byte0, 0xb7) // # of bytes the actual length is
                memPtr := add(memPtr, 1) // skip over the first byte
                
                /* 32 byte word size */
                let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to get the len
                itemLen := add(dataLen, add(byteLen, 1))
            }
        }

        else if (byte0 < LIST_LONG_START) {
            itemLen = byte0 - LIST_SHORT_START + 1;
        } 

        else {
            assembly {
                let byteLen := sub(byte0, 0xf7)
                memPtr := add(memPtr, 1)

                let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to the correct length
                itemLen := add(dataLen, add(byteLen, 1))
            }
        }

        return itemLen;
    }

    // @return number of bytes until the data
    function _payloadOffset(uint memPtr) private pure returns (uint) {
        uint byte0;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < STRING_SHORT_START) 
            return 0;
        else if (byte0 < STRING_LONG_START || (byte0 >= LIST_SHORT_START && byte0 < LIST_LONG_START))
            return 1;
        else if (byte0 < LIST_SHORT_START)  // being explicit
            return byte0 - (STRING_LONG_START - 1) + 1;
        else
            return byte0 - (LIST_LONG_START - 1) + 1;
    }

    /*
    * @param src Pointer to source
    * @param dest Pointer to destination
    * @param len Amount of memory to copy from the source
    */
    function copy(uint src, uint dest, uint len) private pure {
        if (len == 0) return;

        // copy as many word sizes as possible
        for (; len >= WORD_SIZE; len -= WORD_SIZE) {
            assembly {
                mstore(dest, mload(src))
            }

            src += WORD_SIZE;
            dest += WORD_SIZE;
        }

        // left over bytes. Mask is used to remove unwanted bytes from the word
        uint mask = 256 ** (WORD_SIZE - len) - 1;
        assembly {
            let srcpart := and(mload(src), not(mask)) // zero out src
            let destpart := and(mload(dest), mask) // retrieve the bytes
            mstore(dest, or(destpart, srcpart))
        }
    }
}

// File: openzeppelin-solidity/contracts/math/SafeMath.sol

pragma solidity ^0.5.2;

/**
 * @title SafeMath
 * @dev Unsigned math operations with safety checks that revert on error
 */
library SafeMath {
    /**
     * @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 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 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 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 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;
    }
}

// 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/mixin/ChainIdMixin.sol

pragma solidity ^0.5.2;

contract ChainIdMixin {
  bytes constant public networkId = hex"89";
  uint256 constant public CHAINID = 137;
}

// File: contracts/root/RootChainStorage.sol

pragma solidity ^0.5.2;





contract RootChainHeader {
    event NewHeaderBlock(
        address indexed proposer,
        uint256 indexed headerBlockId,
        uint256 indexed reward,
        uint256 start,
        uint256 end,
        bytes32 root
    );
    // housekeeping event
    event ResetHeaderBlock(address indexed proposer, uint256 indexed headerBlockId);
    struct HeaderBlock {
        bytes32 root;
        uint256 start;
        uint256 end;
        uint256 createdAt;
        address proposer;
    }
}


contract RootChainStorage is ProxyStorage, RootChainHeader, ChainIdMixin {
    bytes32 public heimdallId;
    uint8 public constant VOTE_TYPE = 2;

    uint16 internal constant MAX_DEPOSITS = 10000;
    uint256 public _nextHeaderBlock = MAX_DEPOSITS;
    uint256 internal _blockDepositId = 1;
    mapping(uint256 => HeaderBlock) public headerBlocks;
    Registry internal registry;
}

// File: contracts/staking/stakeManager/IStakeManager.sol

pragma solidity ^0.5.2;


contract IStakeManager {
    // validator replacement
    function startAuction(uint256 validatorId, uint256 amount) external;

    function confirmAuctionBid(
        uint256 validatorId,
        uint256 heimdallFee,
        bool acceptDelegation,
        bytes calldata signerPubkey
    ) external;

    function transferFunds(
        uint256 validatorId,
        uint256 amount,
        address delegator
    ) external returns (bool);

    function delegationDeposit(
        uint256 validatorId,
        uint256 amount,
        address delegator
    ) external returns (bool);

    function stake(
        uint256 amount,
        uint256 heimdallFee,
        bool acceptDelegation,
        bytes calldata signerPubkey
    ) external;

    function unstake(uint256 validatorId) external;

    function totalStakedFor(address addr) external view returns (uint256);

    function supportsHistory() external pure returns (bool);

    function stakeFor(
        address user,
        uint256 amount,
        uint256 heimdallFee,
        bool acceptDelegation,
        bytes memory signerPubkey
    ) public;

    function checkSignatures(
        uint256 blockInterval,
        bytes32 voteHash,
        bytes32 stateRoot,
        address proposer,
        bytes memory sigs
    ) public returns (uint256);

    function updateValidatorState(uint256 validatorId, int256 amount) public;

    function ownerOf(uint256 tokenId) public view returns (address);

    function slash(bytes memory slashingInfoList) public returns (uint256);

    function validatorStake(uint256 validatorId) public view returns (uint256);

    function epoch() public view returns (uint256);

    function withdrawalDelay() public view returns (uint256);
}

// File: contracts/root/IRootChain.sol

pragma solidity ^0.5.2;


interface IRootChain {
    function slash() external;

    function submitHeaderBlock(bytes calldata data, bytes calldata sigs)
        external;

    function getLastChildBlock() external view returns (uint256);

    function currentHeaderBlock() external view returns (uint256);
}

// File: contracts/root/RootChain.sol

pragma solidity ^0.5.2;








contract RootChain is RootChainStorage, IRootChain {
    using SafeMath for uint256;
    using RLPReader for bytes;
    using RLPReader for RLPReader.RLPItem;

    modifier onlyDepositManager() {
        require(msg.sender == registry.getDepositManagerAddress(), "UNAUTHORIZED_DEPOSIT_MANAGER_ONLY");
        _;
    }

    function submitHeaderBlock(bytes calldata data, bytes calldata sigs) external {
        (address proposer, uint256 start, uint256 end, bytes32 rootHash, bytes32 accountHash, uint256 _borChainID) = abi
            .decode(data, (address, uint256, uint256, bytes32, bytes32, uint256));
        require(CHAINID == _borChainID, "Invalid bor chain id");

        require(_buildHeaderBlock(proposer, start, end, rootHash), "INCORRECT_HEADER_DATA");

        // check if it is better to keep it in local storage instead
        IStakeManager stakeManager = IStakeManager(registry.getStakeManagerAddress());
        uint256 _reward = stakeManager.checkSignatures(
            end.sub(start).add(1),
            /**  
                prefix 01 to data 
                01 represents positive vote on data and 00 is negative vote
                malicious validator can try to send 2/3 on negative vote so 01 is appended
             */
            keccak256(abi.encodePacked(bytes(hex"01"), data)),
            accountHash,
            proposer,
            sigs
        );

        require(_reward != 0, "Invalid checkpoint");
        emit NewHeaderBlock(proposer, _nextHeaderBlock, _reward, start, end, rootHash);
        _nextHeaderBlock = _nextHeaderBlock.add(MAX_DEPOSITS);
        _blockDepositId = 1;
    }

    function updateDepositId(uint256 numDeposits) external onlyDepositManager returns (uint256 depositId) {
        depositId = currentHeaderBlock().add(_blockDepositId);
        // deposit ids will be (_blockDepositId, _blockDepositId + 1, .... _blockDepositId + numDeposits - 1)
        _blockDepositId = _blockDepositId.add(numDeposits);
        require(
            // Since _blockDepositId is initialized to 1; only (MAX_DEPOSITS - 1) deposits per header block are allowed
            _blockDepositId <= MAX_DEPOSITS,
            "TOO_MANY_DEPOSITS"
        );
    }

    function getLastChildBlock() external view returns (uint256) {
        return headerBlocks[currentHeaderBlock()].end;
    }

    function slash() external {
        //TODO: future implementation
    }

    function currentHeaderBlock() public view returns (uint256) {
        return _nextHeaderBlock.sub(MAX_DEPOSITS);
    }

    function _buildHeaderBlock(
        address proposer,
        uint256 start,
        uint256 end,
        bytes32 rootHash
    ) private returns (bool) {
        uint256 nextChildBlock;
        /*
    The ID of the 1st header block is MAX_DEPOSITS.
    if _nextHeaderBlock == MAX_DEPOSITS, then the first header block is yet to be submitted, hence nextChildBlock = 0
    */
        if (_nextHeaderBlock > MAX_DEPOSITS) {
            nextChildBlock = headerBlocks[currentHeaderBlock()].end + 1;
        }
        if (nextChildBlock != start) {
            return false;
        }

        HeaderBlock memory headerBlock = HeaderBlock({
            root: rootHash,
            start: nextChildBlock,
            end: end,
            createdAt: now,
            proposer: proposer
        });

        headerBlocks[_nextHeaderBlock] = headerBlock;
        return true;
    }

    // Housekeeping function. @todo remove later
    function setNextHeaderBlock(uint256 _value) public onlyOwner {
        require(_value % MAX_DEPOSITS == 0, "Invalid value");
        for (uint256 i = _value; i < _nextHeaderBlock; i += MAX_DEPOSITS) {
            delete headerBlocks[i];
        }
        _nextHeaderBlock = _value;
        _blockDepositId = 1;
        emit ResetHeaderBlock(msg.sender, _nextHeaderBlock);
    }

    // Housekeeping function. @todo remove later
    function setHeimdallId(string memory _heimdallId) public onlyOwner {
        heimdallId = keccak256(abi.encodePacked(_heimdallId));
    }
}

// File: contracts/root/stateSyncer/StateSender.sol

pragma solidity ^0.5.2;



contract StateSender is Ownable {
    using SafeMath for uint256;

    uint256 public counter;
    mapping(address => address) public registrations;

    event NewRegistration(
        address indexed user,
        address indexed sender,
        address indexed receiver
    );
    event RegistrationUpdated(
        address indexed user,
        address indexed sender,
        address indexed receiver
    );
    event StateSynced(
        uint256 indexed id,
        address indexed contractAddress,
        bytes data
    );

    modifier onlyRegistered(address receiver) {
        require(registrations[receiver] == msg.sender, "Invalid sender");
        _;
    }

    function syncState(address receiver, bytes calldata data)
        external
        onlyRegistered(receiver)
    {
        counter = counter.add(1);
        emit StateSynced(counter, receiver, data);
    }

    // register new contract for state sync
    function register(address sender, address receiver) public {
        require(
            isOwner() || registrations[receiver] == msg.sender,
            "StateSender.register: Not authorized to register"
        );
        registrations[receiver] = sender;
        if (registrations[receiver] == address(0)) {
            emit NewRegistration(msg.sender, sender, receiver);
        } else {
            emit RegistrationUpdated(msg.sender, sender, receiver);
        }
    }
}

// File: contracts/common/mixin/Lockable.sol

pragma solidity ^0.5.2;


contract Lockable is Governable {
    bool public locked;

    modifier onlyWhenUnlocked() {
        require(!locked, "Is Locked");
        _;
    }

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

    function lock() external onlyGovernance {
        locked = true;
    }

    function unlock() external onlyGovernance {
        locked = false;
    }
}

// File: contracts/root/depositManager/DepositManagerStorage.sol

pragma solidity ^0.5.2;







contract DepositManagerHeader {
    event NewDepositBlock(address indexed owner, address indexed token, uint256 amountOrNFTId, uint256 depositBlockId);
    event MaxErc20DepositUpdate(uint256 indexed oldLimit, uint256 indexed newLimit);

    struct DepositBlock {
        bytes32 depositHash;
        uint256 createdAt;
    }
}


contract DepositManagerStorage is ProxyStorage, Lockable, DepositManagerHeader {
    Registry public registry;
    RootChain public rootChain;
    StateSender public stateSender;

    mapping(uint256 => DepositBlock) public deposits;

    address public childChain;
    uint256 public maxErc20Deposit = 100 * (10**18);
}

// 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/Proxy.sol

pragma solidity ^0.5.2;




contract Proxy is ProxyStorage, DelegateProxy {
    event ProxyUpdated(address indexed _new, address indexed _old);
    event OwnerUpdate(address _prevOwner, address _newOwner);

    constructor(address _proxyTo) public {
        updateImplementation(_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(proxyTo, msg.data);
    }

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

    function updateImplementation(address _newProxyTo) public onlyOwner {
        require(_newProxyTo != address(0x0), "INVALID_PROXY_ADDRESS");
        require(isContract(_newProxyTo), "DESTINATION_ADDRESS_IS_NOT_A_CONTRACT");
        emit ProxyUpdated(_newProxyTo, proxyTo);
        proxyTo = _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/root/depositManager/DepositManagerProxy.sol

pragma solidity ^0.5.2;






contract DepositManagerProxy is Proxy, DepositManagerStorage {
    constructor(
        address _proxyTo,
        address _registry,
        address _rootChain,
        address _governance
    ) public Proxy(_proxyTo) Lockable(_governance) {
        registry = Registry(_registry);
        rootChain = RootChain(_rootChain);
    }
}

Contract ABI

[{"constant":false,"inputs":[{"internalType":"address","name":"_newProxyTo","type":"address"}],"name":"updateImplementation","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"childChain","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":true,"inputs":[],"name":"governance","outputs":[{"internalType":"contract IGovernance","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"registry","outputs":[{"internalType":"contract Registry","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":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"rootChain","outputs":[{"internalType":"contract RootChain","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"unlock","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"deposits","outputs":[{"internalType":"bytes32","name":"depositHash","type":"bytes32"},{"internalType":"uint256","name":"createdAt","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"stateSender","outputs":[{"internalType":"contract StateSender","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"locked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"maxErc20Deposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"lock","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_proxyTo","type":"address"},{"internalType":"address","name":"_registry","type":"address"},{"internalType":"address","name":"_rootChain","type":"address"},{"internalType":"address","name":"_governance","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountOrNFTId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"depositBlockId","type":"uint256"}],"name":"NewDepositBlock","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"oldLimit","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"newLimit","type":"uint256"}],"name":"MaxErc20DepositUpdate","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_prevOwner","type":"address"},{"indexed":false,"internalType":"address","name":"_newOwner","type":"address"}],"name":"OwnerUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"}]

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

Deployed Bytecode

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

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

00000000000000000000000020339c5ea91d680e681b9374fc0a558d5b96a026000000000000000000000000ee11713fe713b2bff2942452517483654078154d0000000000000000000000002890ba17efe978480615e330ecb65333b880928e000000000000000000000000acdeadee4c054a86f5b1e8705126b30ec999899b

-----Decoded View---------------
Arg [0] : _proxyTo (address): 0x20339c5Ea91D680E681B9374Fc0a558D5b96a026
Arg [1] : _registry (address): 0xeE11713Fe713b2BfF2942452517483654078154D
Arg [2] : _rootChain (address): 0x2890bA17EfE978480615e330ecB65333b880928e
Arg [3] : _governance (address): 0xAcdEADEE4c054A86F5b1e8705126b30Ec999899B

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 00000000000000000000000020339c5ea91d680e681b9374fc0a558d5b96a026
Arg [1] : 000000000000000000000000ee11713fe713b2bff2942452517483654078154d
Arg [2] : 0000000000000000000000002890ba17efe978480615e330ecb65333b880928e
Arg [3] : 000000000000000000000000acdeadee4c054a86f5b1e8705126b30ec999899b


Deployed Bytecode Sourcemap

34370:342:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33531:7;;33518:31;;;;33540:8;33518:31;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;33531:7:0;;-1:-1:-1;;33540:8:0;;33518:31;;-1:-1:-1;33540:8:0;;-1:-1:-1;33518:31:0;1:33:-1;99:1;81:16;;74:27;;;;-1:-1;33518:12:0;;-1:-1:-1;;;33518:31:0:i;:::-;34370:342;33664:314;;8:9:-1;5:2;;;30:1;27;20:12;5:2;33664:314:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;33664:314:0;-1:-1:-1;;;;;33664:314:0;;:::i;31281:25::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;31281:25:0;;;:::i;:::-;;;;-1:-1:-1;;;;;31281:25:0;;;;;;;;;;;;;;31857:129;;8:9:-1;5:2;;;30:1;27;20:12;5:2;31857:129:0;;;:::i;:::-;;;;;;;;;;;;;;;;363:29;;8:9:-1;5:2;;;30:1;27;20:12;5:2;363:29:0;;;:::i;33565:91::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;33565:91:0;;;:::i;19973:140::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19973:140:0;;;:::i;31121:24::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;31121:24:0;;;:::i;19183:79::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19183:79:0;;;:::i;19518:92::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19518:92:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;31152:26;;8:9:-1;5:2;;;30:1;27;20:12;5:2;31152:26:0;;;:::i;30505:75::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;30505:75:0;;;:::i;31224:48::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;31224:48:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;31224:48:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;31185:30;;8:9:-1;5:2;;;30:1;27;20:12;5:2;31185:30:0;;;:::i;30228:18::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;30228:18:0;;;:::i;31313:47::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;31313:47:0;;;:::i;20290:109::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;20290:109:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;20290:109:0;-1:-1:-1;;;;;20290:109:0;;:::i;30425:72::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;30425:72:0;;;:::i;32060:892::-;32425:1;32405;32376:9;32370:16;32346:4;32335:9;32331:20;32308:4;32283:5;32278:3;32274:15;32243:198;32467:14;32514:4;32508:11;32556:4;32553:1;32548:3;32533:28;32759:6;32783:66;;;;32910:4;32905:3;32898:17;32783:66;32825:4;32820:3;32813:17;33664:314;19395:9;:7;:9::i;:::-;19387:18;;;;;;-1:-1:-1;;;;;33751:27:0;;33743:61;;;;;-1:-1:-1;;;33743:61:0;;;;;;;;;;;;-1:-1:-1;;;33743:61:0;;;;;;;;;;;;;;;33823:23;33834:11;33823:10;:23::i;:::-;33815:73;;;;-1:-1:-1;;;33815:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33930:7;;33904:34;;-1:-1:-1;;;;;33930:7:0;;;;33904:34;;;;;33930:7;;33904:34;33949:7;:21;;-1:-1:-1;;;;;;33949:21:0;-1:-1:-1;;;;;33949:21:0;;;;;;;;;;33664:314::o;31281:25::-;;;-1:-1:-1;;;;;31281:25:0;;:::o;31857:129::-;31977:1;;31857:129::o;363:29::-;;;-1:-1:-1;;;;;363:29:0;;:::o;33565:91::-;33641:7;;-1:-1:-1;;;;;33641:7:0;33565:91;:::o;19973:140::-;19395:9;:7;:9::i;:::-;19387:18;;;;;;20072:1;20056:6;;20035:40;;-1:-1:-1;;;;;20056:6:0;;;;20035:40;;20072:1;;20035:40;20103:1;20086:19;;-1:-1:-1;;;;;;20086:19:0;;;19973:140::o;31121:24::-;;;-1:-1:-1;;;;;31121:24:0;;:::o;19183:79::-;19221:7;19248:6;-1:-1:-1;;;;;19248:6:0;19183:79;:::o;19518:92::-;19558:4;19596:6;-1:-1:-1;;;;;19596:6:0;19582:10;:20;;19518:92::o;31152:26::-;;;-1:-1:-1;;;;;31152:26:0;;:::o;30505:75::-;586:10;;-1:-1:-1;;;;;586:10:0;564;:33;542:121;;;;-1:-1:-1;;;542:121:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30558:6;:14;;-1:-1:-1;;;;30558:14:0;;;30505:75::o;31224:48::-;;;;;;;;;;;;;;;;;;;:::o;31185:30::-;;;-1:-1:-1;;;;;31185:30:0;;:::o;30228:18::-;;;-1:-1:-1;;;30228:18:0;;;;;:::o;31313:47::-;;;;:::o;20290:109::-;19395:9;:7;:9::i;:::-;19387:18;;;;;;20363:28;20382:8;20363:18;:28::i;:::-;20290:109;:::o;30425:72::-;586:10;;-1:-1:-1;;;;;586:10:0;564;:33;542:121;;;;-1:-1:-1;;;542:121:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30476:6;:13;;-1:-1:-1;;;;30476:13:0;-1:-1:-1;;;30476:13:0;;;30425:72::o;33986:274::-;34046:4;-1:-1:-1;;;;;34067:21:0;;34063:66;;-1:-1:-1;34112:5:0;34105:12;;34063:66;-1:-1:-1;34196:20:0;;34244:8;;33986:274;;;;:::o;20549:187::-;-1:-1:-1;;;;;20623:22:0;;20615:31;;;;;;20683:6;;;20662:38;;-1:-1:-1;;;;;20662:38:0;;;;20683:6;;;20662:38;;;20711:6;:17;;-1:-1:-1;;;;;;20711:17:0;-1:-1:-1;;;;;20711:17:0;;;;;;;;;;20549:187::o

Swarm Source

bzzr://7a086b0b90c5f34ac3c10b9250bea1ec82aa64e0293531b93222d9da3eb35501

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.