feat: add support for private sp1 clusters to relayer

packages/relayer-lib/src/tx_builder/cosmos_to_eth.rs

@@ -15,8 +15,8 @@ use ibc_eureka_solidity_types::{
     sp1_ics07::sp1_ics07_tendermint,
 };
 
+use sp1_ics07_tendermint_prover::prover::Sp1Prover;
 use sp1_ics07_tendermint_utils::rpc::TendermintRpcExt;
-use sp1_sdk::Prover;
 use tendermint_rpc::HttpClient;
 
 use sp1_prover::components::SP1ProverComponents;
@@ -41,7 +41,7 @@ where
     /// The HTTP client for the Cosmos SDK.
     pub tm_client: HttpClient,
     /// SP1 prover for generating proofs.
-    pub sp1_prover: Box<dyn Prover<C>>,
+    pub sp1_prover: Sp1Prover<C>,
 }
 
 impl<P, C> TxBuilder<P, C>
@@ -50,16 +50,16 @@ where
     C: SP1ProverComponents,
 {
     /// Create a new [`TxBuilder`] instance.
-    pub const fn new(
+    pub fn new(
         ics26_address: Address,
         provider: P,
         tm_client: HttpClient,
-        sp1_prover: Box<dyn Prover<C>>,
+        sp1_prover: impl Into<Sp1Prover<C>>,
     ) -> Self {
         Self {
             ics26_router: routerInstance::new(ics26_address, provider),
             tm_client,
-            sp1_prover,
+            sp1_prover: sp1_prover.into(),
         }
     }
 
@@ -131,7 +131,7 @@ where
         let client_state = self.client_state(target_client_id).await?;
 
         inject_sp1_proof(
-            self.sp1_prover.as_ref(),
+            &self.sp1_prover,
             &mut all_msgs,
             &self.tm_client,
             latest_light_block,

packages/relayer-lib/src/utils/eth_eureka.rs

@@ -16,11 +16,12 @@ use ibc_eureka_solidity_types::{
     },
 };
 use sp1_ics07_tendermint_prover::{
-    programs::UpdateClientAndMembershipProgram, prover::SP1ICS07TendermintProver,
+    programs::UpdateClientAndMembershipProgram,
+    prover::{SP1ICS07TendermintProver, Sp1Prover},
 };
 use sp1_ics07_tendermint_utils::{light_block::LightBlockExt, rpc::TendermintRpcExt};
 use sp1_prover::components::SP1ProverComponents;
-use sp1_sdk::{HashableKey, Prover};
+use sp1_sdk::HashableKey;
 use tendermint_light_client_verifier::types::LightBlock;
 use tendermint_rpc::HttpClient;
 
@@ -103,7 +104,7 @@ pub fn src_events_to_recv_and_ack_msgs(
 /// # Errors
 /// Returns an error if the sp1 proof cannot be generated.
 pub async fn inject_sp1_proof<C: SP1ProverComponents>(
-    sp1_prover: &dyn Prover<C>,
+    sp1_prover: &Sp1Prover<C>,
     msgs: &mut [routerCalls],
     tm_client: &HttpClient,
     target_light_block: LightBlock,

packages/sp1-ics07-tendermint-prover/src/prover.rs

@@ -17,7 +17,8 @@ use ibc_proto::{
 use prost::Message;
 use sp1_prover::components::SP1ProverComponents;
 use sp1_sdk::{
-    Prover, SP1ProofMode, SP1ProofWithPublicValues, SP1ProvingKey, SP1Stdin, SP1VerifyingKey,
+    network::FulfillmentStrategy, NetworkProver, Prover, SP1ProofMode, SP1ProofWithPublicValues,
+    SP1ProvingKey, SP1Stdin, SP1VerificationError, SP1VerifyingKey,
 };
 
 // Re-export the supported zk algorithms.
@@ -31,7 +32,7 @@ where
     C: SP1ProverComponents,
 {
     /// [`sp1_sdk::ProverClient`] for generating proofs.
-    pub prover_client: &'a dyn Prover<C>,
+    pub prover_client: &'a Sp1Prover<C>,
     /// The proving key.
     pub pkey: SP1ProvingKey,
     /// The verifying key.
@@ -41,6 +42,56 @@ where
     _phantom: std::marker::PhantomData<T>,
 }
 
+/// The SP1 prover used by the [`TxBuilder`].
+#[allow(clippy::module_name_repetitions)]
+pub enum Sp1Prover<C>
+where
+    C: SP1ProverComponents,
+{
+    /// All default public cluster provers.
+    PublicCluster(Box<dyn Prover<C>>),
+    /// Private clusters can only be a [`NetworkProver`].
+    PrivateCluster(NetworkProver),
+}
+
+impl<C: SP1ProverComponents> Sp1Prover<C> {
+    /// Create a new [`Sp1Prover::PublicCluster`] from any type that implements [`Prover`].
+    pub fn new_public_cluster<T>(prover: T) -> Self
+    where
+        T: Prover<C> + 'static,
+    {
+        Self::PublicCluster(Box::new(prover))
+    }
+
+    /// Create a new [`Sp1Prover::PrivateCluster`] from a [`NetworkProver`].
+    pub const fn new_private_cluster(prover: NetworkProver) -> Self {
+        Self::PrivateCluster(prover)
+    }
+
+    /// Calls the underlying prover's `setup` method.
+    #[must_use]
+    pub fn setup(&self, elf: &[u8]) -> (SP1ProvingKey, SP1VerifyingKey) {
+        match self {
+            Self::PublicCluster(prover) => prover.setup(elf),
+            Self::PrivateCluster(prover) => prover.setup(elf),
+        }
+    }
+
+    /// Calls the underlying prover's `prove` method.
+    /// # Errors
+    /// If the underlying prover errors.
+    pub fn verify(
+        &self,
+        bundle: &SP1ProofWithPublicValues,
+        vkey: &SP1VerifyingKey,
+    ) -> Result<(), SP1VerificationError> {
+        match self {
+            Self::PublicCluster(prover) => prover.verify(bundle, vkey),
+            Self::PrivateCluster(prover) => prover.verify(bundle, vkey),
+        }
+    }
+}
+
 impl<'a, T, C> SP1ICS07TendermintProver<'a, T, C>
 where
     T: SP1Program,
@@ -49,7 +100,7 @@ where
     /// Create a new prover.
     #[must_use]
     #[tracing::instrument(skip_all)]
-    pub fn new(proof_type: SupportedZkAlgorithm, prover_client: &'a dyn Prover<C>) -> Self {
+    pub fn new(proof_type: SupportedZkAlgorithm, prover_client: &'a Sp1Prover<C>) -> Self {
         tracing::info!("Initializing SP1 ProverClient...");
         let (pkey, vkey) = prover_client.setup(T::ELF);
         tracing::info!("SP1 ProverClient initialized");
@@ -68,19 +119,27 @@ where
     #[must_use]
     pub fn prove(&self, stdin: &SP1Stdin) -> SP1ProofWithPublicValues {
         // Generate the proof. Depending on SP1_PROVER env variable, this may be a mock, local or
-        // network proof.
-        let proof = self
-            .prover_client
-            .prove(
-                &self.pkey,
-                stdin,
-                match self.proof_type {
-                    SupportedZkAlgorithm::Groth16 => SP1ProofMode::Groth16,
-                    SupportedZkAlgorithm::Plonk => SP1ProofMode::Plonk,
-                    SupportedZkAlgorithm::__Invalid => panic!("unsupported zk algorithm"),
-                },
-            )
-            .expect("proving failed");
+        let proof = match self.prover_client {
+            Sp1Prover::PublicCluster(ref prover) => prover
+                .prove(
+                    &self.pkey,
+                    stdin,
+                    match self.proof_type {
+                        SupportedZkAlgorithm::Groth16 => SP1ProofMode::Groth16,
+                        SupportedZkAlgorithm::Plonk => SP1ProofMode::Plonk,
+                        SupportedZkAlgorithm::__Invalid => panic!("unsupported zk algorithm"),
+                    },
+                )
+                .expect("proving failed"),
+            Sp1Prover::PrivateCluster(ref prover) => match self.proof_type {
+                SupportedZkAlgorithm::Groth16 => prover.prove(&self.pkey, stdin).groth16(),
+                SupportedZkAlgorithm::Plonk => prover.prove(&self.pkey, stdin).plonk(),
+                SupportedZkAlgorithm::__Invalid => panic!("unsupported zk algorithm"),
+            }
+            .strategy(FulfillmentStrategy::Reserved)
+            .run()
+            .expect("proving failed"),
+        };
 
         self.prover_client
             .verify(&proof, &self.vkey)
@@ -230,3 +289,15 @@ where
         self.prove(&stdin)
     }
 }
+
+impl<C: SP1ProverComponents> From<Box<dyn Prover<C>>> for Sp1Prover<C> {
+    fn from(prover: Box<dyn Prover<C>>) -> Self {
+        Self::PublicCluster(prover)
+    }
+}
+
+impl<C: SP1ProverComponents> From<NetworkProver> for Sp1Prover<C> {
+    fn from(prover: NetworkProver) -> Self {
+        Self::PrivateCluster(prover)
+    }
+}

programs/operator/src/runners/fixtures/membership.rs

@@ -15,7 +15,10 @@ use ibc_eureka_solidity_types::msgs::{
     ISP1Msgs::SP1Proof,
 };
 use serde::{Deserialize, Serialize};
-use sp1_ics07_tendermint_prover::{programs::MembershipProgram, prover::SP1ICS07TendermintProver};
+use sp1_ics07_tendermint_prover::{
+    programs::MembershipProgram,
+    prover::{SP1ICS07TendermintProver, Sp1Prover},
+};
 use sp1_ics07_tendermint_utils::rpc::TendermintRpcExt;
 use sp1_sdk::{HashableKey, ProverClient};
 use std::path::PathBuf;
@@ -103,7 +106,7 @@ pub async fn run_sp1_membership(
     trusted_consensus_state: SolConsensusState,
     proof_type: SupportedZkAlgorithm,
 ) -> anyhow::Result<MembershipProof> {
-    let sp1_prover = ProverClient::from_env();
+    let sp1_prover = Sp1Prover::new_public_cluster(ProverClient::from_env());
     let verify_mem_prover =
         SP1ICS07TendermintProver::<MembershipProgram, _>::new(proof_type, &sp1_prover);
 

programs/operator/src/runners/fixtures/misbehaviour.rs

@@ -13,7 +13,8 @@ use ibc_eureka_solidity_types::msgs::{
 use ibc_proto::ibc::lightclients::tendermint::v1::Misbehaviour as RawMisbehaviour;
 use serde::{Deserialize, Serialize};
 use sp1_ics07_tendermint_prover::{
-    programs::MisbehaviourProgram, prover::SP1ICS07TendermintProver,
+    programs::MisbehaviourProgram,
+    prover::{SP1ICS07TendermintProver, Sp1Prover},
 };
 use sp1_ics07_tendermint_utils::rpc::TendermintRpcExt;
 use sp1_sdk::{HashableKey, ProverClient};
@@ -43,7 +44,7 @@ pub async fn run(args: MisbehaviourCmd) -> anyhow::Result<()> {
     let misbehaviour: RawMisbehaviour = serde_json::from_slice(&misbehaviour_bz)?;
 
     let tm_rpc_client = HttpClient::from_env();
-    let sp1_prover = ProverClient::from_env();
+    let sp1_prover = Sp1Prover::new_public_cluster(ProverClient::from_env());
 
     // get light block for trusted height of header 1
     #[allow(clippy::cast_possible_truncation)]

programs/operator/src/runners/fixtures/uc_and_mem.rs

@@ -15,7 +15,8 @@ use ibc_eureka_solidity_types::msgs::{
     IUpdateClientAndMembershipMsgs::UcAndMembershipOutput,
 };
 use sp1_ics07_tendermint_prover::{
-    programs::UpdateClientAndMembershipProgram, prover::SP1ICS07TendermintProver,
+    programs::UpdateClientAndMembershipProgram,
+    prover::{SP1ICS07TendermintProver, Sp1Prover},
 };
 use sp1_ics07_tendermint_utils::{light_block::LightBlockExt, rpc::TendermintRpcExt};
 use sp1_sdk::{HashableKey, ProverClient};
@@ -31,7 +32,7 @@ pub async fn run(args: UpdateClientAndMembershipCmd) -> anyhow::Result<()> {
     );
 
     let tm_rpc_client = HttpClient::from_env();
-    let sp1_prover = ProverClient::from_env();
+    let sp1_prover = Sp1Prover::new_public_cluster(ProverClient::from_env());
     let uc_mem_prover = SP1ICS07TendermintProver::<UpdateClientAndMembershipProgram, _>::new(
         args.proof_type,
         &sp1_prover,

programs/operator/src/runners/fixtures/update_client.rs

@@ -12,7 +12,8 @@ use ibc_eureka_solidity_types::msgs::{
 };
 use serde::{Deserialize, Serialize};
 use sp1_ics07_tendermint_prover::{
-    programs::UpdateClientProgram, prover::SP1ICS07TendermintProver,
+    programs::UpdateClientProgram,
+    prover::{SP1ICS07TendermintProver, Sp1Prover},
 };
 use sp1_ics07_tendermint_utils::{light_block::LightBlockExt, rpc::TendermintRpcExt};
 use sp1_sdk::{HashableKey, ProverClient};
@@ -46,7 +47,7 @@ pub async fn run(args: UpdateClientCmd) -> anyhow::Result<()> {
     );
 
     let tm_rpc_client = HttpClient::from_env();
-    let sp1_prover = ProverClient::from_env();
+    let sp1_prover = Sp1Prover::new_public_cluster(ProverClient::from_env());
     let uc_prover =
         SP1ICS07TendermintProver::<UpdateClientProgram, _>::new(args.proof_type, &sp1_prover);
 

programs/operator/src/runners/operator.rs

@@ -9,7 +9,8 @@ use ibc_eureka_solidity_types::{
     sp1_ics07::sp1_ics07_tendermint,
 };
 use sp1_ics07_tendermint_prover::{
-    programs::UpdateClientProgram, prover::SP1ICS07TendermintProver,
+    programs::UpdateClientProgram,
+    prover::{SP1ICS07TendermintProver, Sp1Prover},
 };
 use sp1_ics07_tendermint_utils::{eth, light_block::LightBlockExt, rpc::TendermintRpcExt};
 use sp1_sdk::{utils::setup_logger, HashableKey, ProverClient};
@@ -37,7 +38,7 @@ pub async fn run(args: Args) -> anyhow::Result<()> {
     let contract_client_state = contract.clientState().call().await?;
     let tendermint_rpc_client = HttpClient::from_env();
 
-    let sp1_prover = ProverClient::from_env();
+    let sp1_prover = Sp1Prover::new_public_cluster(ProverClient::from_env());
     let prover = SP1ICS07TendermintProver::<UpdateClientProgram, _>::new(
         contract_client_state.zkAlgorithm.try_into()?,
         &sp1_prover,