Quickstart

warning

The Succinct Prover Network is not currently live on Ethereum Mainnet. The steps in this guide are for connecting to our Sepolia testnet deployment

In this section, we will walk through the steps to run a minimal prover on the network.

As a reminder, Succinct provides an out-of-the-box implementation of the prover software, designed to run a minimal node on the network. While this version is easy to set up and useful for understanding the prover architecture, it is not competitive with actively optimized provers running on the network. You should not expect to generate many proofs or operate profitably with this setup. It is best viewed as a reference implementation for developers building their own high-performance, scalable proving implementation.

Step 1: Requirements

You will need a fresh Ethereum wallet with some Sepolia ETH to interact with protocol smart contracts. We suggest using a fresh wallet for this purpose since the private key will be used inside the proving CLI.
You will also need at least 1000 $PROVE tokens to stake to your prover. You can obtain these tokens through our faucet.

Step 2: Create Your Prover

To create a prover, you need to call createProver(uint256 _stakerFeeBips) on the SuccinctStaking contract.

We suggest doing this through our frontend here. You can also interact with the contract directly using cast, Etherscan, or a similar tool.

By default, the wallet you use to create the prover will be the owner of the prover and also the delegated signer used to sign transactions on behalf of the prover.

Remember the address of the prover you created (not the same as the wallet that created it). You will need it later.

Step 3: Stake to Your Prover

The next step is to stake to your prover. You can do this by calling the stake(address _prover, uint256 _amount) function on the SuccinctStaking contract.

We also suggest doing this through our frontend here. Similarly, you can also interact with the contract directly using cast, Etherscan, or a similar tool.

Step 4: Calibrate the Prover

The prover needs to be calibrated to your hardware in order to configure key parameters that govern its behavior. There are two key parameters that need to be set:

Bidding Price: This is the price per proving gas unit (PGU) that the prover will bid for. This determines the profit margin of the prover and it's competitiveness with the rest of the network.
Expected Throughput: This is an estimate of the prover's proving throughput in PGUs per second. This is used to estimate whether a prover can complete a proof before its deadline.

We offer a calibration tool that can be used to set these parameters. This can be by using the calibrate command available in the CLI.

If you installed with Docker, you can run the following command:

docker run --rm public.ecr.aws/succinct-labs/spn-node:latest-gpu calibrate \
    --usd-cost-per-hour 0.80 \
    --utilization-rate 0.5 \
    --profit-margin 0.1 \
    --prove-price 1.00

If you built from source, you can run the following command:

SP1_PROVER=cuda ./target/release/spn-node calibrate \
    --usd-cost-per-hour 0.80 \
    --utilization-rate 0.5 \
    --profit-margin 0.1 \
    --prove-price 1.00

This will output calibration results that look like the following:

Parameters:
┌──────────────────┬────────┐
│ Parameter        │ Value  │
├──────────────────┼────────┤
│ Cost Per Hour    │ $0.80  │
├──────────────────┼────────┤
│ Utilization Rate │ 50.00% │
├──────────────────┼────────┤
│ Profit Margin    │ 10.00% │
├──────────────────┼────────┤
│ Price of $PROVE  │ $1.00  │
└──────────────────┴────────┘

Starting calibration...

Calibration Results:
┌──────────────────────┬─────────────────────────┐
│ Metric               │ Value                   │
├──────────────────────┼─────────────────────────┤
│ Estimated Throughput │ 1742469 PGUs/second     │
├──────────────────────┼─────────────────────────┤
│ Estimated Bid Price  │ 0.28 $PROVE per 1B PGUs │
└──────────────────────┴─────────────────────────┘

This tells you that your prover can prove 1742469 prover gas units (PGUs) per second and that you should bid 0.28 $PROVE per 1B PGUs for proofs.

Set these parameters as environment variables for later use:

export PGUS_PER_SECOND=<PGUS_PER_SECOND>
export PROVE_PER_BPGU=<PROVE_PER_BPGU>
export PROVER_ADDRESS=<PROVER_ADDRESS>
export PRIVATE_KEY=<PRIVATE_KEY>

Step 5: Run the Prover

At this point, we've done all the necessary setup. If you installed with Docker, you can run the following command:

docker run --rm public.ecr.aws/succinct-labs/spn-node:latest-gpu prove \
    --rpc-url https://rpc-production.succinct.xyz \
    --throughput $PGUS_PER_SECOND \
    --bid $PROVE_PER_BPGU \
    --private-key $PRIVATE_KEY \
    --prover $PROVER_ADDRESS

If you built from source, you can run the following command:

SP1_PROVER=cuda ./target/release/spn-node prove \
    --rpc-url https://rpc-production.succinct.xyz \
    --throughput $PGUS_PER_SECOND \
    --bid $PROVE_PER_BPGU \
    --private-key $PRIVATE_KEY \
    --prover $PROVER_ADDRESS

success

Congratulations! You're now running a prover on the network.

Frequently Asked Questions

What hardware is recommended for running a prover?

The minimal implementation works on standard consumer hardware, but competitive provers typically use optimized setups with powerful GPUs. As a reminder, most competitive provers use high-end GPUs like NVIDIA 4090s and orchestrate their own proving software to maximize throughput.

How profitable is running a prover?

Profitability depends on hardware, electricity costs, and competition on the network. The minimal implementation provided is not expected to be competitive for generating significant revenue. It serves primarily as a reference for developers building optimized proving implementations.

How much $PROVE token do I need to stake?

You need to stake at least 1000 $PROVE tokens to be eligible to bid for proofs on the Sepolia testnet. The staking requirements may change.

What happens if I can't complete a proof in time?

If your prover accepts a request but fails to deliver a proof before the deadline, a portion of your stake may be slashed as a penalty. This ensures the reliability of the network.

Slashing is not currently enabled on the Sepolia testnet.

How can I monitor my prover's performance?

You can monitor your prover through logs generated by the CLI. Additionally, you can track your prover's activity on the Succinct Explorer.

What does the calibration process actually measure?

The calibration process runs a suite of standard workloads to benchmark your hardware's proving performance. This measures your prover's throughput in proving gas units (PGUs) per second, which is a standardized metric for comparing proving performance across different hardware configurations. Based on this measurement and current network conditions, it also recommends a competitive bid amount for your prover.

What happens if my prover goes offline?

If your prover goes offline, it won't be able to bid for or complete proofs. There's no penalty for simply being offline, but if your prover was in the middle of generating a proof and fails to deliver it before the deadline, a portion of your stake may be slashed as a penalty. This ensures the reliability of the network.

How can I unstake my $PROVE tokens?

You can unstake your tokens through the Succinct staking interface or by directly interacting with the SuccinctStaking contract. Note that there may be a cooldown period before tokens can be withdrawn after unstaking.

Step 1: Requirements​

Step 2: Create Your Prover​

Step 3: Stake to Your Prover​

Step 4: Calibrate the Prover​

Step 5: Run the Prover​

Frequently Asked Questions​

What hardware is recommended for running a prover?​

How profitable is running a prover?​

How much $PROVE token do I need to stake?​

What happens if I can't complete a proof in time?​

How can I monitor my prover's performance?​

What does the calibration process actually measure?​

What happens if my prover goes offline?​

How can I unstake my $PROVE tokens?​