feat: send state transition transaction

Author: MarcosNicolau

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

@@ -4,6 +4,7 @@ use aligned_sdk::{
 };
 use alloy::{
     eips::BlockNumberOrTag,
+    hex,
     primitives::Address,
     providers::{Provider, ProviderBuilder, WsConnect},
     rpc::types::Filter,
@@ -40,7 +41,7 @@ pub async fn send_proof_to_be_verified_on_aligned(
     .expect("Max fee to be retrieved");
 
     let aligned_verification_data =
-        aligned_sdk::sdk::submit(network, &verification_data, max_fee, wallet, 0.into())
+        aligned_sdk::sdk::submit(network, &verification_data, max_fee, wallet, nonce.into())
             .await
             .expect("Proof to be sent");
 
@@ -54,8 +55,8 @@ pub async fn wait_until_proof_is_aggregated(
     proof: &sp1_sdk::SP1ProofWithPublicValues,
     vk: &SP1VerifyingKey,
 ) -> Option<Vec<[u8; 32]>> {
-    let rpc_url = "";
-    let ws = WsConnect::new(rpc_url);
+    let ws_rpc_url = "wss://ethereum-holesky-rpc.publicnode.com";
+    let ws = WsConnect::new(ws_rpc_url);
     let provider = ProviderBuilder::new().on_ws(ws).await.unwrap();
 
     let aligned_proof_agg_address =
@@ -74,19 +75,23 @@ pub async fn wait_until_proof_is_aggregated(
         vk: vk.hash_bytes(),
         public_inputs: proof.public_values.to_vec(),
     };
-
+    
     let mut merkle_path = None;
 
     while let Some(_) = stream.next().await {
-        merkle_path = aligned_sdk::sdk::aggregation::get_merkle_path_for_proof(
+        if let Some(merkle_proof) = aligned_sdk::sdk::aggregation::get_merkle_path_for_proof(
             network.clone(),
             eth_rpc_url.clone(),
             beacon_client_url.clone(),
             None,
             &verification_data,
         )
         .await
-        .unwrap();
+        .unwrap()
+        {
+            merkle_path = Some(merkle_proof);
+            break;
+        };
     }
 
     merkle_path

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

@@ -75,6 +75,8 @@ impl DB {
         root
     }
 
+    /// Db genesis state used if a file is not provided
+    /// Its commitment is: 0x454691b501bc38536f4156a5b7d86502c49d13710d5e5b52b22c563fff4afee0
     fn initial_state() -> Vec<UserState> {
         vec![
             UserState {

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

@@ -0,0 +1,42 @@
+use std::str::FromStr;
+
+use alloy::{
+    network::EthereumWallet, primitives::Address, providers::ProviderBuilder,
+    rpc::types::TransactionReceipt, signers::local::PrivateKeySigner, sol,
+};
+
+sol!(
+    #[sol(rpc)]
+    StateTransition,
+    "abi/StateTransition.json"
+);
+
+pub async fn send_state_transition_to_chain(
+    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 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)
+            .expect("State transition address should be valid"),
+        rpc_provider,
+    );
+
+    let merkle_proof = merkle_proof.iter().map(|e| e.into()).collect();
+
+    let res = state_transition_contract
+        .updateState(public_inputs.into(), merkle_proof)
+        .send()
+        .await
+        .expect("State transition tx to not revert");
+
+    res.get_receipt().await.expect("To get receipt")
+}

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

@@ -1,11 +1,15 @@
 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 zk::{prove_state_transition, PROGRAM_ELF};
 
 mod aligned;
 mod db;
+mod eth;
 mod zk;
 
 pub async fn start_l2(
@@ -21,11 +25,13 @@ pub async fn start_l2(
     let transfers = generate_random_transfers(&db, 10);
 
     // 2. Call zkvm and pass (MerkleTree, Updates to perform)
+    println!("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");
 
     // 3. If the proving went alright, update the db and verify that the merkle root matches
     assert!(db.commitment() == initial_state_merkle_root);
@@ -56,22 +62,37 @@ 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");
 
+    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,
+        eth_rpc_url.clone(),
         beacon_client_url,
         &proof,
         &vk,
     )
-    .await;
+    .await
+    .expect("To get merkle path in last aggregated proofs");
+
+    println!("Proof has been aggregated on aligned, about to send update to chain.");
 
     // 6. Send updateState transaction to Ethereum
-    // let receipt = update_state_on_chain();
+    let receipt = send_state_transition_to_chain(
+        proof.public_values.to_vec(),
+        merkle_path,
+        eth_rpc_url.clone(),
+        "0xdC62Bf47Da2a2afD8Eb838C7004337613Af5C3b9".into(),
+        "".into(),
+    )
+    .await;
+
+    println!("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/zk.rs

@@ -1,4 +1,3 @@
-use sp1_sdk::Prover;
 use types::Transfer;
 
 use crate::db::DB;