ETH Price: $3,882.12 (+2.81%)

Contract

0xca7f7145E2693E09febeE903f8567041cc9650c8
 

Overview

ETH Balance

0.01304593192 ETH

Eth Value

$50.65 (@ $3,882.12/ETH)

Token Holdings

More Info

Private Name Tags

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
Distribute Balan...234931642025-10-02 22:45:4715 days ago1759445147IN
0xca7f7145...1cc9650c8
0 ETH0.000162172.20141264
Distribute Balan...232416742025-08-28 19:22:4750 days ago1756408967IN
0xca7f7145...1cc9650c8
0 ETH0.000173872.36027104
Distribute Balan...230614812025-08-03 15:38:1175 days ago1754235491IN
0xca7f7145...1cc9650c8
0 ETH0.000164282.23006173
Distribute Balan...226424792025-06-06 2:07:59134 days ago1749175679IN
0xca7f7145...1cc9650c8
0 ETH0.000228922.84531782
Distribute Balan...220137222025-03-10 3:15:59222 days ago1741576559IN
0xca7f7145...1cc9650c8
0 ETH0.000188212.55493346
Distribute Balan...214951652024-12-27 17:03:35294 days ago1735319015IN
0xca7f7145...1cc9650c8
0 ETH0.000746359.27643658
Distribute Balan...206506902024-08-31 19:38:11412 days ago1725133091IN
0xca7f7145...1cc9650c8
0 ETH0.000211272.56227949
Distribute Balan...199443952024-05-25 4:06:35511 days ago1716609995IN
0xca7f7145...1cc9650c8
0 ETH0.000495156.00501529
Distribute Balan...188455102023-12-23 2:21:23665 days ago1703298083IN
0xca7f7145...1cc9650c8
0 ETH0.0019653323.20591937
Distribute Balan...182383222023-09-29 2:12:35750 days ago1695953555IN
0xca7f7145...1cc9650c8
0 ETH0.000747068.82102694
Distribute Balan...178348602023-08-03 13:47:11806 days ago1691070431IN
0xca7f7145...1cc9650c8
0 ETH0.0023493927.74076139
Distribute Balan...176390742023-07-07 2:51:23834 days ago1688698283IN
0xca7f7145...1cc9650c8
0 ETH0.0019160422.62390226
Distribute Balan...174434582023-06-09 15:07:47861 days ago1686323267IN
0xca7f7145...1cc9650c8
0 ETH0.0034015241.25214292
Stake172506982023-05-13 11:16:23889 days ago1683976583IN
0xca7f7145...1cc9650c8
0 ETH0.00869444.37778759

Latest 25 internal transactions

