Overview
ETH Balance
0.07641202995 ETH
Eth Value
$295.03 (@ $3,861.03/ETH)More Info
Private Name Tags
ContractCreator
Latest 10 internal transactions
Advanced mode:
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
21253712 | 11 days ago | 0.10396412 ETH | ||||
20847647 | 67 days ago | 0.14013599 ETH | ||||
20847647 | 67 days ago | 0.25461329 ETH | ||||
19594300 | 243 days ago | 0.16559111 ETH | ||||
19594300 | 243 days ago | 0.30086273 ETH | ||||
18066559 | 457 days ago | 31 ETH | ||||
18062366 | 457 days ago | 31 ETH | ||||
18062366 | 457 days ago | 1 ETH | ||||
18062366 | 457 days ago | 1 ETH | ||||
18062366 | 457 days ago | Contract Creation | 0 ETH |
Loading...
Loading
Minimal Proxy Contract for 0x560656c8947564363497e9c78a8bdeff8d3eff33
Contract Name:
RocketMinipoolBase
Compiler Version
v0.7.6+commit.7338295f
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; }
/** * . * / \ * |.'.| * |'.'| * ,'| |`. * |,-'-|-'-.| * __|_| | _ _ _____ _ * | ___ \| | | | | | ___ \ | | * | |_/ /|__ ___| | _____| |_ | |_/ /__ ___ | | * | // _ \ / __| |/ / _ \ __| | __/ _ \ / _ \| | * | |\ \ (_) | (__| < __/ |_ | | | (_) | (_) | | * \_| \_\___/ \___|_|\_\___|\__| \_| \___/ \___/|_| * +---------------------------------------------------+ * | 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 }
/** * . * / \ * |.'.| * |'.'| * ,'| |`. * |,-'-|-'-.| * __|_| | _ _ _____ _ * | ___ \| | | | | | ___ \ | | * | |_/ /|__ ___| | _____| |_ | |_/ /__ ___ | | * | // _ \ / __| |/ / _ \ __| | __/ _ \ / _ \| | * | |\ \ (_) | (__| < __/ |_ | | | (_) | (_) | | * \_| \_\___/ \___|_|\_\___|\__| \_| \___/ \___/|_| * +---------------------------------------------------+ * | 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 }
/** * . * / \ * |.'.| * |'.'| * ,'| |`. * |,-'-|-'-.| * __|_| | _ _ _____ _ * | ___ \| | | | | | ___ \ | | * | |_/ /|__ ___| | _____| |_ | |_/ /__ ___ | | * | // _ \ / __| |/ / _ \ __| | __/ _ \ / _ \| | * | |\ \ (_) | (__| < __/ |_ | | | (_) | (_) | | * \_| \_\___/ \___|_|\_\___|\__| \_| \___/ \___/|_| * +---------------------------------------------------+ * | 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); }
{ "optimizer": { "enabled": true, "runs": 15000 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } } }
[{"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"}]
Loading...
Loading
Loading...
Loading
Latest 25 from a total of 52 withdrawals (1.041579293 ETH withdrawn)
Validator Index | Block | Amount | |
---|---|---|---|
917014 | 21274319 | 8 days ago | 0.019191465 ETH |
917014 | 21206986 | 17 days ago | 0.065393489 ETH |
917014 | 21139330 | 27 days ago | 0.019266385 ETH |
917014 | 21071950 | 36 days ago | 0.019199905 ETH |
917014 | 21004865 | 46 days ago | 0.019271289 ETH |
917014 | 20937668 | 55 days ago | 0.019126762 ETH |
917014 | 20870469 | 64 days ago | 0.01892686 ETH |
917014 | 20803726 | 74 days ago | 0.019097152 ETH |
917014 | 20737054 | 83 days ago | 0.019196094 ETH |
917014 | 20670611 | 92 days ago | 0.018785595 ETH |
917014 | 20604528 | 101 days ago | 0.018968973 ETH |
917014 | 20538593 | 111 days ago | 0.01907263 ETH |
917014 | 20472702 | 120 days ago | 0.018876642 ETH |
917014 | 20407426 | 129 days ago | 0.018696507 ETH |
917014 | 20342826 | 138 days ago | 0.018595782 ETH |
917014 | 20278360 | 147 days ago | 0.018835924 ETH |
917014 | 20213945 | 156 days ago | 0.018496171 ETH |
917014 | 20149755 | 165 days ago | 0.018550791 ETH |
917014 | 20086059 | 174 days ago | 0.062951023 ETH |
917014 | 20022960 | 183 days ago | 0.018530151 ETH |
917014 | 19960302 | 191 days ago | 0.01865292 ETH |
917014 | 19897389 | 200 days ago | 0.017509627 ETH |
917014 | 19834707 | 209 days ago | 0.017729782 ETH |
917014 | 19772480 | 218 days ago | 0.018158742 ETH |
917014 | 19710923 | 226 days ago | 0.016011703 ETH |
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
ETH | Ether (ETH) | 100.00% | $3,861.03 | 0.0764 | $295.03 |
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.