switch to SecurityConfig in gpu_prover

robik75 · robik75 · commit 83185c906ec4 · 2026-01-16T16:44:14.000+01:00
diff --git a/gpu_prover/Cargo.toml b/gpu_prover/Cargo.toml
@@ -23,7 +23,7 @@ prover = { workspace = true }
 riscv_transpiler = { workspace = true, features = ["jit"] }
 setups = { workspace = true }
 trace_and_split = { workspace = true }
-verifier_common = { workspace = true }
+verifier_common = { workspace = true, features = ["proof_utils"] }
 worker = { workspace = true }
 itertools = { workspace = true }
 log = { workspace = true }
diff --git a/gpu_prover/src/circuit_type.rs b/gpu_prover/src/circuit_type.rs
@@ -1,5 +1,6 @@
 use crate::machine_type::MachineType;
 use prover::definitions::OPTIMAL_FOLDING_PROPERTIES;
+use prover::prover_stages::ProofSecurityConfig;
 use setups::{
     add_sub_lui_auipc_mop, bigint_with_control, blake2_with_compression, inits_and_teardowns,
     jump_branch_slt, keccak_special5, load_store_subword_only, load_store_word_only, mul_div,
@@ -75,6 +76,13 @@ impl CircuitType {
         //     Self::Unrolled(unrolled_type) => unrolled_type.get_tree_cap_size(),
         // }
     }
+
+    pub fn get_security_config(&self) -> ProofSecurityConfig {
+        match self {
+            Self::Delegation(delegation_type) => delegation_type.get_security_config(),
+            Self::Unrolled(unrolled_type) => unrolled_type.get_security_config(),
+        }
+    }
 }
 
 #[repr(u32)]
@@ -155,6 +163,18 @@ impl DelegationCircuitType {
             MachineType::Reduced => &[DelegationCircuitType::Blake2WithCompression],
         }
     }
+
+    pub fn get_security_config(&self) -> ProofSecurityConfig {
+        match self {
+            Self::BigIntWithControl => {
+                get_security_config::<{ bigint_with_control::DOMAIN_SIZE }>()
+            }
+            Self::Blake2WithCompression => {
+                get_security_config::<{ blake2_with_compression::DOMAIN_SIZE }>()
+            }
+            Self::KeccakSpecial5 => get_security_config::<{ keccak_special5::DOMAIN_SIZE }>(),
+        }
+    }
 }
 
 impl From<u16> for DelegationCircuitType {
@@ -272,6 +292,17 @@ impl UnrolledCircuitType {
             .iter()
             .map(|id| DelegationCircuitType::from(*id as u16))
     }
+
+    pub fn get_security_config(&self) -> ProofSecurityConfig {
+        match self {
+            Self::InitsAndTeardowns => {
+                get_security_config::<{ inits_and_teardowns::DOMAIN_SIZE }>()
+            }
+            Self::Memory(circuit_type) => circuit_type.get_security_config(),
+            Self::NonMemory(circuit_type) => circuit_type.get_security_config(),
+            Self::Unified => get_security_config::<{ unified_reduced_machine::DOMAIN_SIZE }>(),
+        }
+    }
 }
 
 #[repr(u32)]
@@ -361,6 +392,17 @@ impl UnrolledMemoryCircuitType {
             },
         }
     }
+
+    pub fn get_security_config(&self) -> ProofSecurityConfig {
+        match self {
+            Self::LoadStoreSubwordOnly => {
+                get_security_config::<{ load_store_subword_only::DOMAIN_SIZE }>()
+            }
+            Self::LoadStoreWordOnly => {
+                get_security_config::<{ load_store_word_only::DOMAIN_SIZE }>()
+            }
+        }
+    }
 }
 
 #[repr(u32)]
@@ -516,6 +558,18 @@ impl UnrolledNonMemoryCircuitType {
             Self::ShiftBinaryCsr => 4,
         }
     }
