Skip to main content

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 prover on the network. As a reminder, Succinct provides an out-of-the-box reference implementation of the prover software, designed to run a minimal node on the network. These instructions assume you have already installed the prover software. If you haven't, go to the Installation section.

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 prover implementation.

Step 1: Requirements​

  1. You will need a fresh Ethereum wallet to interact with the network. This wallet should not contain any funds, as the private key will be used inside the prover CLI.

  2. We recommend having a hardware wallet that will be used to create your prover and store funds. The fresh wallet you previously created will be used to sign transactions on behalf of your prover.

  3. You will also need at least 1000 testnet $PROVE tokens to stake to your prover so that you can bid for proofs. You can obtain these tokens through our faucet or by reaching out to us.

  4. You will need a machine with these recommended specs:

    • GPU: NVIDIA RTX 3090 or 4090
    • Memory: 24GB RAM (required)
    • Disk: 100GB (recommended)
    • CPU: 4 cores (required)
    • Template: Ubuntu VM (22.04/24.04) (required)

    You can either use a machine you already have or a cloud provider. Find more information in the Hardware Requirements section.

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. You can also interact with the contract directly using cast, Etherscan, or a similar tool.

Use your hardware wallet to create the prover. 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.

You can change the signer to your fresh wallet address by going to the Prover page and clicking "Set Signer". We'll refer to the private key of this wallet as the PRIVATE_KEY; you'll need it later.

Copy the address of the prover you created; you can find this address under "My Prover" in the frontend. Note that this is not the address of the wallet you used to create the prover. We'll refer to this address as the PROVER_ADDRESS; you'll 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. Similarly, you can also interact with the contract directly using cast, Etherscan, or a similar tool.

To be eligible to bid for proofs, you need to stake at least 1000 testnet $PROVE tokens to your prover. You can stake these yourself, or have other stakers delegate them to you.

Step 4: Run Your Prover​

You can now run your prover with our quickstart script. This will download the prover software as the necessary dependencies, configure it, and run it.

wget -O prove.sh https://raw.githubusercontent.com/succinctlabs/network/refs/heads/main/prove.sh
sudo bash prove.sh

Advanced​

In this section, we'll walk through you can calibrate your prover for more optimized performance and parameter selection and how to run the prover software directly from the terminal.

Prover Calibration​

The prover can 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 its 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>

Run Prover from CLI​

To run the prover from the CLI, set the environment variables for the prover:

export PROVER_ADDRESS=<PROVER_ADDRESS>
export PRIVATE_KEY=<PRIVATE_KEY>

Recall that the PROVER_ADDRESS is the address of the prover you created, found under "My Prover" in the frontend, and the PRIVATE_KEY is the private key of the wallet that will be used to sign transactions on behalf of the prover.

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

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​

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 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.

Slashing is not currently enabled on the Sepolia testnet.

How can I unstake my $PROVE tokens?​

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