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,150 @@ 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 prev_l2_block_sketch = contracts_client
+            .get_prev_l2_block_sketch(BlockNumberOrTag::Number(
+                request.aggchain_proof_inputs.start_block,
+            ))
+            .await
+            .map_err(Error::L2ChainDataRetrievalError)?;
+
+        let new_l2_block_sketch = contracts_client
+            .get_new_l2_block_sketch(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,
+                global_indices_claimed: global_indices,
+                global_indices_unset,
+                raw_inserted_gers: inserted_gers_hash_chain,
+                removed_gers: removed_gers_hash_chain,
+                prev_l2_block_sketch,
+                new_l2_block_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 +302,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 alloy::eips::BlockNumberOrTag;
 use alloy::network::Ethereum;
 use alloy::sol;
+use sp1_cc_client_executor::io::EVMStateSketch;
 
 use crate::Error;
 
@@ -60,6 +62,19 @@ pub trait L1RollupConfigHashFetcher {
     async fn get_rollup_config_hash(&self) -> Result<Digest, Error>;
 }
 
+#[async_trait::async_trait]
+pub trait L2EVMStateSketchesFetched {
+    async fn get_prev_l2_block_sketch(
+        &self,
+        prev_l2_block: BlockNumberOrTag,
+    ) -> Result<EVMStateSketch, Error>;
+
+    async fn get_new_l2_block_sketch(
+        &self,
+        new_l2_block: BlockNumberOrTag,
+    ) -> Result<EVMStateSketch, Error>;
+}
+
 /// L2 output at block data structure.
 #[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
 pub struct L2OutputAtBlock {

crates/aggchain-proof-contracts/src/contracts.rs

@@ -9,12 +9,20 @@ use std::str::FromStr;
 use std::sync::Arc;
 
 use aggchain_proof_types::Digest;
-use alloy::primitives::B256;
+use alloy::eips::BlockNumberOrTag;
+use alloy::network::AnyNetwork;
+use alloy::primitives::{Address, B256};
+use alloy::providers::RootProvider;
+use contracts::L2EVMStateSketchesFetched;
 use jsonrpsee::core::client::ClientT;
 use jsonrpsee::http_client::HttpClient;
 use jsonrpsee::rpc_params;
 use prover_alloy::{build_alloy_fill_provider, AlloyFillProvider};
+use sp1_cc_client_executor::io::EVMStateSketch;
+use sp1_cc_client_executor::ContractInput;
+use sp1_cc_host_executor::HostExecutor;
 use tracing::info;
+use url::Url;
 
 use crate::config::AggchainProofContractsConfig;
 use crate::contracts::{
@@ -27,7 +35,10 @@ pub use crate::error::Error;
 /// `AggchainContractsClient` is a trait for interacting with the smart
 /// contracts relevant for the aggchain prover.
 pub trait AggchainContractsClient:
-    L2LocalExitRootFetcher + L2OutputAtBlockFetcher + L1RollupConfigHashFetcher
+    L2LocalExitRootFetcher
+    + L2OutputAtBlockFetcher
+    + L1RollupConfigHashFetcher
+    + L2EVMStateSketchesFetched
 {
 }
 
@@ -41,6 +52,9 @@ pub struct AggchainContractsRpcClient<RpcProvider> {
     /// L2 rpc execution layer client.
     _l2_el_client: Arc<RpcProvider>,
 
+    /// L2 rpc execution layer client.
+    l2_archive_endpoint: Url, // TODO: put directly RootProvider
+
     /// L2 rpc consensus layer client (rollup node).
     l2_cl_client: Arc<HttpClient>,
 
@@ -105,6 +119,45 @@ where
     }
 }
 
+#[async_trait::async_trait]
+impl<RpcProvider> L2EVMStateSketchesFetched for AggchainContractsRpcClient<RpcProvider>
+where
+    RpcProvider: alloy::providers::Provider + Send + Sync,
+{
+    async fn get_prev_l2_block_sketch(
+        &self,
+        prev_l2_block: BlockNumberOrTag,
+    ) -> Result<EVMStateSketch, Error> {
+        let root_provider = RootProvider::<AnyNetwork>::new_http(self.l2_archive_endpoint.clone());
+        let mut executor: HostExecutor<RootProvider<AnyNetwork>> =
+            HostExecutor::new(root_provider, prev_l2_block)
+                .await
+                .expect("d");
+
+        let _ = executor
+            .execute(ContractInput::new_call(
+                Address::default(), // should be ger
+                Address::default(),
+                GlobalExitRootManagerL2SovereignChain::bridgeAddressCall {},
+            ))
+            .await
+            .expect("todo");
+
+        //let bridge_address_sketch = executor.finalize().await.expect("todo");
+
+        let prev_l2_block_sketch: EVMStateSketch = todo!();
+
+        Ok(prev_l2_block_sketch)
+    }
+
+    async fn get_new_l2_block_sketch(
+        &self,
+        _new_l2_block: BlockNumberOrTag,
+    ) -> Result<EVMStateSketch, Error> {
+        todo!()
+    }
+}
+
 impl<RpcProvider> AggchainContractsRpcClient<RpcProvider> {
     fn parse_l2_output_root(json: serde_json::Value) -> Result<L2OutputAtBlock, Error> {
         fn parse_hash(json: &serde_json::Value, field: &str) -> Result<Digest, Error> {
@@ -204,6 +257,7 @@ impl AggchainContractsRpcClient<AlloyFillProvider> {
             l2_cl_client,
             polygon_zkevm_bridge_v2,
             aggchain_fep,
+            l2_archive_endpoint: config.l2_execution_layer_rpc_endpoint.clone(),
         })
     }
 }