Staking Pool Installation

Install and activate a staking pool with helper scripts: register, activate, set min effective balance, and optional stake.

This guide walks validator operators through installing and activating a staking pool using the helper scripts.

What you’ll use

The helper scripts are available through GitHub:

git clone https://github.com/berachain/guides/
cd guides/apps/staking-pools
ls -F
# frontend/   install-helpers/

There are many useful scripts under install-helpers/ which wrap multi-step operations into safe, review-first commands:

• register.sh: Deploys (registers) staking pool contracts and generates the deployment transaction
• activate.sh: Activates a deployed pool using validator proofs from the beacon chain
• status.sh: Verifies deployment, registration, and activation status
• stake.sh: Generates a staking transaction to add BERA to your pool

All scripts write ready-to-run cast commands to files for you to review and execute. They do not send transactions without your confirmation. By default, scripts use Ledger for signing; set PRIVATE_KEY in env.sh if you prefer a local key.

Requirements

• beacond (validator client) running and synced with your validator keys backed up somewhere safe
• Foundry cast (getfoundry.sh)
• jq, bc, curl
• Ledger hardware wallet (default) or a private key set via PRIVATE_KEY
• Funds: at least 10,000 BERA for the initial deposit; additional stake as desired

1. Configure environment

In install-helpers/:

cp env.sh.template env.sh
# Edit env.sh and set at minimum:
#   BEACOND_HOME="/path/to/your/beacond/home"
#   NODE_API_ADDRESS="127.0.0.1:3500"  # If not auto-detected from app.toml
# Optionally set:
#   PRIVATE_KEY="0x..."            # Defaults to Ledger if unset

Ensure the beacon node API is enabled in your app.toml ([beacon-kit.node-api]) or provide NODE_API_ADDRESS in env.sh. The scripts will auto-detect when possible and verify connectivity before proceeding.

2. Register (deploy contracts)

Run register.sh with your addresses to deploy the staking pool contracts:

./register.sh --sr 0xSHARES_RECIPIENT --op 0xOPERATOR

1. The chain (mainnet or Bepolia) is auto-detected from your beacond configuration.
2. The initial stake is 10,000 BERA (fixed by the consensus layer). The script writes deployment-command.sh with this deposit. Review it. Simulate it if you want. Then run it. This should dump a successful transaction receipt.
3. The script also predicts and shows your staking pool contract addresses ahead of time.

3. Wait for validator registration

After deploying the contracts, wait for your validator to be registered on the beacon chain. You can check registration status with:

./status.sh

The validator must appear on the beacon chain before you can activate the pool.

4. Activate the pool

Once your validator is registered, run activate.sh to activate the pool:

./activate.sh

Activation is a permissionless on-chain call keyed by your validator pubkey, so activate.sh no longer takes --sr or --op; the pool’s shares recipient and operator are already baked in from register.sh. The script:

1. Verifies the pool contract is deployed and not already active (isActive()).
2. Confirms BeaconDeposit.getOperator(pubkey) matches the pool’s SmartOperator and that the validator’s withdrawal credentials point at the pool’s WithdrawalVault.
3. Pins the beacon-chain head slot, fetches validator pubkey, withdrawal-credentials, and balance proofs at that single slot, and preflights activateStakingPool() locally so a bad proof or stale timestamp surfaces before you broadcast.
4. Writes generated/activation-command.sh for you to review and execute.

Proofs include a timestamp enforced by the contract (MAX_TIMESTAMP_AGE = 10 minutes). The generated script also hard-expires after that window; if you hit it, re-run activate.sh to regenerate.

5. Verify installation

Use status.sh to check deployment, registration, and activation:

./status.sh

You should see the SmartOperator, StakingPool, StakingRewardsVault, and IncentiveCollector addresses, confirmation that the beacon deposit operator matches your SmartOperator, the pool’s active status, and various telemetry.

6. Set minimum effective balance

The minEffectiveBalance parameter determines when your staking pool activates its validator on the consensus layer. If you don’t set this value correctly, your pool may accumulate deposits without ever activating.

Set the value using your SmartOperator contract:

cast send $SMART_OPERATOR_ADDRESS \
  "setMinEffectiveBalance(uint256)" $CALCULATED_MIN_STAKE \
  --ledger  # or --private-key $PRIVATE_KEY

Replace $SMART_OPERATOR_ADDRESS with your SmartOperator address and $CALCULATED_MIN_STAKE with the calculated minimum stake amount in wei (multiply BERA amount by 10^18).

For details on why this matters, how to determine the correct value, and how the consensus layer minimum works, see the Setting Minimum Effective Balance section in the operator guide.

7. (Optional) Stake additional BERA

Add stake to your pool and send stBERA to a receiver address:

# With BEACOND_HOME configured (pool auto-detected):
./stake.sh --amount 100 --receiver 0xRECEIVER

# Or specify an explicit pool address:
./stake.sh --amount 100 --receiver 0xRECEIVER --staking-pool 0xPOOL

The script writes stake-command.sh. Review and execute the command to submit your stake.

Troubleshooting (quick)

• Node API not reachable: Enable [beacon-kit.node-api] and confirm the address/port; or set NODE_API_ADDRESS in env.sh. The script will examine your files and tell you how to activate the API if it isn’t enabled yet.
• Missing tools: Install Foundry (cast), jq, bc, and curl and ensure they are on your PATH.

What’s next

• Contract reference explains what you’ve deployed
• Delegation guide explains how to receive a Foundation delegation, which is very similar to this flow