Advanced mode:
Parent Transaction Hash Method Block
From
To
Transfer235987752025-10-17 17:07:4719 hrs ago1760720867
0xca7f7145...1cc9650c8
0.01180247 ETH
Transfer235321682025-10-08 9:33:1110 days ago1759915991
0xca7f7145...1cc9650c8
0.01190069 ETH
Transfer234931642025-10-02 22:45:4715 days ago1759445147
0xca7f7145...1cc9650c8
0.04319663 ETH
Transfer234669492025-09-29 6:46:1119 days ago1759128371
0xca7f7145...1cc9650c8
0.01197666 ETH
Transfer234015282025-09-20 3:14:2328 days ago1758338063
0xca7f7145...1cc9650c8
0.04196052 ETH
Transfer233355232025-09-10 22:03:3537 days ago1757541815
0xca7f7145...1cc9650c8
0.01217237 ETH
Transfer232701482025-09-01 18:43:1146 days ago1756752191
0xca7f7145...1cc9650c8
0.01237445 ETH
Transfer232416742025-08-28 19:22:4750 days ago1756408967
0xca7f7145...1cc9650c8
0.02063176 ETH
Transfer232011252025-08-23 3:33:2356 days ago1755920003
0xca7f7145...1cc9650c8
0.01246509 ETH
Transfer231345142025-08-13 20:27:1165 days ago1755116831
0xca7f7145...1cc9650c8
0.01253884 ETH
Transfer230645052025-08-04 1:45:2375 days ago1754271923
0xca7f7145...1cc9650c8
0.01248193 ETH
Transfer230614812025-08-03 15:38:1175 days ago1754235491
0xca7f7145...1cc9650c8
0.05762189 ETH
Transfer229959992025-07-25 11:55:3585 days ago1753444535
0xca7f7145...1cc9650c8
0.01254771 ETH
Transfer229710662025-07-22 0:12:4788 days ago1753143167
0xca7f7145...1cc9650c8
0.01249997 ETH
Transfer228591722025-07-06 9:08:59104 days ago1751792939
0xca7f7145...1cc9650c8
0.05501485 ETH
Transfer227525692025-06-21 11:33:35119 days ago1750505615
0xca7f7145...1cc9650c8
0.02463076 ETH
Transfer226424792025-06-06 2:07:59134 days ago1749175679
0xca7f7145...1cc9650c8
0.07301474 ETH
Transfer226424792025-06-06 2:07:59134 days ago1749175679
0xca7f7145...1cc9650c8
0.02496676 ETH
Transfer224850972025-05-15 0:55:59156 days ago1747270559
0xca7f7145...1cc9650c8
0.02470666 ETH
Transfer223256702025-04-22 16:14:11178 days ago1745338451
0xca7f7145...1cc9650c8
0.03341647 ETH
Transfer222583902025-04-13 6:55:11188 days ago1744527311
0xca7f7145...1cc9650c8
0.01250643 ETH
Transfer222016782025-04-05 8:59:59196 days ago1743843599
0xca7f7145...1cc9650c8
0.02468905 ETH
Transfer220586982025-03-16 9:58:35216 days ago1742119115
0xca7f7145...1cc9650c8
0.0123752 ETH
Transfer220137222025-03-10 3:15:59222 days ago1741576559
0xca7f7145...1cc9650c8
0.05398817 ETH
Transfer219927272025-03-07 4:50:59225 days ago1741323059
0xca7f7145...1cc9650c8
0.01232814 ETH
Cross-Chain Transactions
Withdrawals

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Latest 25 from a total of 105 withdrawals (2.147886806 ETH withdrawn)

Validator Index Block Amount
611758235968332025-10-17 10:38:1126 hrs ago17606974910.018298416 ETH
611758235321672025-10-08 9:32:5910 days ago17599159790.018450688 ETH
611758234669482025-09-29 6:45:5919 days ago17591283590.018568475 ETH
611758234015272025-09-20 3:14:1128 days ago17583380510.065055073 ETH
611758233355222025-09-10 22:03:2337 days ago17575418030.018871902 ETH
611758232687922025-09-01 14:10:1146 days ago17567358110.019185201 ETH
611758232011242025-08-23 3:33:1156 days ago17559199910.019325729 ETH
611758231329212025-08-13 15:07:3565 days ago17550976550.019440075 ETH
611758230645042025-08-04 1:45:1175 days ago17542719110.019351835 ETH
611758229959962025-07-25 11:54:5985 days ago17534444990.019453816 ETH
611758229273682025-07-15 21:47:5994 days ago17526160790.0193798 ETH
611758228591642025-07-06 9:07:23104 days ago17517928430.066133314 ETH
611758227915672025-06-26 22:22:11113 days ago17509765310.019161034 ETH
611758227246162025-06-17 13:46:35122 days ago17501679950.01907722 ETH
611758226582472025-06-08 7:01:47132 days ago17493661070.019110005 ETH
611758225921722025-05-30 1:07:35141 days ago17485672550.019325454 ETH
611758225256262025-05-20 17:30:59150 days ago17477622590.019382713 ETH
611758224588242025-05-11 8:10:59160 days ago17469510590.019068381 ETH
611758223921792025-05-01 23:10:11169 days ago17461410110.01923652 ETH
611758223255162025-04-22 15:43:23178 days ago17453366030.051808482 ETH
611758222583892025-04-13 6:54:59188 days ago17445272990.019389817 ETH
611758221915142025-04-03 22:57:35197 days ago17437210550.019299306 ETH
611758221249402025-03-25 15:54:23206 days ago17429180630.018978302 ETH
611758220586952025-03-16 9:57:59216 days ago17421190790.019186357 ETH
611758219927262025-03-07 4:50:47225 days ago17413230470.019113397 ETH
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
Loading...
Loading

