refac(scripts): default to network prover

Author: fakedev9999

scripts/prove/bin/agg.rs

@@ -1,15 +1,18 @@
+use std::{env, fs};
+
 use alloy_primitives::{Address, B256};
 use anyhow::Result;
 use cargo_metadata::MetadataCommand;
 use clap::Parser;
 use op_succinct_client_utils::{boot::BootInfoStruct, types::u32_to_u8};
 use op_succinct_elfs::AGGREGATION_ELF;
-use op_succinct_host_utils::{fetcher::OPSuccinctDataFetcher, get_agg_proof_stdin};
+use op_succinct_host_utils::{
+    fetcher::OPSuccinctDataFetcher, get_agg_proof_stdin, network::parse_fulfillment_strategy,
+};
 use op_succinct_proof_utils::get_range_elf_embedded;
 use sp1_sdk::{
     utils, HashableKey, Prover, ProverClient, SP1Proof, SP1ProofWithPublicValues, SP1VerifyingKey,
 };
-use std::fs;
 
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about = None)]
@@ -72,7 +75,7 @@ async fn main() -> Result<()> {
 
     dotenv::from_filename(args.env_file).ok();
 
-    let prover = ProverClient::from_env();
+    let prover = ProverClient::builder().network().build();
     let fetcher = OPSuccinctDataFetcher::new_with_rollup_config().await?;
 
     let (_, vkey) = prover.setup(get_range_elf_embedded());
@@ -92,7 +95,13 @@ async fn main() -> Result<()> {
     println!("Aggregate ELF Verification Key: {:?}", agg_vk.vk.bytes32());
 
     if args.prove {
-        prover.prove(&agg_pk, &stdin).groth16().run().expect("proving failed");
+        // TODO(fakedev9999): default to plonk
+        prover
+            .prove(&agg_pk, &stdin)
+            .groth16()
+            .strategy(parse_fulfillment_strategy(env::var("AGG_PROOF_STRATEGY")?))
+            .run()
+            .expect("proving failed");
     } else {
         let (_, report) = prover
             .execute(AGGREGATION_ELF, &stdin)

scripts/prove/bin/multi.rs

@@ -1,14 +1,16 @@
+use std::{env, fs, sync::Arc, time::Instant};
+
 use anyhow::{Context, Result};
 use clap::Parser;
 use op_succinct_host_utils::{
     block_range::get_validated_block_range, fetcher::OPSuccinctDataFetcher, host::OPSuccinctHost,
-    stats::ExecutionStats, witness_generation::WitnessGenerator,
+    network::parse_fulfillment_strategy, stats::ExecutionStats,
+    witness_generation::WitnessGenerator,
 };
 use op_succinct_proof_utils::{get_range_elf_embedded, initialize_host};
 use op_succinct_prove::{execute_multi, DEFAULT_RANGE};
 use op_succinct_scripts::HostExecutorArgs;
-use sp1_sdk::{utils, ProverClient};
-use std::{fs, sync::Arc, time::Instant};
+use sp1_sdk::{utils, Prover, ProverClient};
 use tracing::debug;
 
 /// Execute the OP Succinct program for multiple blocks.
@@ -46,13 +48,19 @@ async fn main() -> Result<()> {
     // Get the stdin for the block.
     let sp1_stdin = host.witness_generator().get_sp1_stdin(witness_data)?;
 
-    let prover = ProverClient::from_env();
-
     if args.prove {
         // If the prove flag is set, generate a proof.
-        let (pk, _) = prover.setup(get_range_elf_embedded());
-        // Generate proofs in compressed mode for aggregation verification.
-        let proof = prover.prove(&pk, &sp1_stdin).compressed().run().unwrap();
+        let network_prover = ProverClient::builder().network().build();
+
+        let (pk, _) = network_prover.setup(get_range_elf_embedded());
+
+        // Generate a range proof in compressed mode for aggregation verification.
+        let proof = network_prover
+            .prove(&pk, &sp1_stdin)
+            .compressed()
+            .strategy(parse_fulfillment_strategy(env::var("RANGE_PROOF_STRATEGY")?))
+            .run()
+            .unwrap();
 
         // Create a proof directory for the chain ID if it doesn't exist.
         let proof_dir = format!("data/{}/proofs", data_fetcher.get_l2_chain_id().await.unwrap());