#How to Become a Cardano Stake Pool Operator

Before setting up a Cardano stake pool, you’ll have to set up a Cardano node. For this, you can follow our previous guide on how to run a Cardano node.

This guide explains the process of setting up a Cardano stake pool and how to become a Cardano stake pool operator. We’ll configure and set up the Cardano stake pool, and explain the importance of Cardano stake pools to the overall Cardano network. We will also highlight the architecture and roles of the block producer and relay nodes, and how these components come together in your setup.

First of all, it’s crucial to understand the theory and architecture behind Cardano stake pools to properly configure them before setting them up.

#What is a Cardano Stake Pool?

A Cardano stake pool is a specialized node that facilitates participation in the network’s proof-of-stake consensus mechanism. When ADA holders delegate their stake to a pool, they are collectively increasing the chances of the pool being selected to produce blocks.

The pool operator, also known as the Stake Pool Operator (SPO), is responsible for maintaining the infrastructure, running the block-producing node, and ensuring it stays online and functional.

#Roles in the Stake Pool Ecosystem: Operator vs. Owner

In a stake pool, there are two main roles that are pivotal in its operation:

• Stake Pool Operator (SPO): The SPO is responsible for configuring, managing, and maintaining the stake pool infrastructure. They ensure the pool's block producer is running properly, handling the pool's security, node registration, and block production. The SPO also monitors the network, handles certificates, and updates the pool’s information when necessary. Importantly, the SPO is the person who holds the keys necessary for pool operations, including the cold keys and VRF keys.

• Stake Pool Owner(s): The owner(s) are responsible for the pledge stake that is tied to the pool. The owners’ pledge ensures the pool’s commitment to the network. Although the SPO typically also serves as the owner, some pools have multiple owners who combine their resources. The pledge helps secure the pool and makes it eligible for block production. The owners are also responsible for managing the reward distribution among themselves and the SPO.

Together, the SPO and owners ensure that the pool remains operational, secure, and profitable for its delegators.

#The Logical Topology of a Cardano Stake Pool

The logical topology of a stake pool involves both block producer nodes and relay nodes. Let’s break down the components of this topology and why it’s important for your pool’s success.

#Block Producer Node:

• The block producer node is responsible for producing blocks and validating transactions within the Cardano network. It is the core node of the stake pool, directly participating in the consensus process.

• Security Consideration: To ensure security, the block producer node should only connect to trusted relay nodes. This ensures the block producer is isolated from potential vulnerabilities that might arise from direct connections to the broader Cardano network.

• Recommended Configuration: The block producer node should be placed in an environment that’s as secure as possible, and its connection should be limited to trusted relay nodes. Using Cherry Servers for hosting provides robust security and performance, offering customizable solutions for blockchain nodes.

#Relay Nodes:

• Relay nodes act as intermediaries between the block producer node and the Cardano network. These nodes propagate blocks and transactions to other parts of the network, ensuring fast and efficient block propagation.

• Geographic Distribution: To minimize network latency and improve block propagation time, it’s recommended to have multiple relay nodes in different geographical locations.

• Security Consideration: The relay nodes must be configured to only allow connections from the block producer node, and vice versa. This creates a secure, isolated communication layer between your pool’s core infrastructure and the rest of the network.

#How Much Cardano to Start a Stake Pool?

To start a stake pool on the Cardano network, you'll need a minimum of 500 ADA as a pledge. However, for better competitiveness and to attract delegators, it's recommended to have a pledge of 1,000 ADA or more. While 500 ADA is the minimum, a larger pledge is advisable for better performance.

#How Much do Cardano Stake Pool Operators Make?

How much you can make running a Cardano stake pool depends on several factors and can change. For more information and to get a rough idea of your earning potential, you can check their official guidance and use Cardano staking reward calculator.

#Setting up a Cardano Stake Pool: Step-by-Step

Let’s get straight into it. First of all, ensure you’ve successfully set up your Cardano node. Then, follow the below step-by-step instructions to set up your Cardano stake pool.

In this tutorial, we’ve used Cherry Servers dedicated Web3 servers, as it offers the perfect platform for hosting your node and stake pool, with powerful dedicated servers designed specifically for blockchain workloads.

