rocketpool-node-operations

# Rocket Pool — Node Operations

## Quick Start

### Check Node Count
```bash
cast call 0xcf2d76A7499d3acB5A22ce83c027651e8d76e250 "getNodeCount()(uint256)" --rpc-url https://ethereum-rpc.publicnode.com
```

### Check If Address Is Registered Node
```bash
cast call 0xcf2d76A7499d3acB5A22ce83c027651e8d76e250 "getNodeExists(address)(bool)" $NODE_ADDR --rpc-url https://ethereum-rpc.publicnode.com
```

### Check Staked RPL
```bash
cast call 0xedFc7DCaE43fF954577a2875a9D805874490eE3E "getNodeStakedRPL(address)(uint256)" $NODE_ADDR --rpc-url https://ethereum-rpc.publicnode.com
```

## Workflow

1. Look up the contract address from `references/addresses.json`
2. Find the function signature below
3. Load the ABI from `assets/abis/<contractName>.json` when available (Megapool contracts in this skill are signature-only)
4. Execute via `cast call` (read) or `cast send` (write)

## Network Configuration

| Network | Chain ID | RPC | rocketStorage |
|---|---|---|---|
| Mainnet | 1 | `https://ethereum-rpc.publicnode.com` | `0x1d8f8f00cfa6758d7bE78336684788Fb0ee0Fa46` |
| Hoodi | 560048 | `https://rpc.hoodi.ethpandaops.io` | `0x594Fb75D3dc2DFa0150Ad03F99F97817747dd4E1` |

## Architecture

- **RocketStorage** is the central registry — all contracts resolve each other's addresses through it
- **Minipools** (legacy): one contract per validator, 8 or 16 ETH bond
- **Megapools** (Saturn/v1.4): one contract per node, multiple validators, variable bond
- Deploy megapool via `rocketNodeManager.deployMegapool()`, not the factory directly
- All ETH values are in wei (18 decimals); all percentages are 18-decimal fixed point (1e18 = 100%)

## rocketNodeManager

Node registration, withdrawal addresses, smoothing pool opt-in, megapool deployment, and express tickets.

### Functions

Registration:
```
registerNode(string _timezoneLocation)
getNodeExists(address _nodeAddress) → bool [view]
getNodeCount() → uint256 [view]
getNodeAt(uint256 _index) → address [view]
getNodeAddresses(uint256 _offset, uint256 _limit) → address[] [view]
getNodeRegistrationTime(address _nodeAddress) → uint256 [view]
getNodeTimezoneLocation(address _nodeAddress) → string [view]
```

Withdrawal addresses:
```
getNodeWithdrawalAddress(address _nodeAddress) → address [view]
getNodeRPLWithdrawalAddress(address _nodeAddress) → address [view]
getNodeRPLWithdrawalAddressIsSet(address _nodeAddress) → bool [view]
setRPLWithdrawalAddress(address _nodeAddress, address _newAddr, bool _confirm)
confirmRPLWithdrawalAddress(address _nodeAddress)
```
Primary withdrawal address is set on rocketStorage, not here.

Smoothing pool:
```
getSmoothingPoolRegistrationState(address _nodeAddress) → bool [view]
getSmoothingPoolRegistrationChanged(address _nodeAddress) → uint256 [view]
setSmoothingPoolRegistrationState(bool _state)
```

Megapool:
```
deployMegapool() → address
getMegapoolAddress(address _nodeAddress) → address [view]
```

Express tickets:
```
getExpressTicketCount(address _nodeAddress) → uint256 [view]
getExpressTicketsProvisioned(address _nodeAddress) → bool [view]
```

Fee distributor:
```
initialiseFeeDistributor()
getFeeDistributorInitialised(address _nodeAddress) → bool [view]
getAverageNodeFee(address _nodeAddress) → uint256 [view]
```

### Examples

```bash
cast call $NODE_MGR "getNodeCount()(uint256)" --rpc-url $RPC_URL
cast call $NODE_MGR "getNodeExists(address)(bool)" $NODE_ADDR --rpc-url $RPC_URL
cast call $NODE_MGR "getSmoothingPoolRegistrationState(address)(bool)" $NODE_ADDR --rpc-url $RPC_URL
cast call $NODE_MGR "getMegapoolAddress(address)(address)" $NODE_ADDR --rpc-url $RPC_URL
```

## rocketNodeDeposit

Handles ETH deposits from node operators to create validators.

### Functions

