Intro to the Command Line Interface#

As a node operator, the CLI is your primary tool for interacting with Rocket Pool. You will use it to create new minipools, check on the status of everything, claim periodic RPL rewards, exit and withdraw from your minipools when you're ready, and a host of other activities.

Once you've finished syncing the Execution and Beacon chains, all of the commands will be available for you to use. In this section, we'll go over a brief tour of some of the more common ones and some other tricks that the CLI can do.

Learning About the Commands#

To list all of the available commands, type:

rocketpool help

The output will look like this:

Service Commands#

The service group involves managing the various services the smart node manages for you.

Here is what the rocketpool service help output will show:

status#

This command shows you the current running status of each of the Docker containers managed by Rocket Pool. For example, the default Docker install's output looks like this:

You can use it to quickly check if any of the Docker containers are having trouble, or to make sure that a start or stop command worked correctly.

start and stop#

These two commands you are already familiar with. They simply start all of the Rocket Pool containers, or stop them.

logs#

This command is another one you should have already seen. You can use it to look at the output logs of each Docker container. This can be useful for troubleshooting or getting a more detailed status report from them.

If you simply do rocketpool service logs without any other arguments, it will aggregate all of the logs together and show them to you at once.

If you want to focus on one container's output, you can add an argument to the end to specify the container. Valid values are eth1, eth2, validator, api, node, and watchtower.

stats#

This command shows you some resource stats from each of the containers, which you can use to profile each one's hardware and network consumption.

You might find it useful for monitoring the containers if your system starts running slow or has RAM problems.

Here is some example output:

config#

