chore: v1.0.5-testnet (#843)

.github/workflows/main.yml

@@ -38,4 +38,13 @@ jobs:
               args: --release -p sp1-sdk --features plonk -- test_e2e_prove_plonk --nocapture
             env:
               RUSTFLAGS: -Copt-level=3 -Cdebug-assertions -Coverflow-checks=y -Cdebuginfo=0 -C target-cpu=native
-              RUST_BACKTRACE: 1
+              RUST_BACKTRACE: 1
+    check-branch:
+        name: Check branch
+        runs-on: ubuntu-latest
+        steps:
+          - name: Check branch
+            if: github.head_ref != 'dev'
+            run: |
+              echo "ERROR: You can only merge to main from dev."
+              exit 1

book/SUMMARY.md

@@ -40,4 +40,6 @@
 
 - [Recommended Settings](./developers/recommended-settings.md)
 
-- [Building Plonk Bn254 Artifacts](./developers/building-plonk-artifacts.md)
+- [Building Plonk Bn254 Artifacts](./developers/building-plonk-artifacts.md)
+
+- [Common Issues](./developers/common-issues.md)

book/developers/common-issues.md

@@ -0,0 +1,18 @@
+# Alloy Errors
+
+If you are using a library that depends on `alloy_sol_types`, and encounter an error like this:
+
+```
+perhaps two different versions of crate `alloy_sol_types` are being used?
+```
+
+This is likely due to two different versions of `alloy_sol_types` being used. To fix this, you can set `default-features` to `false` for the `sp1-sdk` dependency in your `Cargo.toml`.
+
+```toml
+[dependencies]
+sp1-sdk = { version = "0.1.0", default-features = false }
+```
+
+This will configure out the `network` feature which will remove the dependency on `alloy_sol_types` 
+and configure out the `NetworkProver`.
+

book/verifying-proofs/solidity-and-evm.md

@@ -14,7 +14,6 @@ To use PLONK proving & verification locally, enable the `plonk` feature flag in
 sp1-sdk = { features = ["plonk"] }
 ```
 
-
 ### Example
 
 ```rust,noplayground
@@ -23,25 +22,41 @@ sp1-sdk = { features = ["plonk"] }
 
 You can run the above script with `RUST_LOG=info cargo run --bin plonk_bn254 --release` in `examples/fibonacci/script`.
 
-## Exporting the Verifier Contract
+## Install SP1 Contracts
 
-To export the verifier contract, you can use the export function in the `sp1_sdk` crate.
+# SP1 Contracts
 
-### Example
+This repository contains the smart contracts for verifying [SP1](https://github.com/succinctlabs/sp1) EVM proofs.
 
-```rust,noplayground
-//! Builds the proving artifacts and exports the solidity verifier.
-//!
-//! You can run this script using the following command:
-//! ```shell
-//! RUST_LOG=info cargo run --package fibonacci-script --bin artifacts --release
-//! ```
-
-use std::path::PathBuf;
-
-fn main() {
-    let contracts_src_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../contracts/src");
-    sp1_sdk::artifacts::export_solidity_plonk_bn254_verifier(contracts_src_dir)
-        .expect("failed to export verifier");
+## Installation
+
+> [!WARNING]
+> [Foundry](https://github.com/foundry-rs/foundry) installs the latest release version initially, but subsequent `forge update` commands will use the `main` branch. This branch is the development branch and should be avoided in favor of tagged releases. The release process matches a specific SP1 version.
+
+To install the latest release version:
+
+```bash
+forge install succinctlabs/sp1-contracts
+```
+
+To install a specific version:
+```bash
+forge install succinctlabs/sp1-contracts@<version>
+```
+
+Add `@sp1-contracts/=lib/sp1-contracts/contracts/src/` in `remappings.txt.`
+
+### Usage
+
+Once installed, you can use the contracts in the library by importing them:
+
+```solidity
+pragma solidity ^0.8.25;
+
+import {SP1Verifier} from "@sp1-contracts/SP1Verifier.sol";
+
+contract MyContract is SP1Verifier {
 }
-```
+```
+
+For more details on the contracts, refer to the [sp1-contracts](https://github.com/succinctlabs/sp1-contracts) repo.

core/benches/main.rs

@@ -1,6 +1,3 @@
-#![allow(incomplete_features)]
-#![feature(generic_const_exprs)]
-
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use sp1_core::io::SP1Stdin;
 use sp1_core::runtime::{Program, Runtime};

core/src/lib.rs

@@ -11,7 +11,6 @@
     deprecated,
     incomplete_features
 )]
-#![feature(generic_const_exprs)]
 #![warn(unused_extern_crates)]
 
 extern crate alloc;

core/src/runtime/mod.rs

@@ -22,6 +22,7 @@ pub use utils::*;
 
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
+use std::fmt::{Display, Formatter, Result as FmtResult};
 use std::fs::File;
 use std::io::BufWriter;
 use std::io::Write;
@@ -81,6 +82,54 @@ pub struct Runtime {
     pub max_syscall_cycles: u32,
 
     pub emit_events: bool,
+
+    /// Report of the program execution.
+    pub report: ExecutionReport,
+
+    /// Whether we should write to the report.
+    pub should_report: bool,
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub struct ExecutionReport {
+    pub instruction_counts: HashMap<Opcode, u64>,
+    pub syscall_counts: HashMap<SyscallCode, u64>,
+}
+
+impl ExecutionReport {
+    pub fn total_instruction_count(&self) -> u64 {
+        self.instruction_counts.values().sum()
+    }
+
+    pub fn total_syscall_count(&self) -> u64 {
+        self.syscall_counts.values().sum()
+    }
+}
+
+impl Display for ExecutionReport {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        writeln!(f, "Instruction Counts:")?;
+        let mut sorted_instructions = self.instruction_counts.iter().collect::<Vec<_>>();
+
+        // Sort instructions by opcode name
+        sorted_instructions.sort_by_key(|&(opcode, _)| opcode.to_string());
+        for (opcode, count) in sorted_instructions {
+            writeln!(f, "  {}: {}", opcode, count)?;
+        }
+        writeln!(f, "Total Instructions: {}", self.total_instruction_count())?;
+
+        writeln!(f, "Syscall Counts:")?;
+        let mut sorted_syscalls = self.syscall_counts.iter().collect::<Vec<_>>();
+
+        // Sort syscalls by syscall name
+        sorted_syscalls.sort_by_key(|&(syscall, _)| format!("{:?}", syscall));
+        for (syscall, count) in sorted_syscalls {
+            writeln!(f, "  {}: {}", syscall, count)?;
+        }
+        writeln!(f, "Total Syscall Count: {}", self.total_syscall_count())?;
+
+        Ok(())
+    }
 }
 
 #[derive(Error, Debug)]
@@ -140,6 +189,8 @@ impl Runtime {
             syscall_map,
             emit_events: true,
             max_syscall_cycles,
+            report: Default::default(),
+            should_report: false,
         }
     }
 
@@ -535,6 +586,14 @@ impl Runtime {
         let mut memory_store_value: Option<u32> = None;
         self.memory_accesses = MemoryAccessRecord::default();
 
+        if self.should_report && !self.unconstrained {
+            self.report
+                .instruction_counts
+                .entry(instruction.opcode)
+                .and_modify(|c| *c += 1)
+                .or_insert(1);
+        }
+
         match instruction.opcode {
             // Arithmetic instructions.
             Opcode::ADD => {
@@ -749,6 +808,14 @@ impl Runtime {
                 b = self.rr(Register::X10, MemoryAccessPosition::B);
                 let syscall = SyscallCode::from_u32(syscall_id);
 
+                if self.should_report && !self.unconstrained {
+                    self.report
+                        .syscall_counts
+                        .entry(syscall)
+                        .and_modify(|c| *c += 1)
+                        .or_insert(1);
+                }
+
                 let syscall_impl = self.get_syscall(syscall).cloned();
                 let mut precompile_rt = SyscallContext::new(self);
                 let (precompile_next_pc, precompile_cycles, returned_exit_code) =
@@ -956,12 +1023,14 @@ impl Runtime {
 
     pub fn run_untraced(&mut self) -> Result<(), ExecutionError> {
         self.emit_events = false;
+        self.should_report = true;
         while !self.execute()? {}
         Ok(())
     }
 
     pub fn run(&mut self) -> Result<(), ExecutionError> {
         self.emit_events = true;
+        self.should_report = true;
         while !self.execute()? {}
         Ok(())
     }
@@ -1110,6 +1179,58 @@ pub mod tests {
         assert_eq!(runtime.register(Register::X31), 42);
     }
 
+    #[test]
+    fn test_ssz_withdrawals_program_run_report() {
+        let program = ssz_withdrawals_program();
+        let mut runtime = Runtime::new(program, SP1CoreOpts::default());
+        runtime.run().unwrap();
+        assert_eq!(runtime.report, {
+            use super::Opcode::*;
+            use super::SyscallCode::*;
+            super::ExecutionReport {
+                instruction_counts: [
+                    (LB, 10723),
+                    (DIVU, 6),
+                    (LW, 237094),
+                    (JALR, 38749),
+                    (XOR, 242242),
+                    (BEQ, 26917),
+                    (AND, 151701),
+                    (SB, 58448),
+                    (MUL, 4036),
+                    (SLTU, 16766),
+                    (ADD, 583439),
+                    (JAL, 5372),
+                    (LBU, 57950),
+                    (SRL, 293010),
+                    (SW, 312781),
+                    (ECALL, 2264),
+                    (BLTU, 43457),
+                    (BGEU, 5917),
+                    (BLT, 1141),
+                    (SUB, 12382),
+                    (BGE, 237),
+                    (MULHU, 1152),
+                    (BNE, 51442),
+                    (AUIPC, 19488),
+                    (OR, 301944),
+                    (SLL, 278698),
+                ]
+                .into(),
+                syscall_counts: [
+                    (COMMIT_DEFERRED_PROOFS, 8),
+                    (SHA_EXTEND, 1091),
+                    (COMMIT, 8),
+                    (WRITE, 65),
+                    (SHA_COMPRESS, 1091),
+                    (HALT, 1),
+                ]
+                .into(),
+            }
+        });
+        assert_eq!(runtime.report.total_instruction_count(), 2757356);
+    }
+
     #[test]
     #[should_panic]
     fn test_panic() {

core/src/runtime/syscall.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::fmt;
 use std::sync::Arc;
 
 use strum_macros::EnumIter;
@@ -28,7 +29,7 @@ use crate::{runtime::ExecutionRecord, runtime::MemoryReadRecord, runtime::Memory
 /// - The second byte is 0/1 depending on whether the syscall has a separate table. This is used
 /// in the CPU table to determine whether to lookup the syscall using the syscall interaction.
 /// - The third byte is the number of additional cycles the syscall uses.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, EnumIter)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, EnumIter, Ord, PartialOrd)]
 #[allow(non_camel_case_types)]
 pub enum SyscallCode {
     /// Halts the program.
@@ -149,6 +150,12 @@ impl SyscallCode {
     }
 }
 
+impl fmt::Display for SyscallCode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
 pub trait Syscall: Send + Sync {
     /// Execute the syscall and return the resulting value of register a0. `arg1` and `arg2` are the
     /// values in registers X10 and X11, respectively. While not a hard requirement, the convention

core/src/stark/permutation.rs

@@ -65,7 +65,7 @@ pub(crate) fn generate_permutation_trace<F: PrimeField, EF: ExtensionField<F>>(
     sends: &[Interaction<F>],
     receives: &[Interaction<F>],
     preprocessed: Option<&RowMajorMatrix<F>>,
-    main: &mut RowMajorMatrix<F>,
+    main: &RowMajorMatrix<F>,
     random_elements: &[EF],
     batch_size: usize,
 ) -> RowMajorMatrix<EF> {
@@ -96,13 +96,13 @@ pub(crate) fn generate_permutation_trace<F: PrimeField, EF: ExtensionField<F>>(
         Some(prep) => {
             permutation_trace
                 .par_rows_mut()
-                .zip_eq(prep.par_rows())
-                .zip_eq(main.par_rows())
+                .zip_eq(prep.par_row_slices())
+                .zip_eq(main.par_row_slices())
                 .for_each(|((row, prep_row), main_row)| {
                     populate_permutation_row(
                         row,
-                        prep_row.collect::<Vec<_>>().as_slice(),
-                        main_row.collect::<Vec<_>>().as_slice(),
+                        prep_row,
+                        main_row,
                         sends,
                         receives,
                         alpha,
@@ -114,7 +114,7 @@ pub(crate) fn generate_permutation_trace<F: PrimeField, EF: ExtensionField<F>>(
         None => {
             permutation_trace
                 .par_rows_mut()
-                .zip_eq(main.par_rows_mut())
+                .zip_eq(main.par_row_slices())
                 .for_each(|(row, main_row)| {
                     populate_permutation_row(
                         row,