refactor: config struct, better docs, .env examples

Author: MarcosNicolau

examples/L2/.env.example

@@ -0,0 +1,8 @@
+# .env example for holesky network
+NETWORK=holesky
+ETH_RPC_URL=https://ethereum-holesky-rpc.publicnode.com
+WS_ETH_RPC_URL=wss://ethereum-holesky-rpc.publicnode.com
+BEACON_CLIENT_URL=<YOUR_BEACON_CLIENT_URL> # This can't be a public one as we need to retrieve blobs and they don't support that method
+PRIVATE_KEY_STORE_PATH=<PATH_TO_STATE_TRANSITION_OWNER_KEYSTORE>
+PRIVATE_KEY_STORE_PASSWORD=<STATE_TRANSITION_OWNER_KEYSTORE_PASSWORD>
+STATE_TRANSITION_CONTRACT_ADDRESS=<STATE_TRANSITION_CONTRACT_ADDRESS>

examples/L2/Cargo.lock

@@ -2,13 +2,12 @@
 
 SHELL := /bin/bash
 
-run:
+run_l2:
 	@cd crates/l2 && cargo run --release --bin main
 
-print_program_id:
+generate_program_id:
 	@cd crates/l2 && cargo run --release --bin write_program_id
 	@cat ./crates/l2/programs_ids.json
 
-
 deploy_contract_holesky:
 	@. ./contracts/.env.holesky && . ./contracts/scripts/deploy.sh

examples/L2/Makefile

@@ -0,0 +1,13 @@
+RPC_URL=https://ethereum-holesky-rpc.publicnode.com
+# Initial state root of db, see in crates/l2/db.rs
+INITIAL_STATE_ROOT=0x454691b501bc38536f4156a5b7d86502c49d13710d5e5b52b22c563fff4afee0
+# You can read it from crates/l2/programs_ids.json and generate it via make generate_program_id
+PROGRAM_ID=0x5961f68d41b2798f4dab05184d8f9cda39637d28097819906033c2f10b365ab1
+# Address of the wallet you want to set as owner
+OWNER_ADDRESS=<CONTRACT_OWNER_ADDRESS>
+# Private key used to deploy the contract
+PRIVATE_KEY=<PRIVATE_KEY_TO_DEPLOY>
+# This is the aligned proof aggregator address in holesky see: 
+# https://docs.alignedlayer.com/guides/7_contract_addresses 
+ALIGNED_PROOF_AGGREGATOR_ADDRESS=0x7Eace34A8d4C4CacE633946C6F7CF4BeF3F33513
+ETHERSCAN_API_KEY=<YOUR_ETHERSCAN_API_KEY>

examples/L2/contracts/.env.holesky

@@ -18,7 +18,8 @@ aligned-sdk = { path = "../../../../batcher/aligned-sdk" }
 bincode = "1.3.3"
 futures-util = "0.3"
 tokio = "1.44"
-alloy = { version = "0.14", features = ["full", "providers"] }
+alloy = { version = "0.14", features = ["full", "signer-keystore", "providers"] }
+dotenv = "0.15"
 
 [[bin]]
 name = "main"

examples/L2/crates/l2/Cargo.toml

@@ -1,24 +1,31 @@
 use aligned_sdk::{
-    core::types::{AlignedVerificationData, Signer, SigningKey, VerificationData, Wallet},
-    sdk::estimate_fee,
+    core::types::{AlignedVerificationData, Signer, VerificationData, Wallet},
+    sdk::{estimate_fee, get_chain_id},
 };
 use alloy::{
     eips::BlockNumberOrTag,
-    hex,
     primitives::Address,
     providers::{Provider, ProviderBuilder, WsConnect},
     rpc::types::Filter,
 };
 use futures_util::StreamExt;
 use sp1_sdk::{HashableKey, SP1VerifyingKey};
 
