fix: tx

Cargo.toml

@@ -22,9 +22,7 @@ tokio = { version = "1.39.3", features = ["macros", "rt-multi-thread"] }
 url = { version = "2.4.0", features = ["serde"] }
 
 [dev-dependencies]
-aptos-testcontainer = { git = "https://github.com/sota-zk-labs/aptos-testcontainer.git", tag = "v0.1.0", features = [
-  "testing",
-] }
+aptos-testcontainer = { version = "0.1.2", features = ["testing"] }
 
 [patch.crates-io]
 merlin = { git = "https://github.com/aptos-labs/merlin" }

src/contracts_caller/gps/verify_proof_and_register.rs

@@ -7,12 +7,12 @@ use aptos_sdk::move_types::value::{serialize_values, MoveValue};
 use aptos_sdk::rest_client::aptos_api_types::MoveType;
 use aptos_sdk::rest_client::error::RestError;
 use aptos_sdk::types::transaction::{EntryFunction, TransactionPayload};
-use log::{debug, error, info};
+use log::{debug, info};
 
 use crate::config::AppConfig;
 use crate::contracts_caller::gps::types::verify_proof_and_register::VerifyProofAndRegisterData;
 use crate::contracts_caller::transaction_helper::{build_transaction, get_event_from_transaction};
-use crate::error::CoreError::TransactionNotSucceed;
+use crate::error::CoreError::{FlowNotFinished, TransactionNotSucceed};
 
 pub async fn verify_proof_and_register(
     config: &AppConfig,
@@ -115,42 +115,43 @@ pub async fn verify_proof_and_register(
                     .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)
+                Ok::<_, anyhow::Error>((name, transaction))
             })
         })
         .collect::<Vec<_>>();
 
     let mut transactions = Vec::with_capacity(results.len());
     for handle in results {
-        transactions.push(handle.await??);
+        let (name, transaction) = handle.await??;
+        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,
+        );
+        transactions.push(transaction);
     }
 
+    let last_transaction = transactions.last().unwrap();
+
     // Get the event from the last transaction
-    if let Some(last_transaction) = transactions.last() {
-        let event = get_event_from_transaction(
-            last_transaction,
-            MoveType::from_str(&format!(
-                "{}::{}::VparFinished",
-                config.module_address, module_name
-            ))?,
-        );
+    let event = get_event_from_transaction(
+        last_transaction,
+        MoveType::from_str(&format!(
+            "{}::{}::VparFinished",
+            config.module_address, module_name
+        ))?,
+    );
+    ensure!(
+        event.is_ok(),
+        FlowNotFinished("verify_proof_and_register".to_string())
+    );
 
-        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_memory_page.rs

@@ -32,7 +32,6 @@ pub async fn register_continuous_memory_page(
             MoveValue::Vector(values),
             MoveValue::U256(U256::from_str(&data.z)?),
             MoveValue::U256(U256::from_str(&data.alpha)?),
-            MoveValue::U256(U256::from_str(&data.prime)?),
         ]),
     ));
     let tx = build_transaction(payload, &config.account, config.chain_id);

src/contracts_caller/memory_page_fact_registry/register_continuous_page_batch.rs

@@ -23,15 +23,11 @@ pub async fn register_continuous_page_batch(
 ) -> anyhow::Result<()> {
     let ContinuousMemoryPage {
         z,
-        alpha,
-        prime,
-        values: _,
-        start_addr: _,
+        alpha, ..
     } = data.memory_page_entries.first().unwrap();
 
     let z = MoveValue::U256(U256::from_str(z)?);
     let alpha = MoveValue::U256(U256::from_str(alpha)?);
-    let prime = MoveValue::U256(U256::from_str(prime)?);
 
     let mut converted_data = data
         .memory_page_entries
@@ -80,7 +76,6 @@ pub async fn register_continuous_page_batch(
 
     let txs = chunks.into_iter().enumerate().map(|(i, chunk)| {
         let (chunk_start_addr, chunk_values): (Vec<_>, Vec<_>) = chunk.into_iter().unzip();
-
         let payload = TransactionPayload::EntryFunction(EntryFunction::new(
             ModuleId::new(
                 config.module_address,
@@ -93,7 +88,6 @@ pub async fn register_continuous_page_batch(
                 MoveValue::Vector(chunk_values),
                 z.clone(),
                 alpha.clone(),
-                prime.clone(),
             ]),
         ));
         let tx = build_transaction(payload, &config.account, config.chain_id);

src/error.rs

@@ -19,6 +19,9 @@ pub enum CoreError {
     #[error("transaction not succeed {0}")]
     TransactionNotSucceed(String),
 
+    #[error("flow not finished {0}")]
+    FlowNotFinished(String),
+
     #[error("not found")]
     NotFound,