fix: sdk merge

Author: MarcosNicolau

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

@@ -1,6 +1,6 @@
 use aligned_sdk::{
-    core::types::{AlignedVerificationData, Signer, VerificationData, Wallet},
-    sdk::{estimate_fee, get_chain_id},
+    common::types::{AlignedVerificationData, Signer, VerificationData, Wallet},
+    verification_layer::{estimate_fee, get_chain_id},
 };
 use alloy::{
     eips::BlockNumberOrTag,
@@ -19,7 +19,9 @@ pub async fn send_proof_to_be_verified_on_aligned(
     vm_program_code: Vec<u8>,
 ) -> AlignedVerificationData {
     let proof = bincode::serialize(proof).expect("Serialize sp1 proof to binary");
-    let chain_id = get_chain_id(&config.eth_rpc_url).await.expect("To query chain id from rpc");
+    let chain_id = get_chain_id(&config.eth_rpc_url)
+        .await
+        .expect("To query chain id from rpc");
     let wallet = Wallet::decrypt_keystore(
         &config.private_key_store_path,
         &config.private_key_store_password,
@@ -29,25 +31,28 @@ pub async fn send_proof_to_be_verified_on_aligned(
 
     let verification_data = VerificationData {
         proof_generator_addr: wallet.address(),
-        proving_system: aligned_sdk::core::types::ProvingSystemId::SP1,
+        proving_system: aligned_sdk::common::types::ProvingSystemId::SP1,
         proof,
         vm_program_code: Some(vm_program_code),
         pub_input: None,
         verification_key: None,
     };
 
-    let nonce = aligned_sdk::sdk::get_nonce_from_batcher(config.network.clone(), wallet.address())
-        .await
-        .expect("Retrieve nonce from aligned batcher");
+    let nonce = aligned_sdk::verification_layer::get_nonce_from_batcher(
+        config.network.clone(),
+        wallet.address(),
+    )
+    .await
+    .expect("Retrieve nonce from aligned batcher");
 
     let max_fee = estimate_fee(
         &config.eth_rpc_url,
-        aligned_sdk::core::types::FeeEstimationType::Instant,
+        aligned_sdk::common::types::FeeEstimationType::Instant,
     )
     .await
     .expect("Max fee to be retrieved");
 
-    aligned_sdk::sdk::submit(
+    aligned_sdk::verification_layer::submit(
         config.network.clone(),
         &verification_data,
         max_fee,
@@ -79,15 +84,15 @@ pub async fn wait_until_proof_is_aggregated(
     let sub = provider.subscribe_logs(&filter).await.unwrap();
     let mut stream = sub.into_stream();
 
-    let verification_data = aligned_sdk::sdk::aggregation::AggregationModeVerificationData::SP1 {
+    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() {
-        if let Some(merkle_proof) = aligned_sdk::sdk::aggregation::get_merkle_path_for_proof(
+        if let Some(merkle_proof) = aligned_sdk::aggregation_layer::get_merkle_path_for_proof(
             config.network.clone(),
             config.eth_rpc_url.clone(),
             config.beacon_client_url.clone(),

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

@@ -2,17 +2,17 @@ use aligned::{send_proof_to_be_verified_on_aligned, wait_until_proof_is_aggregat
 use db::{generate_random_transfers, DB};
 use eth::send_state_transition_to_chain;
 use primitive_types::U256;
+use prover::{prove_state_transition, PROGRAM_ELF};
 use sp1_state_transition_program::ProgramOutput;
 use tracing::info;
-use prover::{prove_state_transition, PROGRAM_ELF};
 
 mod aligned;
 mod db;
 mod eth;
 mod prover;
 
 pub struct Config {
-    pub network: aligned_sdk::core::types::Network,
+    pub network: aligned_sdk::common::types::Network,
     pub eth_rpc_url: String,
     pub ws_eth_rpc_url: String,
     pub beacon_client_url: String,
@@ -28,7 +28,7 @@ pub async fn start_l2(config: Config) {
     loop {
         // 1. Create random transfers
         let transfers = generate_random_transfers(&db, 10);
-    
+
         // 2. Call zkvm and transfer to perform and verify
         info!("Starting prover...");
         let (mut proof, vk) = prove_state_transition(&db, transfers.clone());
@@ -37,7 +37,7 @@ pub async fn start_l2(config: Config) {
             post_state_merkle_root,
         } = proof.public_values.read::<ProgramOutput>();
         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
@@ -47,47 +47,47 @@ pub async fn start_l2(config: Config) {
                 .get(&transfer.from)
                 .expect("User must exist in state")
                 .clone();
-    
+
             let mut user_to = db
                 .user_states
                 .get(&transfer.to)
                 .expect("User must exist in state")
                 .clone();
-    
+
             user_from.balance -= transfer.amount;
             user_from.nonce += U256::one();
             user_to.balance += transfer.amount;
-    
+
             db.user_states.insert(transfer.from, user_from);
             db.user_states.insert(transfer.to, user_to);
         }
         assert!(db.commitment() == post_state_merkle_root);
-    
+
         // Fow now, in order for a proof to be aggregated, we first need to submit it via the fast mode or verification layer
         // Let's suppose that our L2 would run the prover once every 24hs and submit it on aligned
         // 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
         info!("Sending proof to aligned batcher...");
         let _ = send_proof_to_be_verified_on_aligned(&config, &proof, PROGRAM_ELF.to_vec()).await;
         info!("Proof submitted");
-    
+
         // 5. Wait until proof is aggregated
         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(&config, proof.public_values.to_vec(), merkle_path).await;
-    
+            send_state_transition_to_chain(&config, proof.public_values.to_vec(), merkle_path)
+                .await;
+
         info!(
             "State update in contracts tx hash: {:?}",
             receipt.transaction_hash
         );
-    
+
         // 7. Finally save the db to a file to be retrieved later
         db.save().unwrap();
     }
-
 }

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

@@ -1,6 +1,6 @@
 use std::env;
 
-use aligned_sdk::core::types::Network;
+use aligned_sdk::common::types::Network;
 use dotenv::dotenv;
 use l2_example::{start_l2, Config};
 use tracing_subscriber::FmtSubscriber;