#Step 1: Set Up Folder Structure for Nodes

Once you have your Cardano node installed and your server properly configured, the next step is to set up the relay node. The relay node acts as an intermediary between your block producer node and the rest of the Cardano network. Let's walk through configuring your Cardano relay node.

To keep everything organized, let's create a folder structure for your Cardano node. This structure will store all the configuration files, database, logs, and keys. Start by creating a directory for the node setup:

cd
mkdir -p cnode
cd cnode
mkdir -p config db sockets keys logs scripts
cd config

This creates a directory named cnode, and subdirectories for configuration files, database, sockets, keys, logs, and scripts.

#1. Download Configuration Files

Now that we have our folder structure set up, it's time to download the latest configuration and genesis files. These files are essential for initializing the relay node. Run the following commands:

wget -q -O config.json https://book.world.dev.cardano.org/environments/preprod/config.json
wget -q -O alonzo-genesis.json https://book.world.dev.cardano.org/environments/preprod/alonzo-genesis.json
wget -q -O byron-genesis.json https://book.world.dev.cardano.org/environments/preprod/byron-genesis.json
wget -q -O shelley-genesis.json https://book.world.dev.cardano.org/environments/preprod/shelley-genesis.json
wget -q -O topology.json https://book.world.dev.cardano.org/environments/preprod/topology.json
wget -q -O conway-genesis.json https://book.world.dev.cardano.org/environments/preprod/conway-genesis.json

List the downloaded files to ensure they are saved correctly:

ls -al

You should now see the following six files in the config folder:

• config.json
• alonzo-genesis.json
• byron-genesis.json
• shelley-genesis.json
• topology.json
• conway-genesis.json

These files will help configure the Cardano node to run on the Testnet.

#2. Run the Cardano Node on Port 3000

Now that the configuration files are in place, you are ready to start your Cardano node. This command will run the core node on port 3000:

Start the core node:

cardano-node run \
  --database-path /home/cardano/cnode/db \
  --socket-path /home/cardano/cnode/sockets/node.socket \
  --port 3000 \
  --config /home/cardano/cnode/config/config.json \
  --topology /home/cardano/cnode/config/topology.json

• --database-path: Specifies the location of the node's database.
• --socket-path: Defines the path for the node's socket file.
• --port 3000: Runs the node on port 3000.
• --config: Points to the config.json file.
• --topology: Defines the topology.json file for node network configuration.

If everything is set up correctly, the node will begin syncing. You will see logs that indicate the node is starting and connecting to peers.

Once the node starts syncing, you can stop it at any time by pressing Ctrl+C. This indicates that the node is functioning properly and is connected to the Testnet.

Now that you have successfully run your core node on port 3000, you're well on your way to setting up the full Cardano stake pool.

#Step 2: Downloading the Cardano Blockchain Snapshot

Synchronizing the Cardano blockchain from scratch can be a lengthy process. Depending on your CPU and network connection, it could take several days to fully sync. To save time, we will use the cSnapshots.io service to download a pre-built snapshot of the blockchain, which significantly speeds up the synchronization process.

Before downloading the blockchain snapshot, you need to install some necessary tools to handle the compressed archive:

sudo apt update && sudo apt install liblz4-tool jq curl -y

These packages are required to manage the LZ4 compression and parse JSON files, ensuring a smooth download and extraction process.

#1. Clean Up Old Blockchain Files

If you have previously tried to sync the blockchain or if there are residual files, it’s a good idea to remove any old database files before starting the fresh download.

rm -rf /home/cardano/cnode/db

This command removes the old database files from the db directory under the cnode folder.

#2. Download the Latest Blockchain Snapshot

Now we can download the latest blockchain snapshot. Depending on whether you're working with the mainnet or the testnet, use one of the following methods.

#Download Testnet Snapshot

For the Testnet (Pre-production network), use this command:

curl -o - https://downloads.csnapshots.io/snapshots/testnet/$(curl -s https://downloads.csnapshots.io/snapshots/testnet/testnet-db-snapshot.json| jq -r .[].file_name ) | lz4 -c -d - | tar -x -C /home/cardano/cnode/

