feat: separate proving from verification in two commands

Author: MarcosNicolau

examples/l2/Cargo.lock

@@ -1,6 +1,6 @@
 [workspace]
 resolver = "2"
-members = ["crates/l2", "crates/types"]
+members = ["./cmd/", "crates/l2", "crates/types"]
 
 [workspace.package]
 version = "0.1.0"

examples/l2/Cargo.toml

@@ -2,6 +2,8 @@
 
 SHELL := /bin/bash
 
+
+__CONFIG__:
 gen_devnet_owner_wallet:
 	rm -f ./contract-owner.keystore.json
 	cast wallet import -k . contract-owner.keystore.json --private-key 0x47e179ec197488593b187f80a00eb0da91f1b9d0b13f8733639f19c30a34926a --unsafe-password "<!w5Y%In94Vw"
@@ -19,9 +21,6 @@ gen_env_l2_holesky:
 gen_env_l2_devnet:
 	@cp .env.devnet .env
 
-run_l2:
-	@cd crates/l2 && cargo run --release --bin main
-
 generate_program_id:
 	@cd crates/l2 && cargo run --release --bin write_program_id
 	@cat ./crates/l2/programs_ids.json
@@ -37,3 +36,10 @@ deploy_contract:
 
 clean_db:
 	rm -f examples/l2/crates/l2/db
+
+__L2_PROGRAM__:
+update_state_transition:
+	@cd cmd && cargo run --release --bin update_state_transition
+
+verify_state_transition_on_chain:
+	@cd cmd && cargo run --release --bin verify_state_transition_on_chain

examples/l2/Makefile

@@ -0,0 +1,27 @@
+[package]
+name = "l2_cmd"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+serde = { workspace = true }
+serde_json = { workspace = true }
+tracing = { version = "0.1", features = ["log"] }
+tracing-subscriber = { version = "0.3.0", features = ["env-filter"] }
+bincode = "1.3.3"
+tokio = "1.44"
+dotenv = "0.15"
+l2 = { path = "../crates/l2/" }
+aligned-sdk = { path = "../../../batcher/aligned-sdk" }
+
+[lib]
+name = "l2_cmd"
+path = "./lib.rs"
+
+[[bin]]
+name = "update_state_transition"
+path = "./update_state_transition.rs"
+
+[[bin]]
+name = "verify_state_transition_on_chain"
+path = "./verify_state_transition_on_chain.rs"

examples/l2/cmd/Cargo.toml

@@ -0,0 +1 @@
+pub mod utils;

examples/l2/cmd/lib.rs

@@ -0,0 +1,24 @@
+use std::{fs::File, io::Write};
+
+use l2::l2::L2;
+use tracing::info;
+use tracing_subscriber::FmtSubscriber;
+
+use l2_cmd::utils::load_config;
+
+#[tokio::main]
+async fn main() {
+    let subscriber = FmtSubscriber::builder().finish();
+    tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
+
+    let config = load_config();
+    let mut l2 = L2::new(config);
+
+    let proof = l2.update_state_transition().await;
+    info!("Serializing and saving proof on disk to be verified later on chain");
+
+    let proof_bytes = bincode::serialize(&proof).unwrap();
+    let mut file = File::create("./proof.bin").expect("Unable to create file");
+    file.write(&proof_bytes).unwrap();
+    info!("Proof stored in disk, in the next 24hs it will be aggregated and verified and aligned, so you should retrieve its status later");
+}

examples/l2/cmd/update_state_transition.rs

@@ -2,14 +2,9 @@ use std::env;
 
 use aligned_sdk::common::types::Network;
 use dotenv::dotenv;