This command runs through the configuration interview again. You can use it if you want to change your selection of Execution or Consensus client, or change some of the parameters that you initially specified when you selected them (such as your validator's graffiti message, the max number of peers to connect to, and so on).

You can call this command at any time, but the changes won't take effect until you call rocketpool service stop and rocketpool service start.

terminate#

This command will shut down the Docker containers, then delete them, delete the Rocket Pool virtual network, and delete the ETH1 and ETH2 chain data volumes. It essentially removes all of the Rocket Pool items from your Docker setup. Use it when you want to clean up that portion of the Rocket Pool installation.

Node Commands#

The node group involves operations on your Rocket Pool node. We'll cover these more in-depth in the next section where we create a minipool, but it may be helpful to see them all at a glance.

Here is what the rocketpool node help output will show:

Below is a summary of some of the commands you'll tend to need during typical node operation.

status#

This command will give you a high-level view of your entire node at a glance. It includes how much ETH and RPL you have staked, how many minipools you have and their statuses, your RPL collateral ratio, and more.

This is an example of what rocketpool node status shows once you have your node registered and some minipools set up:

sync#

This command will show you the current sync status of your Execution and Consensus clients. You'll probably use it a lot when you first set the node up, then never need it again (unless you change or reset your clients).

The output of rocketpool node sync will look like this:

Note that Prysm currently doesn't provide its completion percent - you'll need to look in the eth2 logs if you use it.

stake-rpl#

This command is what you'll use when you want to add more RPL collateral to your node. Doing so will increase your collateral ratio, which will increase your RPL rewards at each checkpoint (more on this later). It may allow you to run more minipools or withdraw your rewards for the current checkpoint if your collateral is currently too low.

Unlike the other commands so far, this one is actually interactive because it will trigger a transaction - it isn't simply informational.

It will first ask you how much RPL you'd like to stake, with some pre-defined options for convenience or the ability to specify a custom amount:

Once you select an option, you will be shown some information about the suggested gas price and estimated amount to be used, along with a confirmation dialog:

If you confirm, you will be shown the transaction hash and given a link to Etherscan so you can follow its progress:

Most operations only require one transaction, so the CLI will wait until it has been mined and then exit. However, stake-rpl is one of the few commands that requires two transactions, so this dialog will appear twice.

deposit#

This command will let you deposit ETH and create a new minipool (a new Ethereum validator).

You will be prompted with the expected gas cost for the transaction and one final confirmation dialog. If you accept, your ETH deposit will be processed and you will create a new minipool (and a corresponding Ethereum validator).

(For more information, see the next section on Creating a Minipool).

claim-rewards#

When your node detects a new rewards checkpoint, it will automatically download the rewards tree file with the information for that interval (if you're using the default of Download Mode - see below for information on generating your own trees instead of downloading them). You can then review your rewards using the following command:

As intervals go by and you accumulate rewards, the output will look like this:

{ style="display: block; margin: 0 auto" }

Here you can quickly see how many rewards you've earned at each interval, and can decide which ones you want to claim.

You can also specify an amount you want to restake during this claim:

{ style="display: block; margin: 0 auto" }

This will let you compound your RPL rewards in one transaction, using substantially less gas than you currently needed to use with the legacy claim system.

join-smoothing-pool#

rocketpool node join-smoothing-pool

This will record you as opted-in in the Rocket Pool contracts and automatically change your Validator Client's fee recipient from your node's distributor contract to the Smoothing Pool contract.

Note that once you opt in, there is a 28 day cooldown (one full rewards interval length) until you can opt out.

leave-smoothing-pool#

rocketpool node leave-smoothing-pool

This will opt you out of the Smoothing Pool if you're currently opted in, and have waited at least 28 days after opting in. Once the next epoch after the current epoch is finalized, it will automatically change your node's fee recipient from the Smoothing Pool back to your node's distributor contract. This is to ensure you don't get penalized for front-running the exit process when you see that you have a proposal coming up.

initialize-fee-distributor#

To initialize your node's distributor, simply run this new command:

rocketpool node initialize-fee-distributor

distribute-fees#

When your distributor has been initialized, you can claim and distribute its entire balance using the following command:

rocketpool node distribute-fees

This will send your share of the rewards to your withdrawal address.

send#

This command lets you send ETH, RPL, or other Rocket Pool-related tokens from the node wallet to a different address. This might be useful if you want to move your funds on the wallet elsewhere.

The syntax for using the send command is like this:

rocketpool node send <amount> <token> <address or ENS name>

The arguments are as follows:

• <amount> is the amount of the token to send.
• <token> is the token to send - this can be eth, rpl, fsrpl (the old legacy RPL token), or reth.
• <address or ENS name> is the Ethereum address (or ENS name) to send the tokens to.

For example:

rocketpool node send 1 eth <my friend's address>

would send 1 ETH to my friend.

Minipool Commands#

The minipool group involves commands that affect your minipools. As with the node group, we'll cover these more in-depth in the next section but it may be helpful to see them all now.

Here is what the rocketpool minipool help output will show:

Below is a summary of the commands that you'll typically use.

status#

This command simply provides a summary of each of your minipools. This includes its current status, the eth1 address of the minipool, the commission on it (called the node fee), the public key of the corresponding ETH2 validator, and some other things:

refund#

This command lets you pull 16 ETH back from a minipool if you deposited 32 ETH to create one, once Rocket Pool was able to contribute 16 ETH from the rETH staking pool.

exit#

This command submits a voluntary exit for your validator on the Beacon Chain. Use this when you want to close a validator and withdraw its final ETH balance. Note that this cannot be undone - once you trigger an exit, the validator will shut down permanently.

Useful Flags#

There are some useful global flags that you can add to some of the above commands, which you may want to take advantage of.

Setting a Custom Max Fee or Priority Fee (Gas Price)#

Starting with the London ETH1 hardfork in July of 2021, Ethereum transactions no longer use a single gas price for their transactions. Instead, modern Ethereum transactions use two values:

• The max fee, which describes the absolute maximum gas price you're willing to accept on a transaction
• The max priority fee, which describes the maximum amount you're willing to "tip" the miner for including your transaction in a block

By default, Rocket Pool will use an oracle to look at the current transaction pool and suggest a reasonable max fee for any transactions you trigger. It uses EtherChain for its primary suggestion oracle, and Etherscan as a backup.

If you prefer, you can set a custom max fee (in gwei) you'd be willing to pay with the -f flag. You can also set a custom priority fee with the -i flag.

To do this, add them after rocketpool and before the other command information.

For example, calling node set-timezone with this flag would provide the following output:

This shows that regardless of what max fee the network recommends, it will use your custom max fee of 10 gwei (and priority fee if you specify it) instead when submitting this transaction.

Canceling / Overwriting a Stuck Transaction#

Sometimes, you might run into a scenario where you sent a transaction to the network but you used a gas price that is far too low for the network conditions, and it will take a prohibitively long time to execute. Since all of your subsequent transactions will wait until that one goes through, that transaction essentially blocks all of the operations on your Rocket Pool node. To deal with this situation, we've added a global flag that lets you "cancel" such a transaction by replacing it with something else.

Every Ethereum wallet, including your node wallet, sends transactions sequentially. Each transaction you send has a number called a nonce that identifies where it lives in that sequence. The very first transaction you send will have a nonce of 0, the next one you send will have a nonce of 1, and so on.

This overwriting technique involves sending a new transaction that uses the same nonce as your existing stuck transaction, but will ideally include a higher gas price than the stuck one. This means that the new one will be mined first. As soon as it's mined into a block, the old one will be discarded from the network as though it was never sent in the first place.

To use this flag, you first need to find the nonce of your stuck transaction:

1. Go to an ETH1 block explorer like https://etherscan.io.
2. Navigate to the address of your wallet, and look at the list of transactions.
3. Go through them, starting with the most recent, until you find the furthest one down the list that has the Pending state.
4. Mark the nonce of that transaction. That's what you'll need.

Once you have it, simply call any transaction with the CLI using the --nonce <value> -i 2.2 flags after rocketpool and before the rest of the command.

As an example, say I submitted a transaction with a nonce of 10 and a max fee of 20 gwei, but the current network fee is 100 gwei so my transaction is stuck. To fix it, I will submit a transaction where I send a small amount of ETH from myself back to myself with a higher max fee (say, 150 gwei) and a higher priority fee. I'll burn a little gas doing it, but it will unstick the broken transaction:

The Smartnode stack will automatically check to make sure that the nonce you have provided is valid (it refers to a pending transaction) before sending it and wasting your gas accidentally. If not, it will return an error message. Otherwise, it will go through and provide you with the transaction details so you can monitor it to confirm that it did, in fact, overwrite your old stuck transaction.

That's it for the common CLI commands. In the next section, we'll walk through how to create a minipool and start validating on the Beacon Chain.