Minimal Proxy Contract for 0x560656c8947564363497e9c78a8bdeff8d3eff33

Contract Name:
RocketMinipoolBase

Compiler Version
v0.7.6+commit.7338295f

Optimization Enabled:
Yes with 15000 runs

Other Settings:
default evmVersion, GNU GPLv3 license

Contract Source Code (Solidity Standard Json-Input format)

/**
  *       .
  *      / \
  *     |.'.|
  *     |'.'|
  *   ,'|   |`.
  *  |,-'-|-'-.|
  *   __|_| |         _        _      _____           _
  *  | ___ \|        | |      | |    | ___ \         | |
  *  | |_/ /|__   ___| | _____| |_   | |_/ /__   ___ | |
  *  |    // _ \ / __| |/ / _ \ __|  |  __/ _ \ / _ \| |
  *  | |\ \ (_) | (__|   <  __/ |_   | | | (_) | (_) | |
  *  \_| \_\___/ \___|_|\_\___|\__|  \_|  \___/ \___/|_|
  * +---------------------------------------------------+
  * |  DECENTRALISED STAKING PROTOCOL FOR ETHEREUM 2.0  |
  * +---------------------------------------------------+
  *
  *  Rocket Pool is a first-of-its-kind ETH2 Proof of Stake protocol, designed to be community owned,
  *  decentralised, trustless and compatible with staking in Ethereum 2.0.
  *
  *  For more information about Rocket Pool, visit https://rocketpool.net
  *
  *  Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
  *
  */

// SPDX-License-Identifier: GPL-3.0-only
pragma solidity 0.7.6;

import "./RocketMinipoolStorageLayout.sol";
import "../../interface/RocketStorageInterface.sol";
import "../../interface/minipool/RocketMinipoolBaseInterface.sol";

