feat: pass machine explicitly everywhere applicable

crates/cuda/Cargo.toml

@@ -12,6 +12,7 @@ rust-version = { workspace = true }
 
 [dependencies]
 sp1-core-machine = { workspace = true }
+sp1-hypercube = { workspace = true }
 sp1-prover = { workspace = true }
 sp1-primitives = { workspace = true }
 sp1-prover-types = { workspace = true }

crates/cuda/src/api.rs

@@ -1,15 +1,14 @@
 use serde::{Deserialize, Serialize};
 use sp1_prover::{worker::ProofFromNetwork, SP1VerifyingKey};
-
-use sp1_prover_types::network_base_types::ProofMode;
+use sp1_prover_types::{network_base_types::ProofMode, SerializableRiscvMachine};
 
 use crate::CudaClientError;
 use sp1_core_machine::io::SP1Stdin;
 
 #[derive(Serialize, Deserialize)]
 pub enum Request {
     /// Tell the server to create a new proving key.
-    Setup { elf: Vec<u8> },
+    Setup { elf: Vec<u8>, machine: SerializableRiscvMachine },
 
     /// Tell the server to create a proof with the given mode.
     ProveWithMode { mode: ProofMode, key: [u8; 32], stdin: SP1Stdin, proof_nonce: [u32; 4] },

crates/cuda/src/client.rs

@@ -1,6 +1,8 @@
 use sp1_core_executor::SP1Context;
 use sp1_core_machine::io::SP1Stdin;
-use sp1_primitives::Elf;
+use sp1_core_machine::riscv::RiscvAir;
+use sp1_hypercube::Machine;
+use sp1_primitives::{Elf, SP1Field};
 use sp1_prover::worker::ProofFromNetwork;
 use sp1_prover_types::network_base_types::ProofMode;
 use std::{
@@ -35,8 +37,12 @@ pub(crate) struct CudaClient {
 
 impl CudaClient {
     /// Setup a new proving key.
-    pub(crate) async fn setup(&self, elf: Elf) -> Result<CudaProvingKey, CudaClientError> {
-        let request = Request::Setup { elf: elf.as_ref().into() };
+    pub(crate) async fn setup(
+        &self,
+        elf: Elf,
+        machine: Machine<SP1Field, RiscvAir<SP1Field>>,
+    ) -> Result<CudaProvingKey, CudaClientError> {
+        let request = Request::Setup { elf: elf.as_ref().into(), machine: machine.into() };
         let response = self.send_and_recv(request).await?.into_result()?;
         match response {
             Response::Setup { id, vk } => Ok(CudaProvingKey::new(id, elf, vk, self.clone())),

crates/cuda/src/lib.rs

@@ -16,7 +16,9 @@ pub use error::CudaClientError;
 pub use pk::CudaProvingKey;
 use sp1_core_executor::SP1Context;
 use sp1_core_machine::io::SP1Stdin;
-use sp1_primitives::Elf;
+use sp1_core_machine::riscv::RiscvAir;
+use sp1_hypercube::Machine;
+use sp1_primitives::{Elf, SP1Field};
 use sp1_prover::worker::ProofFromNetwork;
 use sp1_prover_types::network_base_types::ProofMode;
 
@@ -38,8 +40,13 @@ impl CudaProver {
         Ok(Self { client: CudaClient::connect(cuda_id).await? })
     }
 
-    pub async fn setup(&self, elf: Elf) -> Result<CudaProvingKey, CudaClientError> {
-        self.client.setup(elf).await
+    /// Setup a new proving key.
+    pub async fn setup(
+        &self,
+        elf: Elf,
+        machine: Machine<SP1Field, RiscvAir<SP1Field>>,
+    ) -> Result<CudaProvingKey, CudaClientError> {
+        self.client.setup(elf, machine).await
     }
 
     pub async fn prove_with_mode(

crates/perf/src/bin/executor.rs

@@ -4,7 +4,7 @@ use clap::Parser;
 
 use slop_algebra::AbstractField;
 use sp1_core_executor::{MinimalExecutor, Program, SP1CoreOpts};
-use sp1_core_machine::io::SP1Stdin;
+use sp1_core_machine::{io::SP1Stdin, riscv::RiscvAir};
 use sp1_hypercube::{septic_digest::SepticDigest, MachineVerifyingKey};
 use sp1_primitives::{Elf, SP1Field};
 use sp1_prover::{
@@ -135,6 +135,7 @@ async fn execute_node(args: Args, elf: Vec<u8>, stdin: SP1Stdin) {
         gate,
         None,
         args.cycle_limit,
+        RiscvAir::machine(),
     );
 
     let counter_handle = tokio::task::spawn(async move {

crates/prover-types/Cargo.toml

@@ -17,6 +17,9 @@ hashbrown.workspace = true
 mti.workspace = true
 prost.workspace = true
 serde = { workspace = true, features = ["derive"] }
+sp1-core-machine = { workspace = true }
+sp1-hypercube = { workspace = true }
+sp1-primitives = { workspace = true }
 tokio = { workspace = true, features = ["sync", "rt"] }
 tonic = { version = "0.12.3", features = ["tls"] }
 tracing.workspace = true

crates/prover-types/src/lib.rs

@@ -3,6 +3,9 @@ use anyhow::{anyhow, Result};
 mod artifacts;
 pub use artifacts::*;
 
+mod machine;
+pub use machine::*;
+
 pub mod cluster {
     tonic::include_proto!("cluster");
 }

crates/prover-types/src/machine.rs

@@ -0,0 +1,23 @@
+use serde::{Deserialize, Serialize};
+use sp1_core_machine::riscv::RiscvAir;
+use sp1_hypercube::Machine;
+use sp1_primitives::SP1Field;
+
+/// A serializable placeholder for `Machine<SP1Field, RiscvAir<SP1Field>>`.
+///
+/// For now, all supported machines still round-trip to `RiscvAir::machine()`. Keeping this
+/// wrapper in shared transport types preserves the machine slot in protocols for follow-up work.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct SerializableRiscvMachine;
+
+impl From<Machine<SP1Field, RiscvAir<SP1Field>>> for SerializableRiscvMachine {
+    fn from(_: Machine<SP1Field, RiscvAir<SP1Field>>) -> Self {
+        Self
+    }
+}
+
+impl From<SerializableRiscvMachine> for Machine<SP1Field, RiscvAir<SP1Field>> {
+    fn from(_: SerializableRiscvMachine) -> Self {
+        RiscvAir::machine()
+    }
+}

crates/prover/scripts/build_recursion_vks.rs

@@ -2,7 +2,7 @@ use std::{fs::File, path::PathBuf};
 
 use clap::Parser;
 use either::Either;
-use sp1_core_machine::utils::setup_logger;
+use sp1_core_machine::{riscv::RiscvAir, utils::setup_logger};
 use sp1_prover::worker::{cpu_worker_builder, SP1LocalNodeBuilder};
 
 #[derive(Parser, Debug)]
@@ -29,7 +29,8 @@ async fn main() {
 
     let maybe_range = start.and_then(|s| end.map(|e| (s..e).collect::<Vec<usize>>()));
     let maybe_either = maybe_range.map(Either::Left);
-    let node = SP1LocalNodeBuilder::from_worker_client_builder(cpu_worker_builder())
+    let machine = RiscvAir::machine();
+    let node = SP1LocalNodeBuilder::from_worker_client_builder(cpu_worker_builder(machine))
         .build()
         .await
         .unwrap();

crates/prover/src/build.rs

@@ -574,7 +574,7 @@ pub async fn download_file(
 #[cfg(test)]
 mod tests {
     use sp1_core_executor::SP1Context;
-    use sp1_core_machine::utils::setup_logger;
+    use sp1_core_machine::{riscv::RiscvAir, utils::setup_logger};
     use sp1_primitives::io::sha256_hash;
     use sp1_prover_types::network_base_types::ProofMode;
     use tokio::process::Command;
@@ -663,7 +663,8 @@ mod tests {
         let elf = test_artifacts::FIBONACCI_ELF;
 
         tracing::info!("initializing prover");
-        let client = SP1LocalNodeBuilder::from_worker_client_builder(cpu_worker_builder())
+        let machine = RiscvAir::machine();
+        let client = SP1LocalNodeBuilder::from_worker_client_builder(cpu_worker_builder(machine))
             .build()
             .await
             .expect("failed to build client");
@@ -694,7 +695,8 @@ mod tests {
         setup_logger();
 
         tracing::info!("initializing prover");
-        let client = SP1LocalNodeBuilder::from_worker_client_builder(cpu_worker_builder())
+        let machine = RiscvAir::machine();
+        let client = SP1LocalNodeBuilder::from_worker_client_builder(cpu_worker_builder(machine))
             .build()
             .await
             .expect("failed to build client");

crates/prover/src/components.rs

@@ -4,7 +4,7 @@ use sp1_core_executor::HEIGHT_THRESHOLD;
 use sp1_core_machine::riscv::RiscvAir;
 use sp1_hypercube::{
     prover::{AirProver, CpuShardProver, SP1InnerPcsProver, SP1OuterPcsProver},
-    MachineVerifier, SP1InnerPcs, SP1OuterPcs, SP1Pcs, ShardContextImpl, ShardVerifier,
+    Machine, MachineVerifier, SP1InnerPcs, SP1OuterPcs, SP1Pcs, ShardContextImpl, ShardVerifier,
 };
 use sp1_primitives::{
     fri_params::{core_fri_config, recursion_fri_config, shrink_fri_config, wrap_fri_config},
@@ -53,12 +53,12 @@ pub trait CoreProver: AirProver<SP1GlobalContext, CoreSC> {
     /// The default verifier for the core prover.
     ///
     /// The verifier fixes the parameters of the underlying proof system.
-    fn verifier() -> MachineVerifier<SP1GlobalContext, CoreSC> {
+    fn verifier(
+        machine: Machine<SP1Field, RiscvAir<SP1Field>>,
+    ) -> MachineVerifier<SP1GlobalContext, CoreSC> {
         let core_log_stacking_height = CORE_LOG_STACKING_HEIGHT;
         let core_max_log_row_count = CORE_MAX_LOG_ROW_COUNT;
 
-        let machine = RiscvAir::machine();
-
         let core_verifier = ShardVerifier::from_basefold_parameters(
             core_fri_config(),
             core_log_stacking_height,
@@ -153,8 +153,10 @@ pub trait SP1ProverComponents: Send + Sync + 'static + Sized {
     type WrapProver: WrapProver;
     type WrapProverBuilder: WrapProverBuilder<Self>;
 
-    fn core_verifier() -> MachineVerifier<SP1GlobalContext, CoreSC> {
-        <Self::CoreProver as CoreProver>::verifier()
+    fn core_verifier(
+        machine: Machine<SP1Field, RiscvAir<SP1Field>>,
+    ) -> MachineVerifier<SP1GlobalContext, CoreSC> {
+        <Self::CoreProver as CoreProver>::verifier(machine)
     }
 
     fn compress_verifier() -> MachineVerifier<SP1GlobalContext, RecursionSC> {

crates/prover/src/recursion.rs

@@ -38,7 +38,7 @@ use sp1_recursion_executor::{RecursionProgram, DIGEST_SIZE};
 
 use crate::{
     shapes::{create_all_input_shapes, SP1RecursionProofShape},
-    worker::{TaskError, DEFAULT_MAX_COMPOSE_ARITY},
+    worker::TaskError,
     CompressAir, RecursionSC,
 };
 
@@ -50,12 +50,6 @@ pub struct RecursionVks {
     vk_verification: bool,
 }
 
-impl Default for RecursionVks {
-    fn default() -> Self {
-        Self::new(None, DEFAULT_MAX_COMPOSE_ARITY, true)
-    }
-}
-
 impl RecursionVks {
     /// The map for the recursion vk hashes to their indice in the merkle tree.
     const RECURSION_VK_MAP_BYTES: &[u8] = include_bytes!("vk_map.bin");
@@ -67,7 +61,8 @@ impl RecursionVks {
     ) -> Self {
         // Pad the map to the expected number of shapes. This allows us to build partial vk maps
         // for development purposes.
-        let num_shapes = create_all_input_shapes(RiscvAir::machine().shape(), max_compose_arity)
+        let machine = RiscvAir::machine();
+        let num_shapes = create_all_input_shapes(machine.shape(), max_compose_arity)
             .into_iter()
             .collect::<BTreeSet<_>>()
             .len();