feat: generate sp1 stdin for aggchain proof

Author: hadjiszs

Cargo.lock

@@ -98,3 +98,5 @@ sp1-core-machine = "=4.1.2"
 sp1-sdk = "=4.1.2"
 sp1-prover = "=4.1.2"
 sp1-zkvm = "=4.1.2"
+sp1-cc-client-executor = { git = "https://github.com/succinctlabs/sp1-contract-call/", rev = "c9bdace" }
+sp1-cc-host-executor = { git = "https://github.com/succinctlabs/sp1-contract-call/", rev = "c9bdace" }

Cargo.toml

@@ -5,6 +5,9 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
+alloy.workspace = true
+alloy-primitives.workspace = true
+
 futures.workspace = true
 thiserror.workspace = true
 tower = { workspace = true, features = ["timeout"] }

crates/aggchain-proof-builder/Cargo.toml

@@ -1,3 +1,5 @@
+use crate::WitnessGeneration;
+
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
     #[error("Failed to retrieve l2 chain data")]
@@ -11,4 +13,7 @@ pub enum Error {
 
     #[error("Prover service returned the error: {0}")]
     ProverServiceError(String),
+
+    #[error("Prover witness generation error: {0}")]
+    ProverWitnessGenerationError(#[source] WitnessGeneration)
 }

crates/aggchain-proof-builder/src/error.rs

@@ -5,15 +5,23 @@ use std::sync::Arc;
 use std::task::{Context, Poll};
 
 use aggchain_proof_contracts::contracts::{
-    L1RollupConfigHashFetcher, L2LocalExitRootFetcher, L2OutputAtBlockFetcher,
+    L1RollupConfigHashFetcher, L2EVMStateSketchesFetched, L2LocalExitRootFetcher,
+    L2OutputAtBlockFetcher,
 };
 use aggchain_proof_contracts::AggchainContractsClient;
+use aggchain_proof_core::full_execution_proof::FepPublicValues;
+use aggchain_proof_core::local_exit_tree::hasher::Keccak256Hasher;
+use aggchain_proof_core::local_exit_tree::proof::LETMerkleProof;
 use aggchain_proof_core::proof::AggchainProofWitness;
+use aggchain_proof_core::{BridgeWitness, InsertedGER, L1InfoTreeLeaf};
 use aggchain_proof_types::{AggchainProofInputs, Digest};
+use alloy::eips::BlockNumberOrTag;
+use alloy_primitives::Address;
 pub use error::Error;
 use futures::{future::BoxFuture, FutureExt};
 use prover_executor::Executor;
-use sp1_sdk::{SP1Proof, SP1ProofWithPublicValues, SP1VerifyingKey};
+use sp1_sdk::network::B256;
+use sp1_sdk::{SP1Proof, SP1ProofWithPublicValues, SP1Stdin, SP1VerifyingKey};
 use tower::buffer::Buffer;
 use tower::util::BoxService;
 use tower::ServiceExt as _;
@@ -32,7 +40,7 @@ pub(crate) type ProverService = Buffer<
 /// All the data `aggchain-proof-builder` needs for the agghchain
 /// proof generation. Collected from various sources.
 pub struct AggchainProverInputs {
-    pub proof_witness: AggchainProofWitness,
+    pub sp1_stdin: SP1Stdin,
     pub start_block: u64,
     pub end_block: u64,
 }
@@ -78,6 +86,14 @@ pub struct AggchainProofBuilder<ContractsClient> {
     aggchain_proof_vkey: SP1VerifyingKey,
 }
 
+#[derive(Debug, Clone, thiserror::Error)]
+pub enum WitnessGeneration {
+    #[error("Invalid inserted GER.")]
+    InvalidInsertedGer,
+    #[error("Cannot interpret the aggregation proof as 'compressed' type.")]
+    WrongAggregationProofType,
+}
+
 impl<ContractsClient> AggchainProofBuilder<ContractsClient> {
     pub async fn new(
         config: &AggchainProofBuilderConfig,
@@ -107,37 +123,151 @@ impl<ContractsClient> AggchainProofBuilder<ContractsClient> {
     pub(crate) async fn retrieve_chain_data(
         contracts_client: Arc<ContractsClient>,
         request: AggchainProofBuilderRequest,
+        origin_network: u32,
     ) -> Result<AggchainProverInputs, Error>
     where
-        ContractsClient:
-            L2LocalExitRootFetcher + L2OutputAtBlockFetcher + L1RollupConfigHashFetcher,
+        ContractsClient: L2LocalExitRootFetcher
+            + L2OutputAtBlockFetcher
+            + L2EVMStateSketchesFetched
+            + L1RollupConfigHashFetcher,
     {
-        let _prev_local_exit_root = contracts_client
+        // Fetch from RPCs
+        let prev_local_exit_root = contracts_client
             .get_l2_local_exit_root(request.aggchain_proof_inputs.start_block - 1)
             .await
             .map_err(Error::L2ChainDataRetrievalError)?;
 
-        let _new_local_exit_root = contracts_client
+        let new_local_exit_root = contracts_client
             .get_l2_local_exit_root(request.end_block)
             .await
             .map_err(Error::L2ChainDataRetrievalError)?;
 
-        let _l2_pre_root_output_at_block = contracts_client
+        let l2_pre_root_output_at_block = contracts_client
             .get_l2_output_at_block(request.aggchain_proof_inputs.start_block - 1)
             .await
             .map_err(Error::L2ChainDataRetrievalError)?;
 
-        let _claim_root_output_at_block = contracts_client
+        let claim_root_output_at_block = contracts_client
             .get_l2_output_at_block(request.end_block)
             .await
             .map_err(Error::L2ChainDataRetrievalError)?;
 
-        let _rollup_config_hash = contracts_client
+        let rollup_config_hash = contracts_client
             .get_rollup_config_hash()
             .await
             .map_err(Error::L1ChainDataRetrievalError)?;
 
-        todo!()
+        let sketches = contracts_client
+            .get_evm_state_sketches(
+                BlockNumberOrTag::Number(request.aggchain_proof_inputs.start_block),
+                BlockNumberOrTag::Number(request.end_block),
+            )
+            .await
+            .map_err(Error::L2ChainDataRetrievalError)?;
+
+        // From the request
+        let inserted_gers: Vec<InsertedGER> = request
+            .aggchain_proof_inputs
+            .ger_leaves
+            .values()
+            .map(|claim_data| {
+                Ok(InsertedGER {
+                    proof: claim_data.inclusion_proof.clone().try_into().map_err(|_| {
+                        Error::ProverWitnessGenerationError(WitnessGeneration::InvalidInsertedGer)
+                    })?,
+                    l1_info_tree_leaf: claim_data.l1_leaf.clone().into(),
+                    l1_info_tree_index: claim_data.l1_leaf.l1_info_tree_index,
+                })
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let inserted_gers_hash_chain = inserted_gers
+            .iter()
+            .map(|inserted_ger| inserted_ger.ger())
+            .collect();
+
+        let global_indices: Vec<B256> = request
+            .aggchain_proof_inputs
+            .imported_bridge_exits
+            .iter()
+            .map(|ib| (&ib.global_index).into())
+            .collect();
+
+        let l1_info_tree_leaf: (u32, L1InfoTreeLeaf) = (
+            request
+                .aggchain_proof_inputs
+                .l1_info_tree_leaf
+                .l1_info_tree_index,
+            request.aggchain_proof_inputs.l1_info_tree_leaf.into(),
+        );
+
+        // Considered empty for now
+        let (removed_gers_hash_chain, global_indices_unset) = (vec![], vec![]);
+
+        let trusted_sequencer = Address::default(); // TODO: from config or l1
+
+        let fep = FepPublicValues {
+            l1_head: l1_info_tree_leaf.1.block_hash,
+            claim_block_num: request.end_block as u32,
+            rollup_config_hash,
+            prev_state_root: l2_pre_root_output_at_block.state_root,
+            prev_withdrawal_storage_root: l2_pre_root_output_at_block.withdrawal_storage_root,
+            prev_block_hash: l2_pre_root_output_at_block.latest_block_hash,
+            new_state_root: claim_root_output_at_block.state_root,
+            new_withdrawal_storage_root: claim_root_output_at_block.withdrawal_storage_root,
+            new_block_hash: claim_root_output_at_block.latest_block_hash,
+            trusted_sequencer,
+            signature_optimistic_mode: None, // unsupported for now
+        };
+
+        let prover_witness = AggchainProofWitness {
+            prev_local_exit_root,
+            new_local_exit_root,
+            l1_info_root: request.aggchain_proof_inputs.l1_info_tree_root_hash,
+            origin_network,
+            fep,
+            l1_info_tree_leaf,
+            l1_head_inclusion_proof: LETMerkleProof::<Keccak256Hasher> {
+                siblings: request
+                    .aggchain_proof_inputs
+                    .l1_info_tree_merkle_proof
+                    .clone(),
+            },
+            global_indices: global_indices.clone(),
+            bridge_witness: BridgeWitness {
+                inserted_gers,
+                inserted_gers_hash_chain,
+                removed_gers_hash_chain,
+                global_indices_claimed: global_indices,
+                global_indices_unset,
+                inserted_ger_sketches: sketches.inserted_ger_sketches,
+                removed_ger_sketches: sketches.removed_ger_sketches,
+                claimed_global_index_sketches: sketches.claimed_global_index_sketches,
+                unset_global_index_sketches: sketches.unset_global_index_sketches,
+                bridge_address_sketch: sketches.bridge_address_sketch,
+                new_ler_sketch: sketches.new_ler_sketch,
+            },
+        };
+
+        let SP1Proof::Compressed(aggregation_proof) = request.aggregation_proof.proof else {
+            return Err(Error::ProverWitnessGenerationError(
+                WitnessGeneration::WrongAggregationProofType,
+            ));
+        };
+
+        let aggregation_vkey = aggregation_proof.vk.clone();
+        let sp1_stdin = {
+            let mut stdin = SP1Stdin::new();
+            stdin.write(&prover_witness);
+            stdin.write_proof(*aggregation_proof, aggregation_vkey);
+            stdin
+        };
+
+        Ok(AggchainProverInputs {
+            start_block: request.aggchain_proof_inputs.start_block,
+            end_block: request.end_block,
+            sp1_stdin,
+        })
     }
 
     /// Generate aggchain proof
@@ -173,10 +303,12 @@ where
     fn call(&mut self, req: AggchainProofBuilderRequest) -> Self::Future {
         let contracts_client = self.contracts_client.clone();
         let prover = self.prover.clone();
+        let origin_network = self.network_id;
         async move {
             // Retrieve all the necessary public inputs. Combine with
             // the data provided by the agg-sender in the request.
-            let aggchain_prover_inputs = Self::retrieve_chain_data(contracts_client, req).await?;
+            let aggchain_prover_inputs =
+                Self::retrieve_chain_data(contracts_client, req, origin_network).await?;
 
             // Generate aggchain proof.
             Self::generate_aggchain_proof(prover, aggchain_prover_inputs).await

crates/aggchain-proof-builder/src/lib.rs

@@ -21,6 +21,10 @@ prover-alloy.workspace = true
 prover-utils.workspace = true
 mockall = { workspace = true, optional = true }
 
+# SP1 dependencies
+sp1-cc-client-executor.workspace = true
+sp1-cc-host-executor.workspace = true
+
 [dev-dependencies]
 mockito.workspace = true
 test-log.workspace = true

crates/aggchain-proof-contracts/Cargo.toml

@@ -1,6 +1,8 @@
-use aggchain_proof_types::Digest;
+use aggchain_proof_types::{Digest, HashChainSketches};
+use alloy::eips::BlockNumberOrTag;
 use alloy::network::Ethereum;
 use alloy::sol;
+use sp1_cc_client_executor::io::EVMStateSketch;
 
 use crate::Error;
 
@@ -60,6 +62,15 @@ pub trait L1RollupConfigHashFetcher {
     async fn get_rollup_config_hash(&self) -> Result<Digest, Error>;
 }
 
+#[async_trait::async_trait]
+pub trait L2EVMStateSketchesFetched {
+    async fn get_evm_state_sketches(
+        &self,
+        start_block: BlockNumberOrTag,
+        end_block: BlockNumberOrTag,
+    ) -> Result<AggchainStateSketches, Error>;
+}
+
 /// L2 output at block data structure.
 #[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
 pub struct L2OutputAtBlock {
@@ -69,3 +80,18 @@ pub struct L2OutputAtBlock {
     pub latest_block_hash: Digest,
     pub output_root: Digest,
 }
+
+pub struct AggchainStateSketches {
+    /// State sketches to retrieve the inserted GER hash chain.
+    pub inserted_ger_sketches: HashChainSketches,
+    /// State sketches to retrieve the removed GER hash chain.
+    pub removed_ger_sketches: HashChainSketches,
+    /// State sketches to retrieve the claims hash chain.
+    pub claimed_global_index_sketches: HashChainSketches,
+    /// State sketches to retrieve the unset hash chain.
+    pub unset_global_index_sketches: HashChainSketches,
+    /// State sketch to retrieve the bridge address.
+    pub bridge_address_sketch: EVMStateSketch,
+    /// State sketch to retrieve the new LER.
+    pub new_ler_sketch: EVMStateSketch,
+}