-use l2_example::{config::Config, l2::start_l2};
-use tracing_subscriber::FmtSubscriber;
-
-#[tokio::main]
-async fn main() {
-    let subscriber = FmtSubscriber::builder().finish();
-    tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
+use l2::config::Config;
 
+pub fn load_config() -> Config {
     dotenv().ok();
 
     let network = match env::var("NETWORK").expect("NETWORK not set").as_str() {
@@ -30,7 +25,8 @@ async fn main() {
             .expect("PRIVATE_KEY_STORE_PASSWORD not set"),
         state_transition_contract_address: env::var("STATE_TRANSITION_CONTRACT_ADDRESS")
             .expect("STATE_TRANSITION_CONTRACT_ADDRESS not set"),
+        db_path: Some("./db".to_string()),
     };
 
-    start_l2(config).await;
+    config
 }

examples/l2/crates/l2/src/main.rs examples/l2/cmd/utils.rsexamples/l2/crates/l2/src/main.rs renamed to examples/l2/cmd/utils.rs

@@ -0,0 +1,20 @@
+use l2::l2::L2;
+use tracing::info;
+use tracing_subscriber::FmtSubscriber;
+
+use l2_cmd::utils::load_config;
+
+#[tokio::main]
+async fn main() {
+    let subscriber = FmtSubscriber::builder().finish();
+    tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
+
+    let config = load_config();
+    let mut l2 = L2::new(config);
+
+    info!("Loading proof from disk to verify on chain");
+
+    let proof_bytes = std::fs::read("./proof.bin").unwrap();
+    let proof = bincode::deserialize(&proof_bytes).unwrap();
+    l2.verify_state_transition(proof).await;
+}

examples/l2/cmd/verify_state_transition_on_chain.rs

@@ -1,5 +1,5 @@
 [package]
-name = "l2_example"
+name = "l2"
 version = "0.1.0"
 edition = "2021"
 
@@ -21,10 +21,6 @@ tokio = "1.44"
 alloy = { version = "0.14", features = ["full", "signer-keystore", "providers"] }
 dotenv = "0.15"
 
-[[bin]]
-name = "main"
-path = "./src/main.rs"
-
 [[bin]]
 name = "write_program_id"
 path = "./zkvm_programs/bin/write_program_ids.rs"

examples/l2/crates/l2/Cargo.toml

@@ -1,14 +1,8 @@
 use aligned_sdk::{
+    aggregation_layer::ProofStatus,
     common::types::{AlignedVerificationData, Signer, VerificationData, Wallet},
     verification_layer::{estimate_fee, get_chain_id},
 };
-use alloy::{
-    eips::BlockNumberOrTag,
-    primitives::Address,
-    providers::{Provider, ProviderBuilder, WsConnect},
-    rpc::types::Filter,
-};
-use futures_util::StreamExt;
 use sp1_sdk::{HashableKey, SP1VerifyingKey};
 
 use crate::config::Config;
@@ -63,58 +57,45 @@ pub async fn send_proof_to_be_verified_on_aligned(
     .expect("Proof to be sent")
 }
 
-pub async fn wait_until_proof_is_aggregated(
+pub async fn check_proof_proof_aggregation_status(
     config: &Config,
     proof: &sp1_sdk::SP1ProofWithPublicValues,
     vk: &SP1VerifyingKey,
-) -> Vec<[u8; 32]> {
-    let ws_rpc_url = &config.ws_eth_rpc_url;
-    let ws = WsConnect::new(ws_rpc_url);
-    let provider = ProviderBuilder::new().on_ws(ws).await.unwrap();
-
-    let aligned_proof_agg_address =
-        Address::from(config.network.get_aligned_proof_agg_service_address().0);
-
-    let filter = Filter::new()
-        .address(aligned_proof_agg_address)
-        .event("AggregatedProofVerified(bytes32,bytes32)")
-        .from_block(BlockNumberOrTag::Latest);
-
-    // Subscribe to logs.
-    let sub = provider.subscribe_logs(&filter).await.unwrap();
-    let mut stream = sub.into_stream();
-
+) -> ProofStatus {
     let verification_data = aligned_sdk::aggregation_layer::AggregationModeVerificationData::SP1 {
         vk: vk.hash_bytes(),
         public_inputs: proof.public_values.to_vec(),
     };
 
-    let mut merkle_path = vec![];
-
-    while stream.next().await.is_some() {
-        let proof_status = aligned_sdk::aggregation_layer::check_proof_verification(
-            &verification_data,
-            config.network.clone(),
-            config.eth_rpc_url.clone(),
-            config.beacon_client_url.clone(),
-            None,
-        )
-        .await
-        .expect("Get merkle path for proof");
+    let proof_status = aligned_sdk::aggregation_layer::check_proof_verification(
+        &verification_data,
+        config.network.clone(),
+        config.eth_rpc_url.clone(),
+        config.beacon_client_url.clone(),
+        // By default it looks back 24 hours
+        None,
+    )
+    .await
+    .expect("Get merkle path for proof");
 
-        match proof_status {
-            aligned_sdk::aggregation_layer::ProofStatus::Verified {
-                merkle_path: path, ..
-            } => {
-                merkle_path = path;
-                break;
-            }
-            aligned_sdk::aggregation_layer::ProofStatus::Invalid => {
-                panic!("Proof did pass merkle root verification")
-            }
-            aligned_sdk::aggregation_layer::ProofStatus::NotFound => continue,
-        }
-    }
+    proof_status
 
-    merkle_path
+    // match proof_status {
+    //     aligned_sdk::aggregation_layer::ProofStatus::Verified {
+    //         merkle_root,
+    //         merkle_path,
+    //     } => {
+    //         info!(
+    //             "Proof aggregated in aggregation with merkle root {:?}",
+    //             hex::encode(merkle_root)
+    //         );
+    //         merkle_path
+    //     }
+    //     aligned_sdk::aggregation_layer::ProofStatus::Invalid => {
+    //         panic!("Proof did pass merkle root verification");
+    //     }
+    //     aligned_sdk::aggregation_layer::ProofStatus::NotFound => {
+    //         panic!("Proof not found in the last 24 hours logs");
+    //     }
+    // }
 }