Rocket Pool Atlas (v1.2)

/// @notice Distributes the balance of this contract to its owners
function distribute() override external {
    // Calculate node share
    uint256 nodeShare = getNodeShare();
    // Transfer node share
    address withdrawalAddress = rocketStorage.getNodeWithdrawalAddress(nodeAddress);
    (bool success,) = withdrawalAddress.call{value : nodeShare}("");
    require(success);
    // Transfer user share
    uint256 userShare = address(this).balance;
    address rocketTokenRETH = rocketStorage.getAddress(rocketTokenRETHKey);
    payable(rocketTokenRETH).transfer(userShare);
    // Emit event
    emit FeesDistributed(nodeAddress, userShare, nodeShare, block.timestamp);
}

// Set a node's withdrawal address
function setWithdrawalAddress(address _nodeAddress, address _newWithdrawalAddress, bool _confirm) external override {
    // Check new withdrawal address
    require(_newWithdrawalAddress != address(0x0), "Invalid withdrawal address");
    // Confirm the transaction is from the node's current withdrawal address
    address withdrawalAddress = getNodeWithdrawalAddress(_nodeAddress);
    require(withdrawalAddress == msg.sender, "Only a tx from a node's withdrawal address can update it");
    // Update immediately if confirmed
    if (_confirm) {
        updateWithdrawalAddress(_nodeAddress, _newWithdrawalAddress);
    }
    // Set pending withdrawal address if not confirmed
    else {
        pendingWithdrawalAddresses[_nodeAddress] = _newWithdrawalAddress;
    }
}

// Called by node operator to finalise the pool and unlock their RPL stake
function finalise() external override onlyInitialised onlyMinipoolOwnerOrWithdrawalAddress(msg.sender) {
    // Can only call if withdrawable and can only be called once
    require(status == MinipoolStatus.Withdrawable, "Minipool must be withdrawable");
    // Node operator cannot finalise the pool unless distributeBalance has been called
    require(withdrawalBlock > 0, "Minipool balance must have been distributed at least once");
    // Finalise the pool
    _finalise();
}

// Perform any slashings, refunds, and unlock NO's stake
function _finalise() private {
    // Get contracts
    RocketMinipoolManagerInterface rocketMinipoolManager = RocketMinipoolManagerInterface(getContractAddress("rocketMinipoolManager"));
    // Can only finalise the pool once
    require(!finalised, "Minipool has already been finalised");
    // If slash is required then perform it
    if (nodeSlashBalance > 0) {
        _slash();
    }
    // Refund node operator if required
    if (nodeRefundBalance > 0) {
        _refund();
    }
    // Send any left over ETH to rETH contract
    if (address(this).balance > 0) {
        // Send user amount to rETH contract
        payable(rocketTokenRETH).transfer(address(this).balance);
    }
    // Trigger a deposit of excess collateral from rETH contract to deposit pool
    RocketTokenRETHInterface(rocketTokenRETH).depositExcessCollateral();
    // Unlock node operator's RPL
    rocketMinipoolManager.incrementNodeFinalisedMinipoolCount(nodeAddress);
    // Update unbonded validator count if minipool is unbonded
    if (depositType == MinipoolDeposit.Empty) {
        RocketDAONodeTrustedInterface rocketDAONodeTrusted = RocketDAONodeTrustedInterface(getContractAddress("rocketDAONodeTrusted"));
        rocketDAONodeTrusted.decrementMemberUnbondedValidatorCount(nodeAddress);
    }
    // Set finalised flag
    finalised = true;
}

function _refund() private {
    // Update refund balance
    uint256 refundAmount = nodeRefundBalance;
    nodeRefundBalance = 0;
    // Get node withdrawal address
    address nodeWithdrawalAddress = rocketStorage.getNodeWithdrawalAddress(nodeAddress);
    // Transfer refund amount
    (bool success,) = nodeWithdrawalAddress.call{value : refundAmount}("");
    require(success, "ETH refund amount was not successfully transferred to node operator");
    // Emit ether withdrawn event
    emit EtherWithdrawn(nodeWithdrawalAddress, refundAmount, block.timestamp);
}