```
deposit(uint256 _bondAmount, bool _useExpressTicket, bytes _validatorPubkey, bytes _validatorSignature, bytes32 _depositDataRoot) [payable]
depositWithCredit(uint256 _bondAmount, bool _useExpressTicket, bytes _validatorPubkey, bytes _validatorSignature, bytes32 _depositDataRoot) [payable]
depositMulti(tuple[] _deposits) [payable]
depositEthFor(address _nodeAddress) [payable]
```

Credit queries:
```
getNodeDepositCredit(address _nodeAddress) → uint256 [view]
getNodeUsableCredit(address _nodeAddress) → uint256 [view]
getNodeEthBalance(address _nodeAddress) → uint256 [view]
getNodeCreditAndBalance(address _nodeAddress) → uint256 [view]
getBondRequirement(uint256 _numValidators) → uint256 [view]
withdrawEth(address _nodeAddress, uint256 _amount)
```

## rocketNodeStaking

RPL staking for node operators. Manages staked RPL, collateralization ratios, and locking.

### Functions

Staking:
```
stakeRPL(uint256 _amount)
stakeRPLFor(address _nodeAddress, uint256 _amount)
unstakeRPL(uint256 _amount)
unstakeRPLFor(address _nodeAddress, uint256 _amount)
withdrawRPL()
withdrawRPLFor(address _nodeAddress)
```

Legacy:
```
unstakeLegacyRPL(uint256 _amount)
unstakeLegacyRPLFor(address _nodeAddress, uint256 _amount)
```

Queries:
```
getNodeStakedRPL(address _nodeAddress) → uint256 [view]
getNodeLegacyStakedRPL(address _nodeAddress) → uint256 [view]
getNodeMegapoolStakedRPL(address _nodeAddress) → uint256 [view]
getNodeUnstakingRPL(address _nodeAddress) → uint256 [view]
getNodeLastUnstakeTime(address _nodeAddress) → uint256 [view]
getNodeETHBonded(address _nodeAddress) → uint256 [view]
getNodeETHBorrowed(address _nodeAddress) → uint256 [view]
getNodeETHCollateralisationRatio(address _nodeAddress) → uint256 [view]
getNodeMinipoolETHBonded(address _nodeAddress) → uint256 [view]
getNodeMinipoolETHBorrowed(address _nodeAddress) → uint256 [view]
getNodeMegapoolETHBonded(address _nodeAddress) → uint256 [view]
getNodeMegapoolETHBorrowed(address _nodeAddress) → uint256 [view]
getNodeMinimumLegacyRPLStake(address _nodeAddress) → uint256 [view]
getTotalStakedRPL() → uint256 [view]
getTotalLegacyStakedRPL() → uint256 [view]
getTotalMegapoolStakedRPL() → uint256 [view]
```

Locking (for governance proposals):
```
lockRPL(address _nodeAddress, uint256 _amount)
unlockRPL(address _nodeAddress, uint256 _amount)
getNodeLockedRPL(address _nodeAddress) → uint256 [view]
getRPLLockingAllowed(address _nodeAddress) → bool [view]
setRPLLockingAllowed(address _nodeAddress, bool _allowed)
```

### Examples

```bash
cast call $NODE_STAKING "getNodeStakedRPL(address)(uint256)" $NODE_ADDR --rpc-url $RPC_URL
cast call $NODE_STAKING "getNodeETHCollateralisationRatio(address)(uint256)" $NODE_ADDR --rpc-url $RPC_URL
cast call $NODE_STAKING "getTotalStakedRPL()(uint256)" --rpc-url $RPC_URL
```

## rocketMinipoolManager

Registry for all minipools (legacy 16 ETH and 8 ETH validators).

### Functions

```
getMinipoolCount() → uint256 [view]
getActiveMinipoolCount() → uint256 [view]
getStakingMinipoolCount() → uint256 [view]
getFinalisedMinipoolCount() → uint256 [view]
getMinipoolAt(uint256 _index) → address [view]
getMinipoolExists(address _minipoolAddress) → bool [view]
getMinipoolByPubkey(bytes _pubkey) → address [view]
getMinipoolPubkey(address _minipoolAddress) → bytes [view]
getNodeMinipoolCount(address _nodeAddress) → uint256 [view]
getNodeMinipoolAt(address _nodeAddress, uint256 _index) → address [view]
getNodeActiveMinipoolCount(address _nodeAddress) → uint256 [view]
getNodeStakingMinipoolCount(address _nodeAddress) → uint256 [view]
getNodeValidatingMinipoolCount(address _nodeAddress) → uint256 [view]
```

### Examples

```bash
cast call $MINIPOOL_MGR "getMinipoolCount()(uint256)" --rpc-url $RPC_URL
cast call $MINIPOOL_MGR "getNodeMinipoolCount(address)(uint256)" $NODE_ADDR --rpc-url $RPC_URL
```

