feat: make agg proof mode configurable for proposers (#671)

* feat: make agg proof mode configurable for fp proposer

* refactor: default to plonk for agg proofs

This is because plonk has better trust assumptions than groth16.

* make fmt + clippy happy

Author: fakedev9999

book/fault_proofs/proposer.md

@@ -82,6 +82,7 @@ Depending on the one you choose, you must provide the corresponding environment
 | `FAST_FINALITY_MODE` | Whether to use fast finality mode | `false` |
 | `RANGE_PROOF_STRATEGY` | Proof fulfillment strategy for range proofs. Set to `hosted` to use the hosted proof strategy. | `reserved` |
 | `AGG_PROOF_STRATEGY` | Proof fulfillment strategy for aggregation proofs. Set to `hosted` to use the hosted proof strategy. | `reserved` |
+| `AGG_PROOF_MODE` | Proof mode for aggregation proofs. Set to `groth16` to use Groth16 proof type. **Note:** Changing the proof mode requires updating the `SP1_VERIFIER` address in `contracts/src/fp/OPSuccinctFaultDisputeGame.sol` to the corresponding verifier gateway contract. See [SP1 Contract Addresses](https://docs.succinct.xyz/docs/sp1/verification/contract-addresses) for verifier addresses. | `plonk` |
 | `PROPOSAL_INTERVAL_IN_BLOCKS` | Number of L2 blocks between proposals | `1800` |
 | `FETCH_INTERVAL` | Polling interval in seconds | `30` |
 | `MAX_CONCURRENT_DEFENSE_TASKS` | Maximum number of concurrently running defense tasks | `8` |

book/validity/proposer.md

@@ -44,7 +44,7 @@ Before starting the proposer, ensure you have deployed the relevant contracts an
 | `DGF_ADDRESS` | Address of the `DisputeGameFactory` contract. Note: If set, the proposer will create a dispute game with the DisputeGameFactory, rather than the `OPSuccinctL2OutputOracle`. Compatible with `OptimismPortal2`. |
 | `RANGE_PROOF_STRATEGY` | Default: `reserved`. Set to `hosted` to use hosted proof strategy. |
 | `AGG_PROOF_STRATEGY` | Default: `reserved`. Set to `hosted` to use hosted proof strategy. |
-| `AGG_PROOF_MODE` | Default: `groth16`. Set to `plonk` to use PLONK proof type. Note: The verifier gateway contract address must be updated to use PLONK proofs. |
+| `AGG_PROOF_MODE` | Default: `plonk`. Set to `groth16` to use Groth16 proof type. **Note:** Changing the proof mode requires updating the verifier gateway contract address in your L2OutputOracle contract deployment. See [SP1 Contract Addresses](https://docs.succinct.xyz/docs/sp1/verification/contract-addresses) for verifier addresses. |
 | `SUBMISSION_INTERVAL` | Default: `1800`. The number of L2 blocks that must be proven before a proof is submitted to the L1. Note: The interval used by the validity service is always >= to the `submissionInterval` configured on the L2OO contract. To allow for the validity service to configure this parameter entirely, set the `submissionInterval` in the contract to `1`. |
 | `RANGE_PROOF_INTERVAL` | Default: `1800`. The number of blocks to include in each range proof. For chains with high throughput, you need to decrease this value. |
 | `RANGE_PROOF_EVM_GAS_LIMIT` | Default: `0`. The total amount of ethereum gas allowed to be in each range proof. If 0, uses the `RANGE_PROOF_INTERVAL` instead to do a fixed number of blocks interval. NOTE: if both `RANGE_PROOF_INTERVAL` and `RANGE_PROOF_EVM_GAS_LIMIT` are set, the number of blocks to include in each range proof is determined either when the cumulative gas reaches `RANGE_PROOF_EVM_GAS_LIMIT` or the number of blocks reaches `RANGE_PROOF_INTERVAL`, whichever occurs first. |

fault-proof/src/config.rs

@@ -5,7 +5,7 @@ use alloy_transport_http::reqwest::Url;
 use anyhow::Result;
 use op_succinct_host_utils::network::parse_fulfillment_strategy;
 use serde::{Deserialize, Serialize};
-use sp1_sdk::network::FulfillmentStrategy;
+use sp1_sdk::{network::FulfillmentStrategy, SP1ProofMode};
 
 #[derive(Debug, Clone)]
 pub struct ProposerConfig {
@@ -30,6 +30,9 @@ pub struct ProposerConfig {
     /// Proof fulfillment strategy for aggregation proofs.
     pub agg_proof_strategy: FulfillmentStrategy,
 
+    /// Proof mode for aggregation proofs (Groth16 or Plonk).
+    pub agg_proof_mode: SP1ProofMode,
+
     /// The interval in blocks between proposing new games.
     pub proposal_interval_in_blocks: u64,
 
@@ -123,6 +126,15 @@ impl ProposerConfig {
             agg_proof_strategy: parse_fulfillment_strategy(
                 env::var("AGG_PROOF_STRATEGY").unwrap_or("reserved".to_string()),
             ),
+            agg_proof_mode: if env::var("AGG_PROOF_MODE")
+                .unwrap_or("plonk".to_string())
+                .to_lowercase() ==
+                "groth16"
+            {
+                SP1ProofMode::Groth16
+            } else {
+                SP1ProofMode::Plonk
+            },
             proposal_interval_in_blocks: env::var("PROPOSAL_INTERVAL_IN_BLOCKS")
                 .unwrap_or("1800".to_string())
                 .parse()?,

fault-proof/src/proposer.rs

@@ -65,6 +65,7 @@ struct SP1Prover {
     range_pk: Arc<SP1ProvingKey>,
     range_vk: Arc<SP1VerifyingKey>,
     agg_pk: Arc<SP1ProvingKey>,
+    agg_mode: SP1ProofMode,
 }
 
 /// Represents a dispute game in the on-chain game DAG.
@@ -204,6 +205,7 @@ where
                 range_pk: Arc::new(range_pk),
                 range_vk: Arc::new(range_vk),
                 agg_pk: Arc::new(agg_pk),
+                agg_mode: config.agg_proof_mode,
             },
             fetcher: fetcher.clone(),
             host,
@@ -648,14 +650,14 @@ where
             SP1ProofWithPublicValues::create_mock_proof(
                 &self.prover.agg_pk,
                 public_values,
-                SP1ProofMode::Groth16,
+                self.prover.agg_mode,
                 SP1_CIRCUIT_VERSION,
             )
         } else {
             self.prover
                 .network_prover
                 .prove(&self.prover.agg_pk, &sp1_stdin)
-                .groth16()
+                .mode(self.prover.agg_mode)
                 .strategy(self.config.agg_proof_strategy)
                 .timeout(Duration::from_secs(self.config.timeout))
                 .min_auction_period(self.config.min_auction_period)

fault-proof/tests/common/process.rs

@@ -14,7 +14,7 @@ use op_succinct_host_utils::{
 };
 use op_succinct_proof_utils::initialize_host;
 use op_succinct_signer_utils::SignerLock;
-use sp1_sdk::network::FulfillmentStrategy;
+use sp1_sdk::{network::FulfillmentStrategy, SP1ProofMode};
 use tracing::Instrument;
 
 pub async fn init_proposer(
@@ -35,6 +35,7 @@ pub async fn init_proposer(
         fast_finality_mode: false,
         range_proof_strategy: FulfillmentStrategy::Hosted,
         agg_proof_strategy: FulfillmentStrategy::Hosted,
+        agg_proof_mode: SP1ProofMode::Plonk,
         proposal_interval_in_blocks: 10, // Much smaller interval for testing
         fetch_interval: 30,              // Check more frequently in tests
         game_type,

validity/src/env.rs

@@ -98,10 +98,10 @@ pub async fn read_proposer_env() -> Result<EnvironmentConfig> {
 
     // Parse proof mode
     let agg_proof_mode =
-        if get_env_var("AGG_PROOF_MODE", Some("groth16".to_string()))?.to_lowercase() == "plonk" {
-            SP1ProofMode::Plonk
-        } else {
+        if get_env_var("AGG_PROOF_MODE", Some("plonk".to_string()))?.to_lowercase() == "groth16" {
             SP1ProofMode::Groth16
+        } else {
+            SP1ProofMode::Plonk
         };
 
     // Optional loop interval