// Increments _nodeAddress' number of minipools that have been finalised
function incrementNodeFinalisedMinipoolCount(address _nodeAddress) override external onlyLatestContract("rocketMinipoolManager", address(this)) onlyRegisteredMinipool(msg.sender) {
    // Update the node specific count
    addUint(keccak256(abi.encodePacked("node.minipools.finalised.count", _nodeAddress)), 1);
    // Update the total count
    addUint(keccak256(bytes("minipools.finalised.count")), 1);
}

}
function decrementMemberUnbondedValidatorCount(address _nodeAddress) override external onlyLatestContract("rocketDAONodeTrusted", address(this)) onlyRegisteredMinipool(msg.sender) {
    subUint(keccak256(abi.encodePacked(daoNameSpace, "member.validator.unbonded.count", _nodeAddress)), 1);
}

function _slash() private {
    // Get contracts
    RocketNodeStakingInterface rocketNodeStaking = RocketNodeStakingInterface(getContractAddress("rocketNodeStaking"));
    // Slash required amount and reset storage value
    uint256 slashAmount = nodeSlashBalance;
    nodeSlashBalance = 0;
    rocketNodeStaking.slashRPL(nodeAddress, slashAmount);
    // Record slashing
    slashed = true;
}

function _slash() private {
    // Get contracts
    RocketNodeStakingInterface rocketNodeStaking = RocketNodeStakingInterface(getContractAddress("rocketNodeStaking"));
    // Slash required amount and reset storage value
    uint256 slashAmount = nodeSlashBalance;
    nodeSlashBalance = 0;
    rocketNodeStaking.slashRPL(nodeAddress, slashAmount);
}