+use crate::Config;
+
 pub async fn send_proof_to_be_verified_on_aligned(
+    config: &Config,
     proof: &sp1_sdk::SP1ProofWithPublicValues,
     vm_program_code: Vec<u8>,
-    network: aligned_sdk::core::types::Network,
-    wallet: Wallet<SigningKey>,
 ) -> AlignedVerificationData {
     let proof = bincode::serialize(proof).expect("Serialize sp1 proof to binary");
+    let chain_id = get_chain_id(&config.eth_rpc_url).await.unwrap();
+    let wallet = Wallet::decrypt_keystore(
+        &config.private_key_store_path,
+        &config.private_key_store_password,
+    )
+    .expect("Keystore to be `cast wallet` compliant")
+    .with_chain_id(chain_id);
 
     let verification_data = VerificationData {
         proof_generator_addr: wallet.address(),
@@ -29,38 +36,41 @@ pub async fn send_proof_to_be_verified_on_aligned(
         verification_key: None,
     };
 
-    let nonce = aligned_sdk::sdk::get_nonce_from_batcher(network.clone(), wallet.address())
+    let nonce = aligned_sdk::sdk::get_nonce_from_batcher(config.network.clone(), wallet.address())
         .await
         .expect("Retrieve nonce from aligned batcher");
 
     let max_fee = estimate_fee(
-        "https://ethereum-holesky-rpc.publicnode.com".into(),
+        &config.eth_rpc_url,
         aligned_sdk::core::types::FeeEstimationType::Instant,
     )
     .await
     .expect("Max fee to be retrieved");
 
-    let aligned_verification_data =
-        aligned_sdk::sdk::submit(network, &verification_data, max_fee, wallet, nonce.into())
-            .await
-            .expect("Proof to be sent");
+    let aligned_verification_data = aligned_sdk::sdk::submit(
+        config.network.clone(),
+        &verification_data,
+        max_fee,
+        wallet,
+        nonce.into(),
+    )
+    .await
+    .expect("Proof to be sent");
 
     aligned_verification_data
 }
 
 pub async fn wait_until_proof_is_aggregated(
-    network: aligned_sdk::core::types::Network,
-    eth_rpc_url: String,
-    beacon_client_url: String,
+    config: &Config,
     proof: &sp1_sdk::SP1ProofWithPublicValues,
     vk: &SP1VerifyingKey,
-) -> Option<Vec<[u8; 32]>> {
-    let ws_rpc_url = "wss://ethereum-holesky-rpc.publicnode.com";
+) -> 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(network.get_aligned_proof_agg_service_address().0);
+        Address::from(config.network.get_aligned_proof_agg_service_address().0);
 
     let filter = Filter::new()
         .address(aligned_proof_agg_address)
@@ -75,21 +85,21 @@ pub async fn wait_until_proof_is_aggregated(
         vk: vk.hash_bytes(),
         public_inputs: proof.public_values.to_vec(),
     };
-    
-    let mut merkle_path = None;
+
+    let mut merkle_path = vec![];
 
     while let Some(_) = stream.next().await {
         if let Some(merkle_proof) = aligned_sdk::sdk::aggregation::get_merkle_path_for_proof(
-            network.clone(),
-            eth_rpc_url.clone(),
-            beacon_client_url.clone(),
+            config.network.clone(),
+            config.eth_rpc_url.clone(),
+            config.beacon_client_url.clone(),
             None,
             &verification_data,
         )
         .await
-        .unwrap()
+        .expect("Get merkle path for proof")
         {
-            merkle_path = Some(merkle_proof);
+            merkle_path = merkle_proof;
             break;
         };
     }

examples/L2/crates/l2/src/aligned.rs

@@ -2,30 +2,33 @@ use std::str::FromStr;
 
 use alloy::{
     network::EthereumWallet, primitives::Address, providers::ProviderBuilder,
-    rpc::types::TransactionReceipt, signers::local::PrivateKeySigner, sol,
+    rpc::types::TransactionReceipt, signers::local::LocalSigner, sol,
 };
 
+use crate::Config;
+
 sol!(
     #[sol(rpc)]
     StateTransition,
     "abi/StateTransition.json"
 );
 
 pub async fn send_state_transition_to_chain(
+    config: &Config,
     public_inputs: Vec<u8>,
     merkle_proof: Vec<[u8; 32]>,
-    eth_rpc_url: String,
-    state_transition_address: String,
-    private_key: String,
 ) -> TransactionReceipt {
-    let rpc_url = eth_rpc_url.parse().expect("RPC URL should be valid");
-    let signer = PrivateKeySigner::from_str(&private_key)
-        .expect("Keystore signer should be `cast wallet` compliant");
+    let rpc_url = config.eth_rpc_url.parse().expect("RPC URL should be valid");
+    let signer = LocalSigner::decrypt_keystore(
+        &config.private_key_store_path,
+        &config.private_key_store_password,
+    )
+    .expect("Keystore signer should be `cast wallet` compliant");
     let wallet = EthereumWallet::from(signer);
 
     let rpc_provider = ProviderBuilder::new().wallet(wallet).on_http(rpc_url);
     let state_transition_contract = StateTransition::new(
-        Address::from_str(&state_transition_address)
+        Address::from_str(&config.state_transition_contract_address)
             .expect("State transition address should be valid"),
         rpc_provider,
     );

examples/L2/crates/l2/src/eth.rs

@@ -1,40 +1,45 @@
 use aligned::{send_proof_to_be_verified_on_aligned, wait_until_proof_is_aggregated};
-use alloy::hex::hex;
 use db::{generate_random_transfers, DB};
 use eth::send_state_transition_to_chain;
-use lambdaworks_crypto::merkle_tree::merkle::MerkleTree;
 use primitive_types::U256;
 use sp1_state_transition_program::ProgramOutput;
+use tracing::info;
 use zk::{prove_state_transition, PROGRAM_ELF};
 
 mod aligned;
 mod db;
 mod eth;
 mod zk;
 
-pub async fn start_l2(
-    network: aligned_sdk::core::types::Network,
-    eth_rpc_url: String,
-    beacon_client_url: String,
-    wallet: aligned_sdk::core::types::Wallet<aligned_sdk::core::types::SigningKey>,
-) {
+pub struct Config {
+    pub network: aligned_sdk::core::types::Network,
+    pub eth_rpc_url: String,
+    pub ws_eth_rpc_url: String,
+    pub beacon_client_url: String,
+    pub private_key_store_path: String,
+    pub private_key_store_password: String,
+    pub state_transition_contract_address: String,
+}
+
+pub async fn start_l2(config: Config) {
     // 0. Load merkle tree file, if not created, create initial state
     let mut db = DB::new("./db".to_string());
 
     // 1. Create random transfers
     let transfers = generate_random_transfers(&db, 10);
 
-    // 2. Call zkvm and pass (MerkleTree, Updates to perform)
-    println!("Staring prover");
+    // 2. Call zkvm and transfer to perform and verify
+    info!("Staring prover");
     let (mut proof, vk) = prove_state_transition(&db, transfers.clone());
     let ProgramOutput {
         initial_state_merkle_root,
         post_state_merkle_root,
     } = proof.public_values.read::<ProgramOutput>();
-    println!("Prover finish");
+    info!("Prover finish");
 
     // 3. If the proving went alright, update the db and verify that the merkle root matches
     assert!(db.commitment() == initial_state_merkle_root);
+    // Note: we don't have to verify that the user has enough balance, as the prover already validates it
     for transfer in transfers {
         let mut user_from = db
             .user_states
@@ -62,37 +67,20 @@ pub async fn start_l2(
     // Once aligned aggregates the proof we will be notified and we'll send the new state commitment on chain
 
     // 4. Send the proof to aligned and wait for verification
-    println!("Sending proof to aligned batcher");
-    let _ =
-        send_proof_to_be_verified_on_aligned(&proof, PROGRAM_ELF.to_vec(), network.clone(), wallet)
-            .await;
-    println!("Proof submitted");
+    info!("Sending proof to aligned batcher");
+    let _ = send_proof_to_be_verified_on_aligned(&config, &proof, PROGRAM_ELF.to_vec()).await;
+    info!("Proof submitted");
 
-    println!("Waiting until is proof is aggregated");
     // 5. Wait until proof is aggregated
-    let merkle_path = wait_until_proof_is_aggregated(
-        network.clone(),
-        eth_rpc_url.clone(),
-        beacon_client_url,
-        &proof,
-        &vk,
-    )
-    .await
-    .expect("To get merkle path in last aggregated proofs");
-
-    println!("Proof has been aggregated on aligned, about to send update to chain.");
+    info!("Waiting until is proof is aggregated");
+    let merkle_path = wait_until_proof_is_aggregated(&config, &proof, &vk).await;
+    info!("Proof has been aggregated on aligned, about to send update to chain.");
 
     // 6. Send updateState transaction to Ethereum
-    let receipt = send_state_transition_to_chain(
-        proof.public_values.to_vec(),
-        merkle_path,
-        eth_rpc_url.clone(),
-        "0xdC62Bf47Da2a2afD8Eb838C7004337613Af5C3b9".into(),
-        "".into(),
-    )
-    .await;
+    let receipt =
+        send_state_transition_to_chain(&config, proof.public_values.to_vec(), merkle_path).await;
 
-    println!("State update in contracts tx receipt {:?}", receipt);
+    info!("State update in contracts tx receipt {:?}", receipt);
 
     // Finally save the db to a file to be retrieved later
     db.save().unwrap();

examples/L2/crates/l2/src/lib.rs

@@ -0,0 +1,36 @@
+use std::env;
+
+use aligned_sdk::core::types::Network;
+use dotenv::dotenv;
+use l2_example::{start_l2, Config};
+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");
+
+    dotenv().ok();
+
+    let network = match env::var("NETWORK").expect("NETWORK not set").as_str() {
+        "holesky" => Network::Holesky,
+        "holesky-stage" => Network::HoleskyStage,
+        "devnet" => Network::Devnet,
+        _ => panic!("Invalid network, possible values are: holesky, holesky-stage, devnet"),
+    };
+
+    let config = Config {
+        network,
+        eth_rpc_url: env::var("ETH_RPC_URL").expect("ETH_RPC_URL not set"),
+        ws_eth_rpc_url: env::var("WS_ETH_RPC_URL").expect("WS_ETH_RPC_URL not set"),
+        beacon_client_url: env::var("BEACON_CLIENT_URL").expect("BEACON_CLIENT_URL not set"),
+        private_key_store_path: env::var("PRIVATE_KEY_STORE_PATH")
+            .expect("PRIVATE_KEY_STORE_PATH not set"),
+        private_key_store_password: env::var("PRIVATE_KEY_STORE_PASSWORD")
+            .expect("PRIVATE_KEY_STORE_PASSWORD not set"),
+        state_transition_contract_address: env::var("STATE_TRANSITION_CONTRACT_ADDRESS")
+            .expect("STATE_TRANSITION_CONTRACT_ADDRESS not set"),
+    };
+
+    start_l2(config).await;
+}

examples/L2/crates/l2/src/main.rs

@@ -22,7 +22,7 @@ pub fn prove_state_transition(
         .prove(&pk, &stdin)
         .compressed()
         .run()
-        .expect("Prover to run fine");
+        .expect("Prover to run well");
 
     (proof, vk)
 }