+
+    pub fn get_security_config(&self) -> ProofSecurityConfig {
+        match self {
+            Self::AddSubLuiAuipcMop => {
+                get_security_config::<{ add_sub_lui_auipc_mop::DOMAIN_SIZE }>()
+            }
+            Self::JumpBranchSlt => get_security_config::<{ jump_branch_slt::DOMAIN_SIZE }>(),
+            Self::MulDiv => get_security_config::<{ mul_div::DOMAIN_SIZE }>(),
+            Self::MulDivUnsigned => get_security_config::<{ mul_div_unsigned::DOMAIN_SIZE }>(),
+            Self::ShiftBinaryCsr => get_security_config::<{ shift_binary_csr::DOMAIN_SIZE }>(),
+        }
+    }
 }
 
 #[inline(always)]
@@ -534,3 +588,21 @@ pub const fn get_tree_cap_size_for_log_domain_size(log_domain_size: u32) -> usiz
 pub const fn get_log_tree_cap_size_for_log_domain_size(log_domain_size: u32) -> usize {
     OPTIMAL_FOLDING_PROPERTIES[log_domain_size as usize].total_caps_size_log2
 }
+
+const fn get_num_foldings<const DOMAIN_SIZE: usize>() -> usize {
+    assert!(DOMAIN_SIZE.is_power_of_two());
+    OPTIMAL_FOLDING_PROPERTIES[DOMAIN_SIZE.trailing_zeros() as usize]
+        .folding_sequence
+        .len()
+}
+
+fn get_security_config<const DOMAIN_SIZE: usize>() -> ProofSecurityConfig
+where
+    [(); get_num_foldings::<DOMAIN_SIZE>()]:,
+{
+    assert!(DOMAIN_SIZE.is_power_of_two());
+    let config = verifier_common::SizedProofSecurityConfig::<{
+        get_num_foldings::<DOMAIN_SIZE>()
+    }>::worst_case_config();
+    config.for_prover()
+}
diff --git a/gpu_prover/src/execution/gpu_worker.rs b/gpu_prover/src/execution/gpu_worker.rs
@@ -23,7 +23,6 @@ use std::ffi::CStr;
 use std::mem;
 use std::ops::Deref;
 use std::process::exit;