This command works in the same way as the mainnet command but pulls from the testnet snapshots instead.

#Download Mainnet Snapshot(we’re using testnet for the tutorial)

To download the Mainnet blockchain snapshot:

wget -c -O - "https://downloads.csnapshots.io/mainnet/$(wget -qO- https://downloads.csnapshots.io/mainnet/mainnet-db-snapshot.json | jq -r .[].file_name)" | lz4 -c -d - | tar -x -C /home/cardano/cnode/

Explanation of the command:

• wget -qO-: Downloads the mainnet-db-snapshot.json file containing the latest snapshot filename.
• jq -r .[].file_name: Extracts the filename of the snapshot from the JSON response.
• lz4 -c -d -: Decompresses the downloaded snapshot using LZ4 compression.
• tar -x -C: Extracts the snapshot to the /home/cardano/cnode/ directory.

This will download and extract the mainnet snapshot in one go, without storing the archive itself, saving space.

#3. Wait for the Download and Extraction

Depending on your internet speed, this process may take some time.

• Mainnet snapshot is typically >100GB, so it may take a few hours to download and extract.
• Testnet snapshot is smaller, usually <10GB, and should take significantly less time.

Once the download is complete, you can proceed with running the node as it now has a fully synced blockchain database.

With the Cardano blockchain snapshot downloaded and extracted, your node should now have the necessary data to sync quickly and start participating in the Cardano network. This snapshot method saves you from waiting days for the initial sync and enables you to begin testing and operating your stake pool more efficiently.

#Step 3: Installing the StakePool Operator Scripts (SPOS)

As managing a Cardano node becomes more complex, it's highly recommended to use the StakePool Operator Scripts (SPOS), also known as Martin's Scripts (developed by the ATADA Stake Pool owner). These scripts simplify the management of Cardano stake pools and help automate many tasks, such as managing keys, certificates, and wallet operations.

Important Security Note: The keys for your pledge wallet and stake pool are critical, as anyone with access to these keys will have full control over your wallets and stake pool. To ensure security, never store these keys on an online server. SPOS scripts allow you to generate all keys and certificates on a secure, offline (air-gapped) PC or using Hardware Wallets, ensuring greater security.

Before you begin downloading and using the SPOS scripts, make sure that you have the required packages installed.

sudo apt update -y
sudo apt install -y curl bc jq

These dependencies include tools like curl for downloading files, bc for basic calculations, and jq for parsing JSON.

#Step 4: Download SPOS Scripts

Now let's download the SPOS scripts from GitHub, which will help you configure and manage your stake pool.

cd
mkdir -p git
cd git

Remove any existing folder if it already exists:

 rm -rf scripts

Clone the repository from GitHub:

git clone https://github.com/gitmachtl/scripts

Navigate to the scripts directory:

cd scripts

Check the contents of the directory:

ls -al

At this point, you should see the SPOS scripts listed in your directory.

#Step 5: Copy the Scripts to the Local Bin

To make it easier to run the scripts, we’ll copy them to the ~/.local/bin/ directory, so you can call them from anywhere on your system.

For Testnet:

