feat: optimize verify_proof_and_register

src/contracts_caller/gps/verify_proof_and_register.rs

@@ -1,50 +1,62 @@
 use std::str::FromStr;
 
-use aptos_sdk::move_types::value::MoveValue;
+use anyhow::ensure;
+use aptos_sdk::move_types::identifier::Identifier;
+use aptos_sdk::move_types::language_storage::ModuleId;
+use aptos_sdk::move_types::value::{serialize_values, MoveValue};
 use aptos_sdk::rest_client::aptos_api_types::MoveType;
-use log::debug;
+use aptos_sdk::rest_client::error::RestError;
+use aptos_sdk::types::transaction::{EntryFunction, TransactionPayload};
+use log::{debug, error, info};
 
 use crate::config::AppConfig;
 use crate::contracts_caller::gps::types::verify_proof_and_register::VerifyProofAndRegisterData;
-use crate::contracts_caller::transaction_helper::{get_event_from_transaction, send_tx};
+use crate::contracts_caller::transaction_helper::{build_transaction, get_event_from_transaction};
+use crate::error::CoreError::TransactionNotSucceed;
 
 pub async fn verify_proof_and_register(
     config: &AppConfig,
     data: &VerifyProofAndRegisterData,
 ) -> anyhow::Result<()> {
     let module_name = "gps_statement_verifier";
-    debug!("pre_registered_facts");
-    send_tx(
-        config,
-        "fact_registry",
-        "register_facts",
-        &vec![MoveValue::Vector(
+    let mut txs = vec![];
+
+    // Register facts transaction
+    let payload = TransactionPayload::EntryFunction(EntryFunction::new(
+        ModuleId::new(config.module_address, Identifier::new("fact_registry")?),
+        Identifier::new("register_facts")?,
+        vec![],
+        serialize_values(&vec![MoveValue::Vector(
             data.pre_registered_facts
                 .iter()
                 .map(|v| MoveValue::U256(*v))
                 .collect(),
-        )],
-    )
-    .await?;
-    debug!("prepush_task_metadata");
-    send_tx(
-        config,
-        module_name,
-        "prepush_task_metadata",
-        &vec![MoveValue::Vector(
+        )]),
+    ));
+    let tx = build_transaction(payload, &config.account, config.chain_id);
+    txs.push(("register_facts".to_string(), tx));
+
+    // Prepush task metadata transaction
+    let payload = TransactionPayload::EntryFunction(EntryFunction::new(
+        ModuleId::new(config.module_address, Identifier::new(module_name)?),
+        Identifier::new("prepush_task_metadata")?,
+        vec![],
+        serialize_values(&vec![MoveValue::Vector(
             data.task_metadata
                 .iter()
                 .map(|v| MoveValue::U256(*v))
                 .collect(),
-        )],
-    )
-    .await?;
-    debug!("prepush_data_to_verify_proof_and_register");
-    send_tx(
-        config,
-        module_name,
-        "prepush_data_to_verify_proof_and_register",
-        &vec![
+        )]),
+    ));
+    let tx = build_transaction(payload, &config.account, config.chain_id);
+    txs.push(("prepush_task_metadata".to_string(), tx));
+
+    // Prepush data to verify proof and register transaction
+    let payload = TransactionPayload::EntryFunction(EntryFunction::new(
+        ModuleId::new(config.module_address, Identifier::new(module_name)?),
+        Identifier::new("prepush_data_to_verify_proof_and_register")?,
+        vec![],
+        serialize_values(&vec![
             MoveValue::Vector(
                 data.proof_params
                     .iter()
@@ -59,23 +71,85 @@ pub async fn verify_proof_and_register(
                     .collect(),
             ),
             MoveValue::U256(data.cairo_verifier_id),
-        ],
-    )
-    .await?;
-    let mut cnt_loop = 0;
-    loop {
-        cnt_loop += 1;
+        ]),
+    ));
+    let tx = build_transaction(payload, &config.account, config.chain_id);
+    txs.push(("prepush_data_to_verify_proof_and_register".to_string(), tx));
+
+    // Verify_proof_and_register
+    for cnt_loop in 1..10 {
         debug!("verify_proof_and_register {}", cnt_loop);
-        let tx = send_tx(config, module_name, "verify_proof_and_register", &vec![]).await?;
+        let payload = TransactionPayload::EntryFunction(EntryFunction::new(
+            ModuleId::new(config.module_address, Identifier::new(module_name)?),
+            Identifier::new("verify_proof_and_register")?,
+            vec![],
+            serialize_values(&vec![]),
+        ));
+        let tx = build_transaction(payload, &config.account, config.chain_id);
+        txs.push((format!("verify_proof_and_register {}", cnt_loop), tx));
+    }
+
+    let pending_transactions = txs
+        .into_iter()
+        .map(|(name, transaction)| {
+            let client = config.client.clone();
+            tokio::spawn(async move {
+                let init_transaction = client.submit(&transaction).await?.into_inner();
+                debug!("sent {} hash = {}", name, init_transaction.hash.to_string());
+                Ok::<_, RestError>((name, init_transaction))
+            })
+        })
+        .collect::<Vec<_>>();
+
+    let mut results = Vec::with_capacity(pending_transactions.len());
+    for handle in pending_transactions {
+        results.push(handle.await??);
+    }
+
+    let results = results
+        .into_iter()
+        .map(|(name, pending_transaction)| {
+            let client = config.client.clone();
+            tokio::spawn(async move {
+                let transaction = client
+                    .wait_for_transaction(&pending_transaction)
+                    .await?
+                    .into_inner();
+                let transaction_info = transaction.transaction_info()?;
+                ensure!(
+                    transaction_info.success,
+                    TransactionNotSucceed(format!("{}; hash: {}", name, transaction_info.hash))
+                );
+                info!(
+                    "{} finished: id={}; hash={}; gas={}",
+                    name,
+                    transaction_info.version,
+                    transaction_info.hash.to_string(),
+                    transaction_info.gas_used,
+                );
+                Ok::<_, anyhow::Error>(transaction)
+            })
+        })
+        .collect::<Vec<_>>();
+
+    let mut transactions = Vec::with_capacity(results.len());
+    for handle in results {
+        transactions.push(handle.await??);
+    }
+
+    // Get the event from the last transaction
+    if let Some(last_transaction) = transactions.last() {
         let event = get_event_from_transaction(
-            &tx,
+            last_transaction,
             MoveType::from_str(&format!(
                 "{}::{}::VparFinished",
                 config.module_address, module_name
             ))?,
         );
-        if event.is_ok() {
-            break;
+
+        info!("Verify_proof_and_register {}", event.is_ok());
+        if event.is_err() {
+            error!("Some things went wrong!");
         }
     }
     Ok(())

src/contracts_caller/memory_page_fact_registry/register_continuous_page_batch.rs

@@ -55,7 +55,7 @@ pub async fn register_continuous_page_batch(
         (vec![], vec![], 0),
         |(mut chunks, mut cur_el, mut cur_value_len), (start_addr, values_len, values)| {
             let new_value_len = cur_value_len + values_len;
-            if cur_el.len() == 0 {
+            if cur_el.is_empty() {
                 cur_el.push((start_addr, values));
                 cur_value_len += values_len;
                 return (chunks, cur_el, cur_value_len);
@@ -74,7 +74,7 @@ pub async fn register_continuous_page_batch(
         },
     );
 
-    if cur_el.len() != 0 {
+    if !cur_el.is_empty() {
         chunks.push(cur_el);
     }
 

src/contracts_caller/transaction_helper.rs

@@ -1,21 +1,16 @@
 use std::str::FromStr;
 use std::time::SystemTime;
 
-use anyhow::{ensure, Error};
-use aptos_sdk::move_types::identifier::Identifier;
-use aptos_sdk::move_types::language_storage::ModuleId;
+use anyhow::Error;
 use aptos_sdk::move_types::u256::U256;
-use aptos_sdk::move_types::value::{serialize_values, MoveValue};
 use aptos_sdk::rest_client::aptos_api_types::{Event, MoveType};
 use aptos_sdk::rest_client::Transaction;
 use aptos_sdk::transaction_builder::TransactionBuilder;
 use aptos_sdk::types::chain_id::ChainId;
-use aptos_sdk::types::transaction::{EntryFunction, SignedTransaction, TransactionPayload};
+use aptos_sdk::types::transaction::{SignedTransaction, TransactionPayload};
 use aptos_sdk::types::LocalAccount;
-use log::info;
 use rand_core::OsRng;
 
-use crate::config::AppConfig;
 use crate::error::CoreError;
 
 #[inline]
@@ -95,33 +90,3 @@ pub fn get_event_from_transaction(
     };
     event.ok_or(Error::new(CoreError::NotFound))
 }
-
-pub async fn send_tx(
-    config: &AppConfig,
-    module_name: &str,
-    fn_name: &str,
-    args: &Vec<MoveValue>,
-) -> anyhow::Result<Transaction> {
-    let payload = TransactionPayload::EntryFunction(EntryFunction::new(
-        ModuleId::new(config.module_address, Identifier::new(module_name)?),
-        Identifier::new(fn_name)?,
-        vec![],
-        serialize_values(args),
-    ));
-    let tx = build_transaction(payload, &config.account, config.chain_id);
-    let transaction = config.client.submit_and_wait(&tx).await?.into_inner();
-    let transaction_info = transaction.transaction_info()?;
-
-    info!(
-        "{} finished: id={}; hash={}; gas={}",
-        fn_name,
-        transaction_info.version,
-        transaction_info.hash.to_string(),
-        transaction_info.gas_used
-    );
-    ensure!(
-        transaction_info.success,
-        CoreError::TransactionNotSucceed(transaction_info.hash.to_string())
-    );
-    Ok(transaction)
-}

tests/flow_test.rs

@@ -187,7 +187,6 @@ mod tests {
                 verify_proof_and_register(&config, &sample_vpar_data(1).unwrap())
                     .await
                     .unwrap();
-
                 Ok(())
             })
         })