## rocketMinipoolDelegate

Logic contract for individual minipool instances. Each minipool is a proxy that delegates to this.

### Functions

Status:
```
getStatus() → uint8 [view]
getStatusTime() → uint256 [view]
getNodeAddress() → address [view]
getNodeFee() → uint256 [view]
getFinalised() → bool [view]
getDepositType() → uint8 [view]
```

Balances:
```
getNodeDepositBalance() → uint256 [view]
getNodeRefundBalance() → uint256 [view]
getUserDepositBalance() → uint256 [view]
getUserDepositAssigned() → bool [view]
calculateNodeShare(uint256 _balance) → uint256 [view]
calculateUserShare(uint256 _balance) → uint256 [view]
```

Lifecycle:
```
stake(bytes _validatorSignature, bytes32 _depositDataRoot)
distributeBalance(bool _rewardsOnly)
finalise()
dissolve()
close()
refund()
```

Minipool statuses: 0=Initialised, 1=Prelaunch, 2=Staking, 3=Withdrawable, 4=Dissolved

## rocketMinipoolFactory

Creates minipool proxy contracts. Called internally by the deposit flow.

## rocketMinipoolBase

Base proxy contract for individual minipool instances. Delegates calls to rocketMinipoolDelegate.

## rocketMinipoolQueue

Manages the queue of minipools waiting for ETH assignment from the deposit pool.

## rocketMinipoolPenalty

Tracks penalty counts for individual minipools (MEV theft, missed duties).

## rocketNodeDistributorFactory

Creates fee distributor contracts for node operators.

## rocketNodeDistributorDelegate

Logic contract for node fee distributors. Handles ETH distribution between the node and the protocol.

## rocketMinipoolBondReducer

Allows node operators to reduce minipool bond from 16 ETH to 8 ETH (or 8 to 4 ETH with LEB4).

### Functions

```
beginReduceBondAmount(address _minipoolAddress, uint256 _newBondAmount)
canReduceBondAmount(address _minipoolAddress) → bool [view]
getReduceBondTime(address _minipoolAddress) → uint256 [view]
getReduceBondValue(address _minipoolAddress) → uint256 [view]
```

## Megapool Contracts (Saturn)

Megapools replace minipools as the new validator structure. A single megapool contract per node can manage multiple validators.
No ABI files are bundled for `rocketMegapoolFactory`, `rocketMegapoolDelegate`, `rocketMegapoolManager`, `rocketMegapoolPenalties`, or `rocketMegapoolProxy` in this skill. Use the raw signatures below with `cast`.

### rocketMegapoolFactory

```
deployContract(address _nodeAddress) → address
getExpectedAddress(address _nodeAddress) → address [view]
getMegapoolDeployed(address _nodeAddress) → bool [view]
```

### rocketMegapoolDelegate (per-megapool logic)

```
newValidator(uint256 _bondAmount, bool _useExpressTicket, bytes _validatorPubkey, bytes _validatorSignature, bytes32 _depositDataRoot)
stake(uint32 _validatorId)
distribute()
claim()
```

Queries:
```
getNodeAddress() → address [view]
getNodeBond() → uint256 [view]
getAssignedValue() → uint256 [view]
getUserCapital() → uint256 [view]
getValidatorCount() → uint32 [view]
getActiveValidatorCount() → uint32 [view]
getExitingValidatorCount() → uint32 [view]
getValidatorInfo(uint32 _validatorId) → ValidatorInfo [view]
getValidatorPubkey(uint32 _validatorId) → bytes [view]
getPendingRewards() → uint256 [view]
getDebt() → uint256 [view]
getRefundValue() → uint256 [view]
calculateRewards(uint256 _amount) → (nodeRewards, voterRewards, protocolDAORewards, rethRewards) [view]
getNewValidatorBondRequirement() → uint256 [view]
```

### rocketMegapoolManager (global megapool operations)

```
getValidatorCount() → uint256 [view]
getValidatorInfo(uint256 _index) → (bytes pubkey, ValidatorInfo, address megapool, uint32 validatorId) [view]
```

### rocketMegapoolPenalties

```
penalise(address _megapool, uint256 _block, uint256 _amount)
executePenalty(address _megapool, uint256 _block, uint256 _amount)
getCurrentMaxPenalty() → uint256 [view]
```

### rocketMegapoolProxy

Base proxy contract for megapool instances. Delegates calls to rocketMegapoolDelegate.

### Gotchas

- Deploy megapool via `rocketNodeManager.deployMegapool()`, not the factory directly
- Each node has exactly one megapool address, but can have multiple validators within it
- Bond reduction has a waiting period and can be cancelled by the oDAO