SP1

https://docs.succinct.xyz/docs/
Admin
SP1 is a zero-knowledge virtual machine that proves the correct execution of programs compiled for...
Tokens:59,091
Snippets:708
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Run SP1 Installer

Source: https://docs.succinct.xyz/docs/sp1/getting-started/install

After downloading, execute `sp1up` to install the SP1 toolchain and the `cargo prove` CLI. This command installs the necessary components for compiling SP1 programs.

```bash
sp1up
```

--------------------------------

### List Installed Rust Toolchains

Source: https://docs.succinct.xyz/docs/sp1/getting-started/install

Verify the installation of the Succinct Rust toolchain by listing all installed toolchains. Ensure `succinct` appears in the output.

```bash
rustup toolchain list
```

--------------------------------

### Efficient Prover Client and Proving Key Usage

Source: https://docs.succinct.xyz/docs/sp1/prover-network/faq

Create the prover client and proving key once at the start of your program to avoid repeated setup costs. Reuse these instances for subsequent proof requests.

```rust
let client = ProverClient::builder()  
  .network_for(NetworkMode::Mainnet)  
  .build()  
  .await;  
let (pk, vk) = client.setup(elf).await;  
  
let proof = client.prove(&pk, &stdin)  
    .compressed()  
    .run()  
    .await;
```

--------------------------------

### Install Foundry CLI

Source: https://docs.succinct.xyz/docs/sp1/prover-network/quickstart

Install the Foundry CLI using the provided curl command and then update it with foundryup.

```bash
curl -L https://foundry.paradigm.xyz | bash  
foundryup  
```

--------------------------------

### Install SP1 Toolchain in CI

Source: https://docs.succinct.xyz/docs/sp1/developers/usage-in-ci

Installs the SP1 toolchain by downloading and executing the sp1up script. It also verifies the installation by checking the prove command version.

```yaml
- name: Install SP1 toolchain  
  run: |  
    curl -L https://sp1up.succinct.xyz | bash  
    ~/.sp1/bin/sp1up   
    ~/.sp1/bin/cargo-prove prove --version  


```

--------------------------------

### Download and Run SP1 Installer

Source: https://docs.succinct.xyz/docs/sp1/getting-started/install

Use this command to download and execute the `sp1up` installer script. Follow the on-screen prompts to make the `sp1up` command available in your CLI.

```bash
curl -L https://sp1up.succinct.xyz | bash
```

--------------------------------

### Requesting a Proof

Source: https://docs.succinct.xyz/docs/provers/building-a-prover/sdk

This example demonstrates the complete process of requesting a proof, including setting up the account, client, and constructing the request.

```APIDOC
## Requesting a Proof

This comprehensive example illustrates how to request a proof from the Succinct Prover Network. It covers account setup, client initialization, nonce retrieval, request body construction, signing, and sending the request.

### Steps

1. **Setup Account and Client**: Initialize a signer with a private key and create a `ProverNetworkClient`.
2. **Get Nonce**: Retrieve the current nonce for the signer's address.
3. **Construct Request Body**: Define the proof request parameters, including `vk_hash`, `version`, `mode`, `strategy`, `stdin_uri`, and `deadline`.
4. **Sign and Send Request**: Create a `RequestProofRequest`, sign it, and send it using the `network_client`.
5. **Process Response**: Extract the `request_id` from the response.

### Code Example

```rust
use alloy_primitives::U256;
use alloy_signer_local::PrivateKeySigner;
use spn_network_types::{
    MessageFormat, ProofMode, FulfillmentStrategy,
    RequestProofRequest, RequestProofRequestBody, Signable,
};
use std::time::{SystemTime, UNIX_EPOCH};

// Helper function to get current time in seconds since epoch
fn time_now() -> u64 {
    SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs()
}

// --- Setup --- 
let private_key = "0x..."; // Replace with your private key
let signer = PrivateKeySigner::new_from_hex(private_key)?;
// Assuming 'channel' is already established and 'network_client' is created
// let network_client = ProverNetworkClient::new(channel);

// --- Get Nonce ---
let nonce = network_client
    .get_nonce(spn_rpc::GetNonceRequest { address: signer.address().to_vec() })
    .await? 
    .into_inner()
    .nonce;