/// @notice Contains the initialisation and delegate upgrade logic for minipools
contract RocketMinipoolBase is RocketMinipoolBaseInterface, RocketMinipoolStorageLayout {

    // Events
    event EtherReceived(address indexed from, uint256 amount, uint256 time);
    event DelegateUpgraded(address oldDelegate, address newDelegate, uint256 time);
    event DelegateRolledBack(address oldDelegate, address newDelegate, uint256 time);

    // Store a reference to the address of RocketMinipoolBase itself to prevent direct calls to this contract
    address immutable self;

    constructor () {
        self = address(this);
    }

    /// @dev Prevent direct calls to this contract
    modifier notSelf() {
        require(address(this) != self);
        _;
    }

    /// @dev Only allow access from the owning node address
    modifier onlyMinipoolOwner() {
        // Only the node operator can upgrade
        address withdrawalAddress = rocketStorage.getNodeWithdrawalAddress(nodeAddress);
        require(msg.sender == nodeAddress || msg.sender == withdrawalAddress, "Only the node operator can access this method");
        _;
    }

    /// @notice Sets up starting delegate contract and then delegates initialisation to it
    function initialise(address _rocketStorage, address _nodeAddress) external override notSelf {
        // Check input
        require(_nodeAddress != address(0), "Invalid node address");
        require(storageState == StorageState.Undefined, "Already initialised");
        // Set storage state to uninitialised
        storageState = StorageState.Uninitialised;
        // Set rocketStorage
        rocketStorage = RocketStorageInterface(_rocketStorage);
        // Set the current delegate
        address delegateAddress = getContractAddress("rocketMinipoolDelegate");
        rocketMinipoolDelegate = delegateAddress;
        // Check for contract existence
        require(contractExists(delegateAddress), "Delegate contract does not exist");
        // Call initialise on delegate
        (bool success, bytes memory data) = delegateAddress.delegatecall(abi.encodeWithSignature('initialise(address)', _nodeAddress));
        if (!success) { revert(getRevertMessage(data)); }
    }

    /// @notice Receive an ETH deposit
    receive() external payable notSelf {
        // Emit ether received event
        emit EtherReceived(msg.sender, msg.value, block.timestamp);
    }

    /// @notice Upgrade this minipool to the latest network delegate contract
    function delegateUpgrade() external override onlyMinipoolOwner notSelf {
        // Set previous address
        rocketMinipoolDelegatePrev = rocketMinipoolDelegate;
        // Set new delegate
        rocketMinipoolDelegate = getContractAddress("rocketMinipoolDelegate");
        // Verify
        require(rocketMinipoolDelegate != rocketMinipoolDelegatePrev, "New delegate is the same as the existing one");
        // Log event
        emit DelegateUpgraded(rocketMinipoolDelegatePrev, rocketMinipoolDelegate, block.timestamp);
    }

    /// @notice Rollback to previous delegate contract
    function delegateRollback() external override onlyMinipoolOwner notSelf {
        // Make sure they have upgraded before
        require(rocketMinipoolDelegatePrev != address(0x0), "Previous delegate contract is not set");
        // Store original
        address originalDelegate = rocketMinipoolDelegate;
        // Update delegate to previous and zero out previous
        rocketMinipoolDelegate = rocketMinipoolDelegatePrev;
        rocketMinipoolDelegatePrev = address(0x0);
        // Log event
        emit DelegateRolledBack(originalDelegate, rocketMinipoolDelegate, block.timestamp);
    }

    /// @notice Sets the flag to automatically use the latest delegate contract or not
    /// @param _setting If true, will always use the latest delegate contract
    function setUseLatestDelegate(bool _setting) external override onlyMinipoolOwner notSelf {
        useLatestDelegate = _setting;
    }

    /// @notice Returns true if this minipool always uses the latest delegate contract
    function getUseLatestDelegate() external override view returns (bool) {
        return useLatestDelegate;
    }

    /// @notice Returns the address of the minipool's stored delegate
    function getDelegate() external override view returns (address) {
        return rocketMinipoolDelegate;
    }

    /// @notice Returns the address of the minipool's previous delegate (or address(0) if not set)
    function getPreviousDelegate() external override view returns (address) {
        return rocketMinipoolDelegatePrev;
    }

    /// @notice Returns the delegate which will be used when calling this minipool taking into account useLatestDelegate setting
    function getEffectiveDelegate() external override view returns (address) {
        return useLatestDelegate ? getContractAddress("rocketMinipoolDelegate") : rocketMinipoolDelegate;
    }

    /// @notice Delegates all calls to minipool delegate contract (or latest if flag is set)
    fallback(bytes calldata _input) external payable notSelf returns (bytes memory) {
        // If useLatestDelegate is set, use the latest delegate contract
        address delegateContract = useLatestDelegate ? getContractAddress("rocketMinipoolDelegate") : rocketMinipoolDelegate;
        // Check for contract existence
        require(contractExists(delegateContract), "Delegate contract does not exist");
        // Execute delegatecall
        (bool success, bytes memory data) = delegateContract.delegatecall(_input);
        if (!success) { revert(getRevertMessage(data)); }
        return data;
    }

    /// @dev Get the address of a Rocket Pool network contract
    function getContractAddress(string memory _contractName) private view returns (address) {
        address contractAddress = rocketStorage.getAddress(keccak256(abi.encodePacked("contract.address", _contractName)));
        require(contractAddress != address(0x0), "Contract not found");
        return contractAddress;
    }

    /// @dev Get a revert message from delegatecall return data
    function getRevertMessage(bytes memory _returnData) private pure returns (string memory) {
        if (_returnData.length < 68) { return "Transaction reverted silently"; }
        assembly {
            _returnData := add(_returnData, 0x04)
        }
        return abi.decode(_returnData, (string));
    }

    /// @dev Returns true if contract exists at _contractAddress (if called during that contract's construction it will return a false negative)
    function contractExists(address _contractAddress) private view returns (bool) {
        uint32 codeSize;
        assembly {
            codeSize := extcodesize(_contractAddress)
        }
        return codeSize > 0;
    }
}