// In the event that the majority/all of members go offline permanently and no more proposals could be passed, a current member or a regular node can 'challenge' a DAO members node to respond
// If it does not respond in the given window, it can be removed as a member. The one who removes the member after the challenge isn't met, must be another node other than the proposer to provide some oversight
// This should only be used in an emergency situation to recover the DAO. Members that need removing when consensus is still viable, should be done via the 'kick' method.
function actionChallengeMake(address _nodeAddress) override external onlyTrustedNode(_nodeAddress) onlyRegisteredNode(msg.sender) onlyLatestContract("rocketDAONodeTrustedActions", address(this)) payable {
    // Load contracts
    RocketDAONodeTrustedInterface rocketDAONode = RocketDAONodeTrustedInterface(getContractAddress("rocketDAONodeTrusted"));
    RocketDAONodeTrustedSettingsMembersInterface rocketDAONodeTrustedSettingsMembers = RocketDAONodeTrustedSettingsMembersInterface(getContractAddress("rocketDAONodeTrustedSettingsMembers"));
    // Members can challenge other members for free, but for a regular bonded node to challenge a DAO member, requires non-refundable payment to prevent spamming
    if(rocketDAONode.getMemberIsValid(msg.sender) != true) require(msg.value == rocketDAONodeTrustedSettingsMembers.getChallengeCost(), "Non DAO members must pay ETH to challenge a members node");
    // Can't challenge yourself duh
    require(msg.sender != _nodeAddress, "You cannot challenge yourself");
    // Is this member already being challenged?

/// @notice Withdraw node balances from the minipool and close it. Only accepts calls from the owner
function close() override external onlyMinipoolOwner(msg.sender) onlyInitialised {
    // Check current status
    require(status == MinipoolStatus.Dissolved, "The minipool can only be closed while dissolved");
    // Distribute funds to owner
    distributeToOwner();
    // Destroy minipool
    RocketMinipoolManagerInterface rocketMinipoolManager = RocketMinipoolManagerInterface(getContractAddress("rocketMinipoolManager"));
    require(rocketMinipoolManager.getMinipoolExists(address(this)), "Minipool already closed");
    rocketMinipoolManager.destroyMinipool();
    // Clear state
    nodeDepositBalance = 0;
    nodeRefundBalance = 0;
    userDepositBalance = 0;
    userDepositBalanceLegacy = 0;
    userDepositAssignedTime = 0;
}

// Save block to prevent multiple withdrawals within a few blocks
withdrawalBlock = block.number;

/// @dev Slash node operator's RPL balance based on nodeSlashBalance
function _slash() private {
    // Get contracts
    RocketNodeStakingInterface rocketNodeStaking = RocketNodeStakingInterface(getContractAddress("rocketNodeStaking"));
    // Slash required amount and reset storage value
    uint256 slashAmount = nodeSlashBalance;
    nodeSlashBalance = 0;
    rocketNodeStaking.slashRPL(nodeAddress, slashAmount);
    // Record slashing
    slashed = true;
}

// Get desired to amount
uint256 newBondAmount = getUint(keccak256(abi.encodePacked("minipool.bond.reduction.value", msg.sender)));
require(rocketNodeDeposit.isValidDepositAmount(newBondAmount), "Invalid bond amount");
// Calculate difference
uint256 existingBondAmount = minipool.getNodeDepositBalance();
uint256 delta = existingBondAmount.sub(newBondAmount);
// Get node address
address nodeAddress = minipool.getNodeAddress();
// Increase ETH matched or revert if exceeds limit based on current RPL stake
rocketNodeDeposit.increaseEthMatched(nodeAddress, delta);
// Increase node operator's deposit credit
rocketNodeDeposit.increaseDepositCreditBalance(nodeAddress, delta);
// Clean up state
deleteUint(keccak256(abi.encodePacked("minipool.bond.reduction.time", msg.sender)));
deleteUint(keccak256(abi.encodePacked("minipool.bond.reduction.value", msg.sender)));

// Execute inflation if required
rplContract.inflationMintTokens();
// Increment the reward index and update the claim interval timestamp
incrementRewardIndex();

function refund() override external onlyMinipoolOwnerOrWithdrawalAddress(msg.sender) onlyInitialised {
    // Check refund balance
    require(nodeRefundBalance > 0, "No amount of the node deposit is available for refund");
    // If this minipool was distributed by a user, force finalisation on the node operator
    if (!finalised && userDistributed) {
        _finalise();
    }
    // Refund node
    _refund();
}

function _finalise() private {
    // Get contracts
    RocketMinipoolManagerInterface rocketMinipoolManager = RocketMinipoolManagerInterface(getContractAddress("rocketMinipoolManager"));
    // Can only finalise the pool once
    require(!finalised, "Minipool has already been finalised");
    // Set finalised flag
    finalised = true;
    // If slash is required then perform it
    if (nodeSlashBalance > 0) {
        _slash();
    }
    // Refund node operator if required
    if (nodeRefundBalance > 0) {
        _refund();
    }

// Sanity check that refund balance is zero
require(nodeRefundBalance == 0, "Refund balance not zero");

// Remove from vacant set
rocketMinipoolManager.removeVacantMinipool();

if (ownerCalling) {
    // Finalise the minipool if the owner is calling
    _finalise();

fallback() external payable {
    address _target = rocketStorage.getAddress(distributorStorageKey);
    assembly {
        calldatacopy(0x0, 0x0, calldatasize())
        let result := delegatecall(gas(), _target, 0x0, calldatasize(), 0x0, 0)
        returndatacopy(0x0, 0x0, returndatasize())
        switch result case 0 {revert(0, returndatasize())} default {return (0, returndatasize())}
    }
}

function getAddress(bytes32 _key) override external view returns (address r) {
    return addressStorage[_key];
}

assembly {
    codeSize := extcodesize(_target)
}
require(codeSize > 0);

RocketDAONodeTrustedInterface rocketDAONodeTrusted = RocketDAONodeTrustedInterface(getContractAddress("rocketDAONodeTrusted"));
if (calcBase.mul(submissionCount).div(rocketDAONodeTrusted.getMemberCount()) >= rocketDAOProtocolSettingsNetwork.getNodeConsensusThreshold()) {
    // Update the price
    updatePrices(_block, _rplPrice);
}

function executeUpdatePrices(uint256 _block, uint256 _rplPrice) override external onlyLatestContract("rocketNetworkPrices", address(this)) {
    // Check settings

RocketDAONodeTrustedSettingsMinipoolInterface rocketDAONodeTrustedSettingsMinipool = RocketDAONodeTrustedSettingsMinipoolInterface(getContractAddress("rocketDAONodeTrustedSettingsMinipool"));
uint256 quorum = rocketDAONode.getMemberCount().mul(rocketDAONodeTrustedSettingsMinipool.getCancelBondReductionQuorum()).div(calcBase);
bytes32 totalCancelVotesKey = keccak256(abi.encodePacked("minipool.bond.reduction.vote.count", _minipoolAddress));
uint256 totalCancelVotes = getUint(totalCancelVotesKey).add(1);
if (totalCancelVotes > quorum) {

RocketDAONodeTrustedInterface rocketDAONodeTrusted = RocketDAONodeTrustedInterface(getContractAddress("rocketDAONodeTrusted"));
if (calcBase.mul(submissionCount).div(rocketDAONodeTrusted.getMemberCount()) >= rocketDAOProtocolSettingsNetwork.getNodePenaltyThreshold()) {
    setBool(executedKey, true);
    incrementMinipoolPenaltyCount(_minipoolAddress);
}

// Executes incrementMinipoolPenaltyCount if consensus threshold is reached
function executeUpdatePenalty(address _minipoolAddress, uint256 _block) override external onlyLatestContract("rocketNetworkPenalties", address(this)) {
    // Get contracts
    RocketDAOProtocolSettingsNetworkInterface rocketDAOProtocolSettingsNetwork = RocketDAOProtocolSettingsNetworkInterface(getContractAddress("rocketDAOProtocolSettingsNetwork"));
    // Get submission keys

function setSettingRewardsClaimer(string memory _contractName, uint256 _perc) override public onlyDAOProtocolProposal {
    // Get the total perc set, can't be more than 100
    uint256 percTotal = getRewardsClaimersPercTotal();
    // If this group already exists, it will update the perc
    uint256 percTotalUpdate = percTotal.add(_perc).sub(getRewardsClaimerPerc(_contractName));
    // Can't be more than a total claim amount of 100%
    require(percTotalUpdate <= 1 ether, "Claimers cannot total more than 100%");
    // Update the total
    setUint(keccak256(abi.encodePacked(settingNameSpace,"rewards.claims", "group.totalPerc")), percTotalUpdate);
    // Update/Add the claimer amount
    setUint(keccak256(abi.encodePacked(settingNameSpace, "rewards.claims", "group.amount", _contractName)), _perc);
    // Set the time it was updated at
    setUint(keccak256(abi.encodePacked(settingNameSpace, "rewards.claims", "group.amount.updated.time", _contractName)), block.timestamp);
}

function setSettingRewardsClaimer(string memory _contractName, uint256 _perc) override public onlyDAOProtocolProposal {
    // Get the total perc set, can't be more than 100
    uint256 percTotal = getRewardsClaimersPercTotal();
    // If this group already exists, it will update the perc
    uint256 percTotalUpdate = percTotal.add(_perc).sub(getRewardsClaimerPerc(_contractName));
    // Can't be more than a total claim amount of 100%
    require(percTotalUpdate <= 1 ether, "Claimers cannot total more than 100%");
    // Update the total
    setUint(keccak256(abi.encodePacked(settingNameSpace,"rewards.claims", "group.totalPerc")), percTotalUpdate);
    // Update/Add the claimer amount
    setUint(keccak256(abi.encodePacked(settingNameSpace, "rewards.claims", "group.amount", _contractName)), _perc);
    // Set the time it was updated at
    setUint(keccak256(abi.encodePacked(settingNameSpace, "rewards.claims", "group.amount.updated.time", _contractName)), block.timestamp);
}

/// @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);

function beginReduceBondAmount(address _minipoolAddress, uint256 _newBondAmount) override external onlyLatestContract("rocketMinipoolBondReducer", address(this)) {
    RocketMinipoolInterface minipool = RocketMinipoolInterface(_minipoolAddress);

/// @notice Returns whether owner of given minipool can reduce bond amount given the waiting period constraint
/// @param _minipoolAddress Address of the minipool
function canReduceBondAmount(address _minipoolAddress) override public view returns (bool) {
    RocketMinipoolInterface minipool = RocketMinipoolInterface(_minipoolAddress);
    RocketDAONodeTrustedSettingsMinipoolInterface rocketDAONodeTrustedSettingsMinipool = RocketDAONodeTrustedSettingsMinipoolInterface(getContractAddress("rocketDAONodeTrustedSettingsMinipool"));
    uint256 reduceBondTime = getUint(keccak256(abi.encodePacked("minipool.bond.reduction.time", _minipoolAddress)));
    return rocketDAONodeTrustedSettingsMinipool.isWithinBondReductionWindow(block.timestamp.sub(reduceBondTime));
}

function voteCancelReduction(address _minipoolAddress) override external onlyTrustedNode(msg.sender) onlyLatestContract("rocketMinipoolBondReducer", address(this)) {
    // Prevent calling if consensus has already been reached
    require(!getReduceBondCancelled(_minipoolAddress), "Already cancelled");
    // Get contracts
    RocketMinipoolInterface minipool = RocketMinipoolInterface(_minipoolAddress);

/// @dev Internal logic to set a minipool's pubkey
/// @param _pubkey The pubkey to set for the calling minipool
function _setMinipoolPubkey(address _minipool, bytes calldata _pubkey) private {
    // Load contracts
    AddressSetStorageInterface addressSetStorage = AddressSetStorageInterface(getContractAddress("addressSetStorage"));
    // Initialize minipool & get properties
    RocketMinipoolInterface minipool = RocketMinipoolInterface(_minipool);

function getMinipoolDetails(address _minipoolAddress) override external view returns (MinipoolDetails memory) {
    // Get contracts
    RocketMinipoolInterface minipoolInterface = RocketMinipoolInterface(_minipoolAddress);
    RocketMinipoolBase minipool = RocketMinipoolBase(payable(_minipoolAddress));
    RocketNetworkPenaltiesInterface rocketNetworkPenalties = RocketNetworkPenaltiesInterface(getContractAddress("rocketNetworkPenalties"));

contract RocketNodeDistributor is RocketNodeDistributorStorageLayout {
    bytes32 immutable distributorStorageKey;

    constructor(address _nodeAddress, address _rocketStorage) {
        rocketStorage = RocketStorageInterface(_rocketStorage);
        nodeAddress = _nodeAddress;

/// @dev Set the main Rocket Storage address
constructor(RocketStorageInterface _rocketStorageAddress) {
    // Update the contract address
    rocketStorage = RocketStorageInterface(_rocketStorageAddress);
}

function burnToken(ERC20Burnable _tokenAddress, uint256 _amount) override external onlyLatestNetworkContract {
    // Get contract key
    bytes32 contractKey = keccak256(abi.encodePacked(getContractName(msg.sender), _tokenAddress));
    // Update balances
    tokenBalances[contractKey] = tokenBalances[contractKey].sub(_amount);
    // Get the token ERC20 instance
    ERC20Burnable tokenContract = ERC20Burnable(_tokenAddress);

constructor(RocketStorageInterface _rocketStorageAddress, IERC20 _rocketTokenRPLFixedSupplyAddress) RocketBase(_rocketStorageAddress) ERC20("Rocket Pool Protocol", "RPL") {
    // Version
    version = 1;
    // Set the mainnet RPL fixed supply token address
    rplFixedSupplyContract = IERC20(_rocketTokenRPLFixedSupplyAddress);

/// @dev Sets the bond value and vacancy flag on this minipool
/// @param _bondAmount The bond amount selected by the node operator
/// @param _currentBalance The current balance of the validator on the beaconchain (will be checked by oDAO and scrubbed if not correct)
function prepareVacancy(uint256 _bondAmount, uint256 _currentBalance) override external onlyLatestContract("rocketMinipoolManager", msg.sender) onlyInitialised {
    // Check status
    require(status == MinipoolStatus.Initialised, "Must be in initialised status");
    // Sanity check that refund balance is zero
    require(nodeRefundBalance == 0, "Refund balance not zero");
    // Check balance
    RocketDAOProtocolSettingsMinipoolInterface rocketDAOProtocolSettingsMinipool = RocketDAOProtocolSettingsMinipoolInterface(getContractAddress("rocketDAOProtocolSettingsMinipool"));
    uint256 launchAmount = rocketDAOProtocolSettingsMinipool.getLaunchBalance();
    require(_currentBalance >= launchAmount, "Balance is too low");
    // Store bond amount
    nodeDepositBalance = _bondAmount;
    // Calculate user amount from launch amount
    userDepositBalance = launchAmount.sub(nodeDepositBalance);
    // Flag as vacant
    vacant = true;
    preMigrationBalance = _currentBalance;
    // Refund the node whatever rewards they have accrued prior to becoming a RP validator
    nodeRefundBalance = _currentBalance.sub(launchAmount);
    // Set status to preLaunch
    setStatus(MinipoolStatus.Prelaunch);
}

import "../../interface/rewards/RocketSmoothingPoolInterface.sol";

import "../../interface/minipool/RocketMinipoolManagerInterface.sol";
import "../../interface/minipool/RocketMinipoolQueueInterface.sol";
import "../../interface/node/RocketNodeStakingInterface.sol";
import "../../interface/util/AddressSetStorageInterface.sol";
import "../../interface/node/RocketNodeManagerInterface.sol";
import "../../interface/network/RocketNetworkPricesInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsMinipoolInterface.sol";

import "../../types/MinipoolStatus.sol";
import "../../types/MinipoolDeposit.sol";
import "../../interface/dao/node/RocketDAONodeTrustedInterface.sol";

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

import "../../interface/network/RocketNetworkPricesInterface.sol";
import "../../interface/node/RocketNodeManagerInterface.sol";

import "../../interface/rewards/claims/RocketClaimNodeInterface.sol";

import "../../interface/rewards/RocketRewardsPoolInterface.sol";

import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsNodeInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsNodeInterface.sol";

/// @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");
    _;
}

// 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");
    _;
}

/// @dev Only allow access from the owning node address
modifier onlyMinipoolOwner(address _nodeAddress) {
    require(_nodeAddress == nodeAddress, "Invalid minipool owner");
    _;
}

/// @dev Only allow access from the owning node address or their withdrawal address
modifier onlyMinipoolOwnerOrWithdrawalAddress(address _nodeAddress) {
    require(_nodeAddress == nodeAddress || _nodeAddress == rocketStorage.getNodeWithdrawalAddress(nodeAddress), "Invalid minipool owner");
    _;
}

// Only allow access from the owning node address
modifier onlyMinipoolOwner(address _nodeAddress) {
    require(_nodeAddress == nodeAddress, "Invalid minipool owner");
    _;
}

// Only allow access from the owning node address or their withdrawal address
modifier onlyMinipoolOwnerOrWithdrawalAddress(address _nodeAddress) {
    require(_nodeAddress == nodeAddress || _nodeAddress == rocketStorage.getNodeWithdrawalAddress(nodeAddress), "Invalid minipool owner");
    _;
}

// The namespace for a particular group of settings
bytes32 settingNameSpace;

// Construct
constructor(RocketStorageInterface _rocketStorageAddress, string memory _settingNameSpace) RocketBase(_rocketStorageAddress) {
    // Apply the setting namespace
    settingNameSpace = keccak256(abi.encodePacked("dao.trustednodes.setting.", _settingNameSpace));
}

// The namespace for a particular group of settings
bytes32 settingNameSpace;

// Construct
constructor(RocketStorageInterface _rocketStorageAddress, string memory _settingNameSpace) RocketBase(_rocketStorageAddress) {
    // Apply the setting namespace
    settingNameSpace = keccak256(abi.encodePacked("dao.protocol.setting.", _settingNameSpace));
}

constructor(RocketStorageInterface _rocketStorageAddress) RocketDAOProtocolSettings(_rocketStorageAddress, "auction") {
    // Set version
    version = 1;

/// @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");
    _;
}

// Get a node's withdrawal address
function getNodeWithdrawalAddress(address _nodeAddress) public override view returns (address) {
    // If no withdrawal address has been set, return the nodes address
    address withdrawalAddress = withdrawalAddresses[_nodeAddress];
    if (withdrawalAddress == address(0)) {
        return _nodeAddress;
    }
    return withdrawalAddress;
}

function assignDeposits() override external onlyThisLatestContract {
    // Load contracts
    RocketDAOProtocolSettingsDepositInterface rocketDAOProtocolSettingsDeposit = RocketDAOProtocolSettingsDepositInterface(getContractAddress("rocketDAOProtocolSettingsDeposit"));
    // Revert if assigning is disabled
    require(_assignDeposits(rocketDAOProtocolSettingsDeposit), "Deposit assignments are currently disabled");
}

if (!_rocketDAOProtocolSettingsDeposit.getAssignDepositsEnabled()) {
    return false;
}

/// @dev Reverts if vacant minipools are not enabled
function checkVacantMinipoolsEnabled() private view {
    // Get contracts
    RocketDAOProtocolSettingsNodeInterface rocketDAOProtocolSettingsNode = RocketDAOProtocolSettingsNodeInterface(getContractAddress("rocketDAOProtocolSettingsNode"));
    // Check node settings
    require(rocketDAOProtocolSettingsNode.getVacantMinipoolsEnabled(), "Vacant minipools are currently disabled");
}

/// @dev Executes an assignDeposits call on the deposit pool
function assignDeposits() private {
    RocketDAOProtocolSettingsDepositInterface rocketDAOProtocolSettingsDeposit = RocketDAOProtocolSettingsDepositInterface(getContractAddress("rocketDAOProtocolSettingsDeposit"));
    if (rocketDAOProtocolSettingsDeposit.getAssignDepositsEnabled()) {
        RocketDepositPoolInterface rocketDepositPool = RocketDepositPoolInterface(getContractAddress("rocketDepositPool"));
        rocketDepositPool.assignDeposits();
    }
}

/// @dev Stakes the balance of this minipool into the deposit contract to set withdrawal credentials to this contract
/// @param _validatorSignature A signature over the deposit message object
/// @param _depositDataRoot The hash tree root of the deposit data object
function preStake(bytes calldata _validatorPubkey, bytes calldata _validatorSignature, bytes32 _depositDataRoot) internal {
    // Load contracts
    DepositInterface casperDeposit = DepositInterface(getContractAddress("casperDeposit"));
    RocketMinipoolManagerInterface rocketMinipoolManager = RocketMinipoolManagerInterface(getContractAddress("rocketMinipoolManager"));

/// @dev Distributes the current contract balance based on capital ratio and node fee
function distributeSkimmedRewards() internal {
    uint256 rewards = address(this).balance.sub(nodeRefundBalance);
    uint256 nodeShare = calculateNodeRewards(nodeDepositBalance, getUserDepositBalance(), rewards);

/// @dev Set the minipool's current status
/// @param _status The new status
function setStatus(MinipoolStatus _status) private {

/// @dev Adds a minipool to the queue
function enqueueMinipool(address _minipoolAddress) private {
    // Add minipool to queue
    RocketMinipoolQueueInterface(getContractAddress("rocketMinipoolQueue")).enqueueMinipool(_minipoolAddress);
}

/// @dev Reverts if node operator has not initialised their fee distributor
function checkDistributorInitialised() private view {
    // Check node has initialised their fee distributor
    RocketNodeManagerInterface rocketNodeManager = RocketNodeManagerInterface(getContractAddress("rocketNodeManager"));
    require(rocketNodeManager.getFeeDistributorInitialised(msg.sender), "Fee distributor not initialised");
}

/// @dev Creates a minipool and returns an instance of it
/// @param _salt The salt used to determine the minipools address
/// @param _expectedMinipoolAddress The expected minipool address. Reverts if not correct
function createMinipool(uint256 _salt, address _expectedMinipoolAddress) private returns (RocketMinipoolInterface) {

function setLotCount(uint256 _amount) private {
    setUint(keccak256("auction.lots.count"), _amount);
}