// --- Construct Request Body ---
let body = RequestProofRequestBody {
    nonce,
    vk_hash: hex::decode("0018b32c74d38cdbbcf62bd30414e413fdd5553ed5d33e9ea432a11d6d7ebcf8")?,
    version: "sp1-v6.1.0".to_string(),
    mode: ProofMode::ExecutionAndProof.into(),
    strategy: FulfillmentStrategy::Auction.into(),
    stdin_uri: "https://artifacts.mainnet.succinct.xyz/stdins/artifact_01jtv7tm61fjsae9cxea76h46p".to_string(),
    deadline: time_now() + 300, // 5 minutes from now
    gas_limit: 1_000_000_000, // PGUs (Proving Gas Units)
};

// --- Sign and Send Request ---
let request = RequestProofRequest {
    format: MessageFormat::Binary.into(),
    signature: body.sign(&signer).into(),
    body: Some(body),
};

let response = network_client.request_proof(request).await?;
let request_id = response.into_inner().body.unwrap().request_id;

println!("Created proof request with ID: {}", hex::encode(request_id));
```
```

--------------------------------

### Clone SP1 Repository and Install CLI

Source: https://docs.succinct.xyz/docs/sp1/getting-started/install

Steps to build the SP1 CLI from source. This involves cloning the repository, navigating to the CLI directory, and installing it using Cargo. This option is recommended for advanced users and may take a significant amount of time.

```bash
git clone git@github.com:succinctlabs/sp1.git
cd sp1/crates/cli
cargo install --locked --force --path .
cd ~
cargo prove build-toolchain
```

--------------------------------

### Example Build Output

Source: https://docs.succinct.xyz/docs/sp1/writing-programs/compiling

This is an example of the output you might see when compiling an SP1 program. It shows the compilation process of various dependencies and your program.

```text
[sp1]     Compiling version_check v0.9.4  
[sp1]     Compiling proc-macro2 v1.0.86  
[sp1]     Compiling unicode-ident v1.0.12  
[sp1]     Compiling cfg-if v1.0.0  
...  
[sp1]     Compiling sp1-lib v1.0.1  
[sp1]     Compiling sp1-zkvm v1.0.1  
[sp1]     Compiling fibonacci-program v0.1.0 (/Users/username/Documents/fibonacci/program)  
[sp1]      Finished `release` profile [optimized] target(s) in 8.33s  
```

--------------------------------

### Get Help for `cargo prove build`

Source: https://docs.succinct.xyz/docs/sp1/writing-programs/compiling

Run `cargo prove build --help` to view all available configuration options for customizing the build process.

```bash
cargo prove build --help
```

--------------------------------

### Run Succinct Prover Fulfiller

Source: https://docs.succinct.xyz/docs/provers/setup/deployment/docker-compose

Starts the fulfiller service using Docker Compose. Ensure RPC_GRPC_ADDR and SP1_PRIVATE_KEY are set.

```bash
export RPC_GRPC_ADDR=https://rpc.sepolia.succinct.xyz
export SP1_PRIVATE_KEY=<key>

docker compose up -d fulfiller

```

--------------------------------

### Install SP1 Toolchain from Source

Source: https://docs.succinct.xyz/docs/sp1/getting-started/install

After building the CLI from source, use this command to build the Succinct Rust toolchain. This process can take 30 minutes to an hour.

```bash
cargo prove build-toolchain
```

--------------------------------

### Run Succinct Prover Bidder

Source: https://docs.succinct.xyz/docs/provers/setup/deployment/docker-compose

Starts the bidder service using Docker Compose. Ensure RPC_GRPC_ADDR and SP1_PRIVATE_KEY are set.

```bash
export RPC_GRPC_ADDR=https://rpc.sepolia.succinct.xyz
export SP1_PRIVATE_KEY=<key>

docker compose up -d bidder

```

--------------------------------

### Initialize New SP1 Project

Source: https://docs.succinct.xyz/docs/sp1/verification/getting-started

Use this command to create a new SP1 project with a predefined structure, including examples for program, script, and contract.

```bash
cargo prove new --evm <name>
```

--------------------------------

### Install and Load Profile with Samply

Source: https://docs.succinct.xyz/docs/sp1/optimizing-programs/profiling