/**
  *       .
  *      / \
  *     |.'.|
  *     |'.'|
  *   ,'|   |`.
  *  |,-'-|-'-.|
  *   __|_| |         _        _      _____           _
  *  | ___ \|        | |      | |    | ___ \         | |
  *  | |_/ /|__   ___| | _____| |_   | |_/ /__   ___ | |
  *  |    // _ \ / __| |/ / _ \ __|  |  __/ _ \ / _ \| |
  *  | |\ \ (_) | (__|   <  __/ |_   | | | (_) | (_) | |
  *  \_| \_\___/ \___|_|\_\___|\__|  \_|  \___/ \___/|_|
  * +---------------------------------------------------+
  * |  DECENTRALISED STAKING PROTOCOL FOR ETHEREUM 2.0  |
  * +---------------------------------------------------+
  *
  *  Rocket Pool is a first-of-its-kind ETH2 Proof of Stake protocol, designed to be community owned,
  *  decentralised, trustless and compatible with staking in Ethereum 2.0.
  *
  *  For more information about Rocket Pool, visit https://rocketpool.net
  *
  *  Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
  *
  */

pragma solidity >0.5.0 <0.9.0;

// SPDX-License-Identifier: GPL-3.0-only

interface RocketStorageInterface {

    // Deploy status
    function getDeployedStatus() external view returns (bool);

    // Guardian
    function getGuardian() external view returns(address);
    function setGuardian(address _newAddress) external;
    function confirmGuardian() external;

    // Getters
    function getAddress(bytes32 _key) external view returns (address);
    function getUint(bytes32 _key) external view returns (uint);
    function getString(bytes32 _key) external view returns (string memory);
    function getBytes(bytes32 _key) external view returns (bytes memory);
    function getBool(bytes32 _key) external view returns (bool);
    function getInt(bytes32 _key) external view returns (int);
    function getBytes32(bytes32 _key) external view returns (bytes32);

    // Setters
    function setAddress(bytes32 _key, address _value) external;
    function setUint(bytes32 _key, uint _value) external;
    function setString(bytes32 _key, string calldata _value) external;
    function setBytes(bytes32 _key, bytes calldata _value) external;
    function setBool(bytes32 _key, bool _value) external;
    function setInt(bytes32 _key, int _value) external;
    function setBytes32(bytes32 _key, bytes32 _value) external;

    // Deleters
    function deleteAddress(bytes32 _key) external;
    function deleteUint(bytes32 _key) external;
    function deleteString(bytes32 _key) external;
    function deleteBytes(bytes32 _key) external;
    function deleteBool(bytes32 _key) external;
    function deleteInt(bytes32 _key) external;
    function deleteBytes32(bytes32 _key) external;

    // Arithmetic
    function addUint(bytes32 _key, uint256 _amount) external;
    function subUint(bytes32 _key, uint256 _amount) external;

    // Protected storage
    function getNodeWithdrawalAddress(address _nodeAddress) external view returns (address);
    function getNodePendingWithdrawalAddress(address _nodeAddress) external view returns (address);
    function setWithdrawalAddress(address _nodeAddress, address _newWithdrawalAddress, bool _confirm) external;
    function confirmWithdrawalAddress(address _nodeAddress) external;
}

File 3 of 6 : MinipoolDeposit.sol
/**
  *       .
  *      / \
  *     |.'.|
  *     |'.'|
  *   ,'|   |`.
  *  |,-'-|-'-.|
  *   __|_| |         _        _      _____           _
  *  | ___ \|        | |      | |    | ___ \         | |
  *  | |_/ /|__   ___| | _____| |_   | |_/ /__   ___ | |
  *  |    // _ \ / __| |/ / _ \ __|  |  __/ _ \ / _ \| |
  *  | |\ \ (_) | (__|   <  __/ |_   | | | (_) | (_) | |
  *  \_| \_\___/ \___|_|\_\___|\__|  \_|  \___/ \___/|_|
  * +---------------------------------------------------+
  * |  DECENTRALISED STAKING PROTOCOL FOR ETHEREUM 2.0  |
  * +---------------------------------------------------+
  *
  *  Rocket Pool is a first-of-its-kind ETH2 Proof of Stake protocol, designed to be community owned,
  *  decentralised, trustless and compatible with staking in Ethereum 2.0.
  *
  *  For more information about Rocket Pool, visit https://rocketpool.net
  *
  *  Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
  *
  */

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-only