cp cardano/testnet/* ~/.local/bin/

For Mainnet:

cp cardano/mainnet/* ~/.local/bin/

Navigate to the local bin directory:

cd ~/.local/bin/

This makes the SPOS scripts accessible from anywhere on your system.

#Step 6: Configuration of SPOS Scripts

Next, you need to configure the scripts so that they know where to find the necessary files (such as the genesis files, Cardano CLI, and node socket). You will create a configuration file in your home directory.

cat &lt;<EOF > ~/.common.inc
socket="/home/cardano/cnode/sockets/node.socket"
genesisfile="/home/cardano/cnode/config/testnet-shelley-genesis.json"  #Shelley-Genesis path
genesisfile_byron="/home/cardano/cnode/config/testnet-byron-genesis.json"  #Byron-Genesis path
cardanocli="cardano-cli"  #Path to your cardano-cli
cardanonode="cardano-node"  #Path to your cardano-node
magicparam="--testnet-magic 1097911063"  # Use "--mainnet" for mainnet or "--testnet-magic 1097911063" for testnet
addrformat="--testnet-magic 1097911063"  # Use "--mainnet" for mainnet address format or "--testnet-magic 1097911063" for testnet address format
itn_jcli="./jcli"  # Only needed if you want to include your ITN witness for your pool-ticker
# Leave this value until you have to change it for a testnet
byronToShelleyEpochs=74  # 208 for the mainnet, 74 for the testnet
EOF

This configuration file sets the paths for various files such as:

• genesisfile: Points to the Shelley genesis file (for testnet or mainnet).
• socket: Specifies the socket file for the node.
• magicparam and addrformat: Define whether you're using testnet or mainnet.

Check that the configuration file is set up correctly by running:

cat ~/.common.inc

The output should display the correct paths for the Cardano node, Cardano CLI, and relevant configuration settings.

#Step 7: Testing the Setup

After completing the setup, you can verify that the scripts are working correctly. Try running a basic script command:

00_common.sh

By following these steps, you have successfully installed the StakePool Operator Scripts (SPOS) on your system. These scripts will help you manage the Cardano node, generate keys for your stake pool, and simplify the configuration process.

#Step 8: Generating Wallet Keys

In this section, we will generate the wallet keys necessary for your pledge wallet, which will be used to pay transaction fees and pool deposit. We will also check the balance of this wallet and register the staking address on the blockchain.

First, navigate to the keys directory where we will store the wallet and staking keys:

cd ~/cnode/keys/

We will create a wallet that will handle the fees and pool deposit. Let’s name this wallet myWallet.

02_genPaymentAddrOnly.sh myWallet cli

List the generated files to confirm the wallet has been created:

ls -al

You should see files similar to the following:

• myWallet.skey (Signing key)
• myWallet.vkey (Verification key)

Next, let’s check the balance of the wallet and retrieve its address.

01_queryAddress.sh myWallet

You should see an address similar to: addr_test1vrl0cagj24t20dcsmljh5n2egg5pehpfmy6wtsul6resl0gpzsp7d

1. Important Note: Do not send any funds to this address yet. You will need 505 ADA for the next steps:

   • 500 ADA for the pool deposit (this will be refunded when you de-register the pool).
   • Additional ADA for transaction fees and delegation key deposit.

2. Send the required ADA to the wallet address. Once the funds have been sent, use the query address script again to verify the funds are received.

#Create an Address for Storing the Pool’s Pledge

Now that we have our payment wallet set up, we will generate an address to store the pledge for your pool. This address will be used to stake the pledge for your pool.

 03a_genStakingPaymentAddr.sh poolOwner cli

List the generated files for the pledge wallet:

ls -al poolOwner*

This will show the staking wallet files for the poolOwner. With the staking address created, the next step is to register the staking key on the blockchain. This ensures that the poolOwner's stake key is properly registered for your pool.

 03b_regStakingAddrCert.sh poolOwner myWallet

This command uses myWallet to pay for the transaction and the staking deposit. After registering the staking address, you can verify that it has been properly registered on the blockchain.

03c_checkStakingAddrOnChain.sh poolOwner

This will confirm if your staking address is correctly registered on the Cardano blockchain. At this point, you have successfully created and funded your payment wallet (for fees and pool deposit) and your staking wallet (for pledging). You have also registered the staking address on the blockchain, preparing for the next steps in setting up your Cardano stake pool.

#Step 9: Generating Cardano Block Producer Keys

In this section, we will generate the block producer keys required for your Cardano stake pool. These keys include the node keys, VRF keys, KES keys, and operation certificates. The StakePool Operator Scripts (SPOS) make this process very straightforward.

#1. Generate Pool Keys

We will use the SPOS scripts to generate the following keys for your Cardano block producer:

04a_genNodeKeys.sh myPool cli

Generate VRF (Verifiable Random Function) Keys:

04b_genVRFKeys.sh myPool cli

Generate KES (Key Evolving Signature) Keys:

04c_genKESKeys.sh myPool cli

Generate Node Operational Certificate:

04d_genNodeOpCert.sh myPool

After running the commands above, check the generated files:

ls -al myPool*

This will display the files associated with the generated pool keys, such as myPool.node.skey, myPool.vrf.skey, myPool.kes.skey, and myPool.opcert. You have now successfully generated the required pool keys for your Cardano block producer node. With the block producer keys ready, the next step is to create a stake pool certificate, which is necessary to register your pool on the blockchain.

05a_genStakepoolCert.sh myPool

This command will generate a template that you will need to fill out with specific information about your pool. This includes pool pledge, fees, margin, and more. Open the template file to configure your pool's settings. Use the nano text editor:

nano myPool.pool.json

Below is an example configuration for a single-owner pool with the following details:

• Pool Pledge: 1 million ADA (held in the poolOwner address)
• Fixed Fee: 340 ADA (minimum fixed fee)
• Pool Margin: 5%
• Relay IPs: 89.191.111.111 and 89.191.111.112 on port 3001
• Pool Ticker: XPOOL
• Short Description: "My Testnet Pool #2"
• Long Description: "This pool is used for the guide I created"
• Metadata URL: The URL for the main metadata file: https://www.stakepool247.eu/xpool-testnet.metadata.json
• Extended Metadata URL: The URL for the extended metadata file: https://www.stakepool247.eu/xpool-testnet.extended.json

After editing, save and close the file.

#2. Regenerate the StakePool Certificate

Once you’ve edited the configuration file, you can regenerate the stake pool certificate:

05a_genStakepoolCert.sh myPool

This will create a valid pool certificate based on the information you provided.

#3. Upload Metadata Files to Your Web Server

The metadata files (both the main and extended) must be uploaded to a web server so they are accessible to Daedalus and other wallets.

Rename the Metadata Files to match the configuration:

cp myPool.metadata.json xpool-testnet.metadata.json
cp myPool.extended-metadata.json xpool-testnet.extended.json

Upload these files to a web server (via FTP/SFTP or any other method). Ensure they are accessible at the URLs specified in your configuration.

#4. Create the Delegation Certificate

Now that the stake pool certificate is generated, you need to create a delegation certificate to delegate ADA to your own pool.

05b_genDelegationCert.sh myPool poolOwner

This will create the delegation certificate for the poolOwner.

Send the pledged amount (in this case, 1 million ADA) to the poolOwner’s payment address. You can find the address by running:

cat poolOwner.payment.addr

After sending the funds, verify that the ADA has been received by checking the wallet balance:

01_queryAddress.sh poolOwner.payment

#5. Register the Stake Pool on the Blockchain

The final step is to register the stake pool on the blockchain. This action will make your pool visible to the Daedalus wallet and other tools like adapools and pooltool.

 05c_regStakepoolCert.sh myPool myWallet

This command registers the stake pool certificate and delegation certificate on the Cardano blockchain. The fees for this registration will be paid using the myWallet.

You’ve successfully generated the necessary keys for your Cardano block producer node and created your stake pool certificate. Additionally, you’ve uploaded the required metadata files to your web server and completed the delegation certificate process.

Now, your stake pool is registered on the Cardano blockchain and should be visible on Daedalus and other wallet applications. You’re now ready to continue managing and operating your Cardano stake pool.

#Step 10: Launching Your Cardano Block Producer Node

With all the keys and certificates generated, it's time to launch your Cardano Block Producer (BP) node. There are two primary methods for launching the node: using a script or as a systemd service. While launching as a script can be useful for testnet or non-production environments, it is recommended to launch the node as a systemd service for production environments to ensure it runs continuously in the background.

First, we need to copy the generated keys from your local machine to the Block Producer (BP) server. These keys are essential for the node to run correctly.

Copy the keys:

• myPool.kes-000.skey
• myPool.vrf.skey
• myPool.node-000.opcert

Place these files under the directory: /home/$USER/cnode/keys/ on your BP server.

Rename the keys to match the default names used in the launch script, which will simplify the configuration process.

cd ~/cnode/keys
mv myPool.kes-000.skey myPool.kes.skey
mv myPool.node-000.opcert myPool.node.opcert

Set read-only access to the keys and restrict any access for other users to ensure security:

chmod 400 *

#Launching Your Node

Now, let's discuss the two ways you can launch your node: using a script or as a systemd service.

#Launching Using a Script (For Testnet or Non-Production Use)

If you're testing or using a non-production server, you can launch the Cardano BP node using a script. Here's how to do it:

cd ~/cnode/scripts

Open the script file in a text editor:

nano node.sh

Inside the node.sh file, add the following code:

 #!/bin/bash
cardano-node run \
 --database-path ~/cnode/db/ \
 --socket-path ~/cnode/sockets/node.socket \
 --host-addr 0.0.0.0 \
 --port 3000 \
 --config ~/cnode/config/mainnet-config.json \
 --topology ~/cnode/config/mainnet-topology.json \
 --shelley-kes-key ~/cnode/keys/myPool.kes.skey \
 --shelley-vrf-key ~/cnode/keys/myPool.vrf.skey \
 --shelley-operational-certificate ~/cnode/keys/myPool.node.opcert

This script will run your Cardano BP node, connecting to the appropriate configuration files and using the generated keys for KES, VRF, and operational certificates. Save and exit the editor by pressing CTRL + X, then Y to confirm.

To start the node, simply run:

 ./start_all.sh

This will launch your Cardano BP node in the current terminal session.

#Launching as a Systemd Service (Recommended for Production)

For production environments, it is highly recommended to run your Cardano BP node as a systemd service. This will allow your node to run as a background service, restart automatically if it fails, and start on boot. Run the following command to create the service file:

cat &lt;<EOF | sudo tee /etc/systemd/system/cardano-node.service
[Unit]
Description=Cardano Pool
After=multi-user.target
[Service]
Type=simple
ExecStart=/home/cardano/.local/bin/cardano-node run \
  --config /home/cardano/cnode/config/config.json \
  --topology /home/cardano/cnode/config/topology.json \
  --database-path /home/cardano/cnode/db/ \
  --socket-path /home/cardano/cnode/sockets/node.socket \
  --host-addr 0.0.0.0 \
  --port 3001 \
  --shelley-kes-key /home/cardano/cnode/keys/myPool.kes.skey \
  --shelley-vrf-key /home/cardano/cnode/keys/myPool.vrf.skey \
  --shelley-operational-certificate /home/cardano/cnode/keys/myPool.node.opcert
KillSignal=SIGINT
RestartKillSignal=SIGINT
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=cardano
LimitNOFILE=32768
Restart=on-failure
RestartSec=45s
WorkingDirectory=~
User=cardano
Group=cardano
[Install]
WantedBy=multi-user.target
EOF

This configuration ensures that your Cardano node runs continuously in the background and restarts automatically if it encounters any issues. Run the following commands to enable and start the Cardano node service:

sudo systemctl enable cardano-node.service
sudo systemctl start cardano-node.service

This will start the node as a system service that will run in the background. If the service is already installed, you just need to reload the configuration and restart the node:

sudo systemctl daemon-reload
sudo systemctl restart cardano-node.service

To view the Cardano node’s logs, use the following command:

journalctl -u cardano-node.service -f -o cat

This will display the logs in real-time and allow you to check the status of your node.** **At this point, you’ve successfully launched your Cardano Block Producer node. You’ve:

• Transferred and renamed the necessary keys for your node.

• Configured the systemd service to ensure your node runs continuously and automatically restarts.

• Tested the launch process using a script for non-production or testnet use.

Your Cardano node is now ready to produce blocks, delegate ADA, and participate in the Cardano network.

#Conclusion

Running a Cardano stake pool is an excellent way to contribute to the network’s security and decentralization while earning rewards. By following the steps outlined in this guide, you can easily set up and run your own stake pool. Whether you're looking to run a solo pool or collaborate with others, Cherry Servers offers tailored, high-performance Web3 dedicated servers that can ensure your stake pool remains reliable and secure.

If you're ready to set up your Cardano stake pool, Cherry Servers provides the infrastructure you need, including 24/7 support, customizable servers, and optimized hosting for blockchain nodes. With their robust and scalable solutions, you can be sure that your stake pool will be well-equipped for success in the Cardano ecosystem.