Install the Samply tool and use it to load and view the generated profile file. Samply utilizes the Firefox profiler for visualization.

```bash
    cargo install --locked samply  
    samply load output.json  

```

--------------------------------

### Install SP1 Contracts for Solidity 0.8.15

Source: https://docs.succinct.xyz/docs/sp1/verification/solidity-sdk

Installs the sp1-contracts library specifically built with Solidity version 0.8.15 using Foundry.

```bash
forge install succinctlabs/sp1-contracts@main-0.8.15  

```

--------------------------------

### Install SP1 with GitHub Token

Source: https://docs.succinct.xyz/docs/sp1/getting-started/install

If you encounter rate-limiting issues with `sp1up`, use this command with your GitHub token. Replace `ghp_YOUR_GITHUB_TOKEN_HERE` with your actual token.

```bash
sp1up --token ghp_YOUR_GITHUB_TOKEN_HERE
```

--------------------------------

### Async ProverClient Build (V5)

Source: https://docs.succinct.xyz/docs/sp1/developers/upgrades

Example of building a ProverClient in V5 without async/await.

```rust
use sp1_sdk::{ProverClient, SP1Stdin};

fn main() {
    let client = ProverClient::builder().cpu().build();
    let (pk, vk) = client.setup(elf);
    let proof = client.prove(&pk, &stdin).compressed().run().unwrap();
    client.verify(&proof, &vk).unwrap();
}
```

--------------------------------

### Install SP1 Toolchain with GitHub PAT

Source: https://docs.succinct.xyz/docs/sp1/developers/usage-in-ci

Installs the SP1 toolchain using a GitHub Personal Access Token (PAT) to avoid potential rate limiting issues with the sp1up script. Verifies the installation by checking the prove command version.

```yaml
- name: Install SP1 toolchain  
  run: |  
    curl -L https://sp1up.succinct.xyz | bash  
    ~/.sp1/bin/sp1up --token "${{ secrets.GH_PAT }}"  
    ~/.sp1/bin/cargo-prove prove --version  


```

--------------------------------

### Install Latest SP1 Contracts

Source: https://docs.succinct.xyz/docs/sp1/verification/solidity-sdk

Installs the latest release version of the sp1-contracts library using Foundry.

```bash
forge install succinctlabs/sp1-contracts  

```

--------------------------------

### Install SP1 with C Toolchain

Source: https://docs.succinct.xyz/docs/sp1/developers/common-issues

To resolve C binding errors, install sp1 with the `--c-toolchain` flag. This installs the RISC-V C++ toolchain and sets the necessary environment variable.

```bash
sp1up --c-toolchain
```

--------------------------------

### Example Benchmark Output

Source: https://docs.succinct.xyz/docs/provers/setup/faq

This is an example of the output you can expect when running a cluster benchmark. The 'Aggregate MHz' indicates the overall proving throughput.

```text
2025-09-10T21:03:55.029021Z  INFO crates/common/src/logger.rs:110: logging initialized      
2025-09-10T21:03:55.029688Z  INFO bin/cli/src/commands/bench.rs:71: Running 1x Fibonacci Compressed for 5 million cycles...  
...  
2025-09-10T21:03:56.373132Z  INFO bin/cli/src/commands/bench.rs:150: base_id: cli_1757538236373  
2025-09-10T21:04:02.425794Z  INFO bin/cli/src/commands/bench.rs:215: Completed after 5.969402833s  
2025-09-10T21:04:02.425818Z  INFO bin/cli/src/commands/bench.rs:217: Total Cycles: 5000000 | Aggregate MHz: 0.84  

```

--------------------------------

### Verify Succinct Rust Toolchain Installation

Source: https://docs.succinct.xyz/docs/sp1/getting-started/install

Confirm the installation of the Succinct Rust toolchain by checking its version. This command ensures the `riscv64im-succinct-zkvm-elf` compilation target is available.

```bash
RUSTUP_TOOLCHAIN=succinct cargo --version
```

--------------------------------

### Build Script Output Example

Source: https://docs.succinct.xyz/docs/sp1/writing-programs/compiling

This output indicates that the program was rebuilt because changes were detected in its source or configuration files. It shows the compilation and finishing steps.