// Represents the type of deposits required by a minipool

enum MinipoolDeposit {
    None,       // Marks an invalid deposit type
    Full,       // The minipool requires 32 ETH from the node operator, 16 ETH of which will be refinanced from user deposits
    Half,       // The minipool required 16 ETH from the node operator to be matched with 16 ETH from user deposits
    Empty,      // The minipool requires 0 ETH from the node operator to be matched with 32 ETH from user deposits (trusted nodes only)
    Variable    // Indicates this minipool is of the new generation that supports a variable deposit amount
}

File 4 of 6 : MinipoolStatus.sol
/**
  *       .
  *      / \
  *     |.'.|
  *     |'.'|
  *   ,'|   |`.
  *  |,-'-|-'-.|
  *   __|_| |         _        _      _____           _
  *  | ___ \|        | |      | |    | ___ \         | |
  *  | |_/ /|__   ___| | _____| |_   | |_/ /__   ___ | |
  *  |    // _ \ / __| |/ / _ \ __|  |  __/ _ \ / _ \| |
  *  | |\ \ (_) | (__|   <  __/ |_   | | | (_) | (_) | |
  *  \_| \_\___/ \___|_|\_\___|\__|  \_|  \___/ \___/|_|
  * +---------------------------------------------------+
  * |  DECENTRALISED STAKING PROTOCOL FOR ETHEREUM 2.0  |
  * +---------------------------------------------------+
  *
  *  Rocket Pool is a first-of-its-kind ETH2 Proof of Stake protocol, designed to be community owned,
  *  decentralised, trustless and compatible with staking in Ethereum 2.0.
  *
  *  For more information about Rocket Pool, visit https://rocketpool.net
  *
  *  Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
  *
  */

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-only

// Represents a minipool's status within the network

enum MinipoolStatus {
    Initialised,    // The minipool has been initialised and is awaiting a deposit of user ETH
    Prelaunch,      // The minipool has enough ETH to begin staking and is awaiting launch by the node operator
    Staking,        // The minipool is currently staking
    Withdrawable,   // NO LONGER USED
    Dissolved       // The minipool has been dissolved and its user deposited ETH has been returned to the deposit pool
}

File 5 of 6 : RocketMinipoolStorageLayout.sol
/**
  *       .
  *      / \
  *     |.'.|
  *     |'.'|
  *   ,'|   |`.
  *  |,-'-|-'-.|
  *   __|_| |         _        _      _____           _
  *  | ___ \|        | |      | |    | ___ \         | |
  *  | |_/ /|__   ___| | _____| |_   | |_/ /__   ___ | |
  *  |    // _ \ / __| |/ / _ \ __|  |  __/ _ \ / _ \| |
  *  | |\ \ (_) | (__|   <  __/ |_   | | | (_) | (_) | |
  *  \_| \_\___/ \___|_|\_\___|\__|  \_|  \___/ \___/|_|
  * +---------------------------------------------------+
  * |  DECENTRALISED STAKING PROTOCOL FOR ETHEREUM 2.0  |
  * +---------------------------------------------------+
  *
  *  Rocket Pool is a first-of-its-kind ETH2 Proof of Stake protocol, designed to be community owned,
  *  decentralised, trustless and compatible with staking in Ethereum 2.0.
  *
  *  For more information about Rocket Pool, visit https://rocketpool.net
  *
  *  Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
  *
  */

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-only

import "../../interface/RocketStorageInterface.sol";
import "../../types/MinipoolDeposit.sol";
import "../../types/MinipoolStatus.sol";

// The RocketMinipool contract storage layout, shared by RocketMinipoolDelegate

// ******************************************************
// Note: This contract MUST NOT BE UPDATED after launch.
// All deployed minipool contracts must maintain a
// Consistent storage layout with RocketMinipoolDelegate.
// ******************************************************