-use verifier_common::num_queries_for_security_params;
 
 pub fn get_gpu_worker_func(
     device_id: i32,
@@ -245,11 +244,7 @@ fn gpu_worker(
                         CircuitType::Delegation(delegation) => Some(delegation as u16),
                         CircuitType::Unrolled(_) => None,
                     };
-                    let num_queries = num_queries_for_security_params(
-                        verifier_common::SECURITY_BITS,
-                        verifier_common::POW_BITS,
-                        log_lde_factor as usize,
-                    );
+                    let security_config = circuit_type.get_security_config();
                     let trees_cache_mode = get_trees_cache_mode(circuit_type, &context);
                     trace!("BATCH[{batch_id}] GPU_WORKER[{device_id}] producing proof for circuit {circuit_type:?}[{sequence_id}]");
                     let job = prove(
@@ -264,8 +259,7 @@ fn gpu_worker(
                         &precomputations.lde_precomputations,
                         delegation_processing_type,
                         precomputations.lde_precomputations.lde_factor,
-                        num_queries,
-                        verifier_common::SECURITY_BITS,
+                        &security_config,
                         None,
                         false,
                         trees_cache_mode,
diff --git a/gpu_prover/src/prover/proof.rs b/gpu_prover/src/prover/proof.rs
@@ -26,7 +26,7 @@ use prover::definitions::{
 };
 use prover::prover_stages::cached_data::ProverCachedData;
 use prover::prover_stages::unrolled_prover::UnrolledModeProof;
-use prover::prover_stages::{ProofPowChallenges, ProofPowConfig};
+use prover::prover_stages::{ProofPowChallenges, ProofSecurityConfig};
 use prover::transcript::Seed;
 use std::sync::Arc;
 
@@ -81,8 +81,7 @@ pub(crate) fn prove<'a, A: GoodAllocator>(
     lde_precomputations: &LdePrecomputations<impl GoodAllocator>,
     delegation_processing_type: Option<u16>,
     lde_factor: usize,
-    num_queries: usize,
-    security_bits: usize,
+    security_config: &ProofSecurityConfig,
     external_pow_challenges: Option<ProofPowChallenges>,
     recompute_cosets: bool,
     trees_cache_mode: TreesCacheMode,
@@ -103,8 +102,6 @@ pub(crate) fn prove<'a, A: GoodAllocator>(
     assert!(trace_len.is_power_of_two());
     let log_domain_size = trace_len.trailing_zeros();
     let optimal_folding = OPTIMAL_FOLDING_PROPERTIES[log_domain_size as usize];
-    let optimal_folding_sequence_len = optimal_folding.folding_sequence.len();
-    let pow_config = ProofPowConfig::worst_case_config(security_bits, optimal_folding_sequence_len);
     let delegation_processing_type = delegation_processing_type.unwrap_or_default();
     let cached_data_values = ProverCachedData::new(
         &circuit,
@@ -194,7 +191,7 @@ pub(crate) fn prove<'a, A: GoodAllocator>(
     stage_2_range.start(stream)?;
     stage_2_output.generate(
         &mut seed,
-        &pow_config,
+        security_config,
         &external_pow_challenges,
         &circuit,
         is_unrolled,
@@ -213,7 +210,7 @@ pub(crate) fn prove<'a, A: GoodAllocator>(
     stage_3_range.start(stream)?;
     let mut stage_3_output = StageThreeOutput::new(
         &mut seed,
-        &pow_config,
+        security_config,
         &external_pow_challenges,
         &circuit,
         is_unrolled,
@@ -238,7 +235,7 @@ pub(crate) fn prove<'a, A: GoodAllocator>(
     stage_4_range.start(stream)?;
     let mut stage_4_output = StageFourOutput::new(
         &mut seed,
-        &pow_config,
+        security_config,
         &external_pow_challenges,
         &circuit,
         is_unrolled,
@@ -262,13 +259,12 @@ pub(crate) fn prove<'a, A: GoodAllocator>(
     stage_5_range.start(stream)?;
     let stage_5_output = StageFiveOutput::new(
         &mut seed,
-        &pow_config,
+        security_config,
         &external_pow_challenges,
         &mut stage_4_output,
         log_domain_size,
         log_lde_factor,
         &optimal_folding,
-        num_queries,
         &lde_precomputations,
         &mut callbacks,
         context,
@@ -281,7 +277,7 @@ pub(crate) fn prove<'a, A: GoodAllocator>(
     let fri_queries_pow_range = device_tracing::Range::new("fri_queries_pow")?;
     fri_queries_pow_range.start(stream)?;
     let mut fri_queries_pow_challenge = unsafe { context.alloc_host_uninit::<u64>() };
-    let fri_queries_pow_bits = pow_config.fri_queries_pow_bits;
+    let fri_queries_pow_bits = security_config.fri_queries_pow_bits;
     assert_ne!(fri_queries_pow_bits, 0);
     search_pow_challenge(
         &mut seed,
@@ -310,7 +306,7 @@ pub(crate) fn prove<'a, A: GoodAllocator>(
         &stage_5_output,
         log_domain_size,
         log_lde_factor,
-        num_queries,
+        security_config.num_queries,
         &optimal_folding,
         &mut callbacks,
         context,
diff --git a/gpu_prover/src/prover/stage_2.rs b/gpu_prover/src/prover/stage_2.rs
@@ -25,7 +25,7 @@ use era_cudart::slice::DeviceSlice;
 use field::{Field, FieldExtension};
 use prover::definitions::Transcript;
 use prover::prover_stages::cached_data::ProverCachedData;
-use prover::prover_stages::{ProofPowChallenges, ProofPowConfig};
+use prover::prover_stages::{ProofPowChallenges, ProofSecurityConfig};
 use prover::transcript::Seed;
 use std::slice;
 
@@ -79,7 +79,7 @@ impl StageTwoOutput {
     pub fn generate(
         &mut self,
         seed: &mut HostAllocation<Seed>,
-        pow_config: &ProofPowConfig,
+        security_config: &ProofSecurityConfig,
         external_challenges: &Option<ProofPowChallenges>,
         circuit: &CompiledCircuitArtifact<BF>,
         is_unrolled: bool,
@@ -100,7 +100,7 @@ impl StageTwoOutput {
         let stream = context.get_exec_stream();
         let seed_accessor = seed.get_mut_accessor();
         let mut pow_challenge = unsafe { context.alloc_host_uninit::<u64>() };
-        let pow_bits = pow_config.lookup_pow_bits;
+        let pow_bits = security_config.lookup_pow_bits;
         search_pow_challenge(
             seed,
             &mut pow_challenge,
diff --git a/gpu_prover/src/prover/stage_3.rs b/gpu_prover/src/prover/stage_3.rs
@@ -20,7 +20,7 @@ use field::FieldExtension;
 use prover::definitions::AuxArgumentsBoundaryValues;
 use prover::prover_stages::cached_data::ProverCachedData;
 use prover::prover_stages::stage3::AlphaPowersLayout;
-use prover::prover_stages::{ProofPowChallenges, ProofPowConfig};
+use prover::prover_stages::{ProofPowChallenges, ProofSecurityConfig};
 use prover::transcript::Seed;
 use std::alloc::Global;
 use std::slice;
@@ -34,7 +34,7 @@ pub(crate) struct StageThreeOutput {
 impl StageThreeOutput {
     pub fn new(
         seed: &mut HostAllocation<Seed>,
-        pow_config: &ProofPowConfig,
+        security_config: &ProofSecurityConfig,
         external_challenges: &Option<ProofPowChallenges>,
         circuit: &Arc<CompiledCircuitArtifact<BF>>,
         is_unrolled: bool,
@@ -69,7 +69,7 @@ impl StageThreeOutput {
         let stream = context.get_exec_stream();
         let seed_accessor = seed.get_mut_accessor();
         let mut pow_challenge = unsafe { context.alloc_host_uninit::<u64>() };
-        let pow_bits = pow_config.quotient_alpha_pow_bits;
+        let pow_bits = security_config.quotient_alpha_pow_bits;
         search_pow_challenge(
             seed,
             &mut pow_challenge,
diff --git a/gpu_prover/src/prover/stage_4.rs b/gpu_prover/src/prover/stage_4.rs
@@ -30,7 +30,7 @@ use field::{Field, FieldExtension};
 use itertools::Itertools;
 use prover::definitions::FoldingDescription;
 use prover::prover_stages::cached_data::ProverCachedData;
-use prover::prover_stages::{ProofPowChallenges, ProofPowConfig, Transcript};
+use prover::prover_stages::{ProofPowChallenges, ProofSecurityConfig, Transcript};
 use prover::transcript::Seed;
 use std::ops::DerefMut;
 use std::slice;
@@ -46,7 +46,7 @@ pub(crate) struct StageFourOutput {
 impl StageFourOutput {
     pub fn new(
         seed: &mut HostAllocation<Seed>,
-        pow_config: &ProofPowConfig,
+        security_config: &ProofSecurityConfig,
         external_challenges: &Option<ProofPowChallenges>,
         circuit: &Arc<CompiledCircuitArtifact<BF>>,
         is_unrolled: bool,
@@ -89,7 +89,7 @@ impl StageFourOutput {
         }
         let stream = context.get_exec_stream();
         let mut quotient_z_pow_challenge = unsafe { context.alloc_host_uninit::<u64>() };
-        let quotient_z_pow_bits = pow_config.quotient_z_pow_bits;
+        let quotient_z_pow_bits = security_config.quotient_z_pow_bits;
         search_pow_challenge(
             seed,
             &mut quotient_z_pow_challenge,
@@ -212,7 +212,7 @@ impl StageFourOutput {
         };
         callbacks.schedule(commit_values_at_z, stream)?;
         let mut deep_poly_alpha_pow_challenge = unsafe { context.alloc_host_uninit::<u64>() };
-        let deep_poly_alpha_pow_bits = pow_config.deep_poly_alpha_pow_bits;
+        let deep_poly_alpha_pow_bits = security_config.deep_poly_alpha_pow_bits;
         search_pow_challenge(
             seed,
             &mut deep_poly_alpha_pow_challenge,
diff --git a/gpu_prover/src/prover/stage_5.rs b/gpu_prover/src/prover/stage_5.rs
@@ -19,7 +19,7 @@ use fft::{
 use field::{Field, FieldExtension, Mersenne31Field};
 use itertools::Itertools;
 use prover::definitions::{FoldingDescription, Transcript};
-use prover::prover_stages::{ProofPowChallenges, ProofPowConfig};
+use prover::prover_stages::{ProofPowChallenges, ProofSecurityConfig};
 use prover::transcript::Seed;
 use std::iter;
 
@@ -48,13 +48,12 @@ pub(crate) struct StageFiveOutput {
 impl StageFiveOutput {
     pub fn new<'a>(
         seed: &mut HostAllocation<Seed>,
-        pow_config: &ProofPowConfig,
+        security_config: &ProofSecurityConfig,
         external_challenges: &Option<ProofPowChallenges>,
         stage_4_output: &mut StageFourOutput,
         log_domain_size: u32,
         log_lde_factor: u32,
         folding_description: &FoldingDescription,
-        num_queries: usize,
         lde_precomputations: &LdePrecomputations<impl GoodAllocator>,
         callbacks: &mut Callbacks<'a>,
         context: &ProverContext,
@@ -64,7 +63,7 @@ impl StageFiveOutput {
         let lde_factor = 1usize << log_lde_factor;
         let mut log_current_domain_size = log_domain_size;
         assert_eq!(
-            pow_config.foldings_pow_bits.len(),
+            security_config.foldings_pow_bits.len(),
             folding_description.folding_sequence.len()
         );
         let oracles_count = folding_description.folding_sequence.len() - 1;
@@ -107,7 +106,7 @@ impl StageFiveOutput {
                 &fri_oracles[i - 1].ldes
             };
             let mut pow_challenge = unsafe { context.alloc_host_uninit::<u64>() };
-            let pow_bits = pow_config.foldings_pow_bits[i];
+            let pow_bits = security_config.foldings_pow_bits[i];
             search_pow_challenge(
                 seed,
                 &mut pow_challenge,
@@ -154,7 +153,10 @@ impl StageFiveOutput {
             }
             d_challenges.free();
             let expose_all_leafs = if i == oracles_count - 1 {
-                let log_bound = num_queries.next_power_of_two().trailing_zeros();
+                let log_bound = security_config
+                    .num_queries
+                    .next_power_of_two()
+                    .trailing_zeros();
                 log_num_leafs + 1 - log_lde_factor <= log_bound
             } else {
                 false
@@ -246,7 +248,7 @@ impl StageFiveOutput {
         );
         let final_monomials = {
             let mut pow_challenge = unsafe { context.alloc_host_uninit::<u64>() };
-            let pow_bits = pow_config.foldings_pow_bits[oracles_count];
+            let pow_bits = security_config.foldings_pow_bits[oracles_count];
             search_pow_challenge(
                 seed,
                 &mut pow_challenge,
diff --git a/gpu_prover/src/tests.rs b/gpu_prover/src/tests.rs