```text
[fibonacci-script 0.1.0] cargo:rerun-if-changed=../program/src
[fibonacci-script 0.1.0] cargo:rerun-if-changed=../program/Cargo.toml
[fibonacci-script 0.1.0] cargo:rerun-if-changed=../program/Cargo.lock
[fibonacci-script 0.1.0] cargo:warning=fibonacci-program built at 2024-03-02 22:01:26
[fibonacci-script 0.1.0] [sp1]    Compiling fibonacci-program v0.1.0 (/Users/umaroy/Documents/fibonacci/program)
[fibonacci-script 0.1.0] [sp1]     Finished release [optimized] target(s) in 0.15s
warning: fibonacci-script@0.1.0: fibonacci-program built at 2024-03-02 22:01:26
```

--------------------------------

### Example Output of cargo tree

Source: https://docs.succinct.xyz/docs/sp1/optimizing-programs/precompiles

This is an example of the expected output from `cargo tree` when a patch is successfully applied, showing the linked repository and tag.

```text
p256 v13.2 (https://github.com/sp1-patches/elliptic-curves?tag=patch-p256-13.2-sp1-6.0.0)
├── ...

```

--------------------------------

### Setup SP1 Logger

Source: https://docs.succinct.xyz/docs/sp1/generating-proofs/basics

Initialize the sp1-sdk logger to display useful information during script execution, such as program execution time.

```rust
async fn main() {  

```

--------------------------------

### Verify Cargo Prove CLI Installation

Source: https://docs.succinct.xyz/docs/sp1/getting-started/install

Check the installation of the `cargo prove` CLI tool by running this command. It confirms that the CLI is accessible and provides its version number.

```bash
cargo prove --version
```

--------------------------------

### Install Rust Toolchain for CI

Source: https://docs.succinct.xyz/docs/sp1/developers/usage-in-ci

Installs a specific Rust toolchain version with necessary components for SP1 development in a CI environment.

```yaml
- name: Install Rust Toolchain  
  uses: actions-rs/toolchain@v1  
  with:  
    toolchain: 1.91.0  
    profile: default  
    override: true  
    default: true  
    components: llvm-tools, rustc-dev  


```

--------------------------------

### Configure Helm Chart Values

Source: https://docs.succinct.xyz/docs/provers/setup/deployment/kubernetes

Copy the example Helm chart values file and customize it for your specific test environment. Pay attention to resource allocation for different components.

```bash
cp infra/charts/sp1-cluster/values-example.yaml infra/charts/sp1-cluster/values-test.yaml  

```

--------------------------------

### Install sp1-verifier Dependency

Source: https://docs.succinct.xyz/docs/sp1/generating-proofs/off-chain-verification

Add the `sp1-verifier` crate to your `Cargo.toml` to enable off-chain verification in no_std environments. Ensure you specify the correct version.

```toml
sp1-verifier = {version = "6.1.0", default-features = false}
```

--------------------------------

### Get Program Verification Key using sp1-sdk

Source: https://docs.succinct.xyz/docs/sp1/verification/solidity-sdk

A Rust script using the sp1-sdk to set up a prover client, load a program's ELF file, and print its verification key.

```rust
fn main() {  
    // Setup the logger.  
    sp1_sdk::utils::setup_logger();  
  
    // Setup the prover client.  
    let client = ProverClient::from_env();  
  
    // Setup the program.  
    let (_, vk) = client.setup(FIBONACCI_ELF);  
  
    // Print the verification key.  
    println!("Program Verification Key: {}", vk.bytes32());  
}

```

--------------------------------

### Example Output of Fibonacci Proof Submission

Source: https://docs.succinct.xyz/docs/provers/setup/deployment/docker-compose

This output shows the logging and progress messages generated when submitting a Fibonacci proof, including connection details, artifact store initialization, and proof completion time.