abstract contract RocketMinipoolStorageLayout {
    // Storage state enum
    enum StorageState {
        Undefined,
        Uninitialised,
        Initialised
    }

	// Main Rocket Pool storage contract
    RocketStorageInterface internal rocketStorage = RocketStorageInterface(0);

    // Status
    MinipoolStatus internal status;
    uint256 internal statusBlock;
    uint256 internal statusTime;
    uint256 internal withdrawalBlock;

    // Deposit type
    MinipoolDeposit internal depositType;

    // Node details
    address internal nodeAddress;
    uint256 internal nodeFee;
    uint256 internal nodeDepositBalance;
    bool internal nodeDepositAssigned;          // NO LONGER IN USE
    uint256 internal nodeRefundBalance;
    uint256 internal nodeSlashBalance;

    // User deposit details
    uint256 internal userDepositBalanceLegacy;
    uint256 internal userDepositAssignedTime;

    // Upgrade options
    bool internal useLatestDelegate = false;
    address internal rocketMinipoolDelegate;
    address internal rocketMinipoolDelegatePrev;

    // Local copy of RETH address
    address internal rocketTokenRETH;

    // Local copy of penalty contract
    address internal rocketMinipoolPenalty;

    // Used to prevent direct access to delegate and prevent calling initialise more than once
    StorageState internal storageState = StorageState.Undefined;

    // Whether node operator has finalised the pool
    bool internal finalised;

    // Trusted member scrub votes
    mapping(address => bool) internal memberScrubVotes;
    uint256 internal totalScrubVotes;

    // Variable minipool
    uint256 internal preLaunchValue;
    uint256 internal userDepositBalance;

    // Vacant minipool
    bool internal vacant;
    uint256 internal preMigrationBalance;

    // User distribution
    bool internal userDistributed;
    uint256 internal userDistributeTime;
}

/**
  *       .
  *      / \
  *     |.'.|
  *     |'.'|
  *   ,'|   |`.
  *  |,-'-|-'-.|
  *   __|_| |         _        _      _____           _
  *  | ___ \|        | |      | |    | ___ \         | |
  *  | |_/ /|__   ___| | _____| |_   | |_/ /__   ___ | |
  *  |    // _ \ / __| |/ / _ \ __|  |  __/ _ \ / _ \| |
  *  | |\ \ (_) | (__|   <  __/ |_   | | | (_) | (_) | |
  *  \_| \_\___/ \___|_|\_\___|\__|  \_|  \___/ \___/|_|
  * +---------------------------------------------------+
  * |  DECENTRALISED STAKING PROTOCOL FOR ETHEREUM 2.0  |
  * +---------------------------------------------------+
  *
  *  Rocket Pool is a first-of-its-kind ETH2 Proof of Stake protocol, designed to be community owned,
  *  decentralised, trustless and compatible with staking in Ethereum 2.0.
  *
  *  For more information about Rocket Pool, visit https://rocketpool.net
  *
  *  Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
  *
  */

pragma solidity >0.5.0 <0.9.0;

// SPDX-License-Identifier: GPL-3.0-only

interface RocketMinipoolBaseInterface {
    function initialise(address _rocketStorage, address _nodeAddress) external;
    function delegateUpgrade() external;
    function delegateRollback() external;
    function setUseLatestDelegate(bool _setting) external;
    function getUseLatestDelegate() external view returns (bool);
    function getDelegate() external view returns (address);
    function getPreviousDelegate() external view returns (address);
    function getEffectiveDelegate() external view returns (address);
}

Settings
{
  "optimizer": {
    "enabled": true,
    "runs": 15000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

Contract ABI

API
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldDelegate","type":"address"},{"indexed":false,"internalType":"address","name":"newDelegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"time","type":"uint256"}],"name":"DelegateRolledBack","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldDelegate","type":"address"},{"indexed":false,"internalType":"address","name":"newDelegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"time","type":"uint256"}],"name":"DelegateUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"time","type":"uint256"}],"name":"EtherReceived","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"delegateRollback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"delegateUpgrade","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getDelegate","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getEffectiveDelegate","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPreviousDelegate","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getUseLatestDelegate","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_rocketStorage","type":"address"},{"internalType":"address","name":"_nodeAddress","type":"address"}],"name":"initialise","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_setting","type":"bool"}],"name":"setUseLatestDelegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading
Loading...
Loading
[ 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.