```text
INFO crates/common/src/logger.rs:111: logging initialized      
INFO bin/cli/src/commands/bench.rs:68: Running Fibonacci Compressed for 5 million cycles...  
INFO crates/common/src/client.rs:22: connecting to http://127.0.0.1:50051  
INFO bin/cli/src/commands/bench.rs:113: using redis artifact store  
INFO crates/artifact/src/redis.rs:38: initializing redis pool  
INFO serialize: crates/artifact/src/lib.rs:126: close time.busy=62.9µs time.idle=1.55ms  
INFO upload: crates/artifact/src/redis.rs:196: close time.busy=2.20ms time.idle=2.15ms artifact_type=Program id="artifact_01jxzhe54bf28v7qk3qr9yedqd"  
INFO upload: crates/artifact/src/redis.rs:196: close time.busy=734µs time.idle=442µs artifact_type=Stdin id="artifact_01jxzhe54hfg1bhewm129hw58j"  
INFO bin/cli/src/commands/bench.rs:146: proof_id: cli_1750183908498  
INFO bin/cli/src/commands/bench.rs:185: Proof request completed after 6.531405385s  
INFO bin/cli/src/commands/bench.rs:187: Aggregate MHz: 0.77  

```

--------------------------------

### Install Specific Version of SP1 Contracts

Source: https://docs.succinct.xyz/docs/sp1/verification/solidity-sdk

Installs a specific version of the sp1-contracts library using Foundry.

```bash
forge install succinctlabs/sp1-contracts@<version>  

```

--------------------------------

### Remove SP1-Installed Cargo Prove

Source: https://docs.succinct.xyz/docs/sp1/getting-started/install

Use this command to remove the `cargo-prove` installation managed by `sp1up`. This is useful for troubleshooting conflicting installations.

```bash
rm ~/.sp1/bin/cargo-prove
```

--------------------------------

### Remove Source-Installed Cargo Prove

Source: https://docs.succinct.xyz/docs/sp1/getting-started/install

If you previously installed `cargo-prove` from source, use this command to remove it to avoid conflicts with the `sp1up` installation.

```bash
rm ~/.cargo/bin/cargo-prove
```

--------------------------------

### Submit Proof Request with Succinct SDK

Source: https://docs.succinct.xyz/docs/protocol/spn/lifecycle

Use the Succinct SDK to build a prover client and submit a proof request to the network. Ensure you have your private key and the necessary artifact details.

```rust
let client = ProverClient::builder()
  .network_for(NetworkMode::Mainnet)
  .private_key("<YOUR_PRIVATE_KEY>")
  .build()
  .await;
client.prove(&pk, &stdin)
  .core()
  .run()
  .await;
```

--------------------------------

### Download Prebuilt SP1 Toolchain

Source: https://docs.succinct.xyz/docs/sp1/getting-started/install

For machines compatible with prebuilt binaries (ARM Mac, x86/ARM Linux), use this command to download the toolchain instead of building it from source.

```bash
cargo prove install-toolchain
```

--------------------------------

### Requesting Proofs with Reserved Capacity

Source: https://docs.succinct.xyz/docs/sp1/prover-network/reserved-capacity

This snippet demonstrates how to set up a `ProverClient` for reserved capacity and request a proof. Ensure you are using `sp1-sdk >= v6.1.0` and have your `NETWORK_PRIVATE_KEY` environment variable set or use the `.private_key()` method.

```rust
use sp1_sdk::{
  include_elf,
  network::{FulfillmentStrategy, NetworkMode},
  utils, Elf, ProveRequest, Prover, ProverClient, SP1Stdin,
};

/// The ELF of the program you want to execute inside the zkVM.
const ELF: Elf = include_elf!("fibonacci-program");

#[tokio::main]
async fn main() {
  // Setup logging.
  utils::setup_logger();

  // Create an input stream and write '500' to it.
  let n = 1000u32;

  // The input stream that the program will read from using `sp1_zkvm::io::read`. Note that the
  // types of the elements in the input stream must match the types being read in the program.
  let mut stdin = SP1Stdin::new();
  stdin.write(&n);

  // Create a `ProverClient` method.
  let client = ProverClient::builder().network_for(NetworkMode::Reserved).build().await;

  // Generate the proof for the given program and input.
  let pk = client.setup(ELF).await.unwrap();
  let _proof = client
    .prove(&pk, stdin)
    .compressed()
    .strategy(FulfillmentStrategy::Reserved)
    .await
    .unwrap();
}


```

--------------------------------

### Install AWS-LC-TLS Crypto Provider at Runtime

Source: https://docs.succinct.xyz/docs/sp1/developers/upgrades

Install the AWS-LC-TLS crypto provider at runtime in your main function to resolve TLS provider ambiguity when using RustCrypto with aws-sdk-* crates.

```rust
fn main() {
    rustls::crypto::aws_lc_rs::default_provider().install_default()
        .expect("Failed to set default crypto provider");

    ...
}
```

--------------------------------

### Build Program with Docker

Source: https://docs.succinct.xyz/docs/sp1/writing-programs/compiling

Use the `--docker` flag for production builds to generate a reproducible ELF file. This ensures the build is identical across all platforms.

```bash
cargo prove build --docker
```

--------------------------------

### PLONK Proof Generation

Source: https://docs.succinct.xyz/docs/sp1/generating-proofs/proof-types

Generates a ~868-byte SNARK proof verifiable on-chain for ~300k gas. This type does not require a trusted setup and is suitable when avoiding trusted setup assumptions is critical.

```rust
let client = ProverClient::from_env().await;  
client.prove(&pk, &stdin).plonk().await.unwrap();  
```

--------------------------------

### Initialize CUDA Prover Client

Source: https://docs.succinct.xyz/docs/sp1/generating-proofs/hardware-acceleration

Use `ProverClient::from_env` with `SP1_PROVER=cuda` or `ProverClient::builder().cuda().build()` to initialize the CUDA prover.

```rust
use sp1_core::ProverClient;

// Option 1: Using environment variable
// Set SP1_PROVER=cuda before running
let mut client = ProverClient::from_env();

// Option 2: Using builder pattern
// let mut client = ProverClient::builder().cuda().build();

// Now use client.generate_proof(...)
```

--------------------------------

### Generate and Verify Proof

Source: https://docs.succinct.xyz/docs/sp1/getting-started/quickstart

Generate a proof for your program and automatically verify its correctness. This command should be run from the script directory.

```bash
cd ../script  
RUST_LOG=info cargo run --release -- --prove  
```

--------------------------------

### Creating a Prover Network Client

Source: https://docs.succinct.xyz/docs/provers/building-a-prover/sdk

This snippet shows how to create a network client by configuring an RPC endpoint and connecting to it.

```APIDOC
## Creating a Prover Network Client

This section demonstrates how to initialize a `ProverNetworkClient` to interact with the Succinct Prover Network.

### Usage

1. **Configure Endpoint**: Set up the RPC URL and establish a connection.
2. **Instantiate Client**: Create a new `ProverNetworkClient` using the established channel.

### Code Example

```rust
use spn_network_types::prover_network_client::ProverNetworkClient;
use spn_rpc::configure_endpoint;
use tonic::transport::Channel;

// Define the RPC URL for the network
let rpc_url = "https://rpc.mainnet.succinct.xyz";

// Configure the endpoint and establish a connection
let channel = configure_endpoint(rpc_url).await?.connect().await?;

// Create a new ProverNetworkClient
let network_client = ProverNetworkClient::new(channel);
```
```

--------------------------------

### Create a Prover Network Client

Source: https://docs.succinct.xyz/docs/provers/building-a-prover/sdk

Instantiates a ProverNetworkClient to interact with the Succinct Prover Network. Requires RPC URL and establishes a connection.

```rust
use spn_network_types::prover_network_client::ProverNetworkClient;
use spn_rpc::configure_endpoint;
use tonic::transport::Channel;

// Create a network client
let rpc_url = "https://rpc.mainnet.succinct.xyz";
let channel = configure_endpoint(rpc_url).await?.connect().await?;
let network_client = ProverNetworkClient::new(channel);

```

--------------------------------

### Create a New SP1 Project

Source: https://docs.succinct.xyz/docs/sp1/getting-started/quickstart

Use the `cargo-prove new --bare` command to create a new SP1 project. Navigate into the created project directory.

```bash
cargo prove new --bare fibonacci  
cd fibonacci  
```

--------------------------------

### C Binding Errors

Source: https://docs.succinct.xyz/docs/sp1/developers/common-issues

These errors indicate issues with C bindings or dependencies. Ensure the RISC-V C++ toolchain is installed and configured correctly.

```bash
cc did not execute successfully
```

```bash
Failed to find tool. Is `riscv64-unknown-elf-gcc` installed?
```

--------------------------------

### Benchmark Fibonacci with Kubernetes

Source: https://docs.succinct.xyz/docs/provers/setup/faq

This command benchmarks Fibonacci proof generation within a Kubernetes environment. The `--count` parameter should be scaled according to the number of GPUs available.

```bash
kubectl run cli --image=ghcr.io/succinctlabs/sp1-cluster:base-latest \
  --rm -it -n sp1-cluster-test /bin/bash  
/cli bench fibonacci 300 --count 2 \
  --cluster-rpc http://api-grpc:50051 \
  --redis-nodes redis://:redispassword@redis-master:6379/0  

```

--------------------------------

### Run Program with Profiling Environment Variables

Source: https://docs.succinct.xyz/docs/sp1/optimizing-programs/profiling

Execute your program with the TRACE_FILE and TRACE_SAMPLE_RATE environment variables set. TRACE_FILE specifies the output path for the profile, and TRACE_SAMPLE_RATE controls the sampling frequency to manage trace file size.

```bash
    TRACE_FILE=output.json TRACE_SAMPLE_RATE=100 cargo run ...  

```

--------------------------------

### Remove Succinct Rust Toolchain

Source: https://docs.succinct.xyz/docs/sp1/getting-started/install

Command to remove the Succinct Rust toolchain if needed. This can be useful for managing installations or freeing up disk space.

```bash
rustup toolchain remove succinct
```

--------------------------------

### Enable Profiling Feature in sp1-sdk

Source: https://docs.succinct.xyz/docs/sp1/optimizing-programs/profiling

Enable the profiling feature for the sp1-sdk in your script's Cargo.toml file. This is a required setup step for profiling.

```toml
    sp1-sdk = { version = "6.1.0", features = ["profiling"] }  

```

--------------------------------

### Alternative Verification of Succinct Rust Toolchain

Source: https://docs.succinct.xyz/docs/sp1/getting-started/install

An equivalent command to verify the Succinct Rust toolchain installation. It also checks for the presence of the `succinct` toolchain.

```bash
cargo +succinct --version
```

--------------------------------

### Estimate Proof Cost by Local Execution

Source: https://docs.succinct.xyz/docs/sp1/prover-network/faq

Execute your program locally to determine the Proof Generation Units (PGUs) it consumes. This requires setting up the ProverClient and running your program against the network.

```rust
let client = ProverClient::builder().network_for(NetworkMode::Mainnet).build().await;  
let (_, report) = client.execute(ELF, &stdin).run().await.unwrap();  
println!("PGUs: {}", report.gas.unwrap_or(0));  

```

--------------------------------

### SP1 zkVM Program Entrypoint

Source: https://docs.succinct.xyz/docs/sp1/writing-programs/setup

Include these two lines in your src/main.rs file to ensure your program compiles correctly for the RISC-V target and the SP1 environment.

```rust
#![no_main]  
sp1_zkvm::entrypoint!(main);  

```

--------------------------------

### Get AWS KMS Signer Address in Rust

Source: https://docs.succinct.xyz/docs/sp1/prover-network/advanced-usage

Retrieve the Ethereum address associated with your AWS KMS key directly within your Rust code.

```rust
let signer = NetworkSigner::aws_kms("<KMS_KEY_ARN>").await.unwrap();  
println!("address: {:?}", signer.address());
```

--------------------------------

### Navigate to Program Directory

Source: https://docs.succinct.xyz/docs/sp1/writing-programs/compiling

Before compiling, navigate to the directory containing your SP1 program.

```bash
cd path/to/your/program
```

--------------------------------

### Get SP1 TEE Version

Source: https://docs.succinct.xyz/docs/sp1/prover-network/tee

Import and use the `SP1_TEE_VERSION` constant from the `sp1_sdk::network::tee` module to retrieve the current version of the SP1 TEE.

```rust
use sp1_sdk::network::tee::SP1_TEE_VERSION;
```

--------------------------------

### Execute Fibonacci Program

Source: https://docs.succinct.xyz/docs/sp1/generating-proofs/basics

Execute the Fibonacci program using ProverClient.execute() to get the estimated proving cost and output without generating a full proof.

```rust
// Execute the program using the `ProverClient.execute` method, without generating a proof.  

```
Tokens:
Raw