chore: format code

Cargo.toml

@@ -8,6 +8,7 @@ anyhow = { version = "1.0.71" }
 aptos-sdk = { git = "https://github.com/aptos-labs/aptos-core", branch = "mainnet" }
 async-trait = { version = "0.1.81" }
 dotenv = { version = "0.15.0" }
+itertools = "0.10.5"
 lazy_static = "1.4.0"
 log = { version = "0.4.22" }
 once_cell = { version = "1.19.0" }

src/bin/main.rs

@@ -1,10 +1,9 @@
-use log::info;
+use log::{error, info};
 
 use verifier_onchain_services::config::{AppConfig, EnvConfig};
+use verifier_onchain_services::contracts_caller::memory_page_fact_registry::sample_register_memory::sample_register_continuous_page_batch;
 use verifier_onchain_services::contracts_caller::verify_fri::sample_verify_fri_input::sample_verify_fri_input;
-use verifier_onchain_services::contracts_caller::verify_fri::verify_fri::verify_fri;
 use verifier_onchain_services::contracts_caller::verify_merkle::sample_verify_merkle_input::sample_verify_merkle_input;
-use verifier_onchain_services::contracts_caller::verify_merkle::verify_merkle::verify_merkle;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
@@ -18,34 +17,18 @@ async fn main() -> anyhow::Result<()> {
     config.account.set_sequence_number(sequence_number);
 
     for i in 1..4 {
-        let (merkle_view, initial_merkle_queue, height, expected_root) =
-            sample_verify_merkle_input(i)?;
-        verify_merkle(
-            &config,
-            merkle_view,
-            initial_merkle_queue,
-            height,
-            expected_root,
-        )
-        .await?;
+        sample_verify_merkle_input(&config, i).await?;
         info!("Verify Merkle {} success", i);
     }
 
     for i in 1..8 {
-        let (fri_verify_input, proof, fri_queue, evaluation_point, fri_step_size, expected_root) =
-            sample_verify_fri_input(i)?;
-        verify_fri(
-            &config,
-            fri_verify_input,
-            proof,
-            fri_queue,
-            evaluation_point,
-            fri_step_size,
-            expected_root,
-        )
-        .await?;
+        sample_verify_fri_input(&config, i).await?;
         info!("Verify FRI {} success", i);
     }
 
+    if !sample_register_continuous_page_batch(&config).await? {
+        error!("something went wrong!")
+    }
+
     Ok(())
-}
+}

src/contracts_caller/memory_page_fact_registry/mod.rs

@@ -1,3 +1,4 @@
+pub mod register_continuous_memorypage;
 pub mod register_continuous_page_batch;
-pub mod register_memory;
+pub mod sample_register_memory;
 pub mod types;

src/contracts_caller/memory_page_fact_registry/register_continuous_memorypage.rs

@@ -0,0 +1,45 @@
+use crate::config::AppConfig;
+use crate::contracts_caller::memory_page_fact_registry::types::register_continuous_memorypage::ContinuousMemorypage;
+use crate::contracts_caller::transaction_helper::build_transaction;
+use aptos_sdk::move_types::identifier::Identifier;
+use aptos_sdk::move_types::language_storage::ModuleId;
+use aptos_sdk::move_types::u256::U256;
+use aptos_sdk::move_types::value::{serialize_values, MoveValue};
+use aptos_sdk::types::transaction::{EntryFunction, TransactionPayload};
+use log::info;
+use std::str::FromStr;
+
+pub async fn register_continuous_memorypage(
+    config: &AppConfig,
+    data: ContinuousMemorypage,
+) -> anyhow::Result<bool> {
+    let mut values = vec![];
+    for e in &data.values {
+        values.push(MoveValue::U256(U256::from_str(e)?));
+    }
+
+    let payload = TransactionPayload::EntryFunction(EntryFunction::new(
+        ModuleId::new(
+            config.module_address,
+            Identifier::new("memory_page_fact_registry")?,
+        ),
+        Identifier::new("register_continuous_memorypage")?,
+        vec![],
+        serialize_values(&vec![
+            MoveValue::U256(U256::from_str(&data.start_addr)?),
+            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);
+    let transaction = config.client.submit_and_wait(&tx).await?.into_inner();
+    let transaction_info = transaction.transaction_info()?;
+    info!(
+        "register_continuous_memorypage: {}; gas used: {}",
+        transaction_info.hash.to_string(),
+        transaction_info.gas_used
+    );
+    Ok(transaction.success())
+}

src/contracts_caller/memory_page_fact_registry/register_continuous_page_batch.rs

@@ -1,53 +1,100 @@
 use crate::config::AppConfig;
-use crate::contracts_caller::memory_page_fact_registry::types::memory_page_batch::MemoryPageEntries;
-use crate::contracts_caller::transaction_helper::{build_transaction, get_events_from_transaction};
+use crate::contracts_caller::memory_page_fact_registry::types::register_continuous_page_batch::MemoryPageEntries;
+use crate::contracts_caller::transaction_helper::build_transaction;
 use aptos_sdk::move_types::identifier::Identifier;
 use aptos_sdk::move_types::language_storage::ModuleId;
 use aptos_sdk::move_types::u256::U256;
 use aptos_sdk::move_types::value::{serialize_values, MoveValue};
-use aptos_sdk::rest_client::aptos_api_types::MoveType;
 use aptos_sdk::types::transaction::{EntryFunction, TransactionPayload};
+use itertools::Itertools;
+use log::info;
 use std::str::FromStr;
 
 pub async fn register_continuous_page_batch(
     config: &AppConfig,
     data: MemoryPageEntries,
 ) -> anyhow::Result<bool> {
     let data_input = data.memory_page_entries;
+    let initial_chunk_size = 15;
+
+    let mut start_addr_values = vec![];
 
-    let mut start_addr = vec![];
-    let mut values = vec![];
     for e in &data_input {
-        start_addr.push(MoveValue::U256(U256::from_str(&e.start_addr)?));
+        let start_addr = MoveValue::U256(U256::from_str(&e.start_addr)?);
         let mut value = vec![];
         for v in &e.values {
             value.push(MoveValue::U256(U256::from_str(v)?));
         }
-        values.push(MoveValue::Vector(value));
+        start_addr_values.push((start_addr, MoveValue::Vector(value)));
     }
 
-    let payload = TransactionPayload::EntryFunction(EntryFunction::new(
-        ModuleId::new(
-            config.module_address,
-            Identifier::new("memory_page_fact_registry")?,
-        ),
-        Identifier::new("register_continuous_page_batch")?,
-        vec![],
-        serialize_values(&vec![
-            MoveValue::Vector(start_addr),
-            MoveValue::Vector(values),
-            MoveValue::U256(U256::from_str(&data_input.get(0).unwrap().z)?),
-            MoveValue::U256(U256::from_str(&data_input.get(0).unwrap().alpha)?),
-            MoveValue::U256(U256::from_str(&data_input.get(0).unwrap().prime)?),
-        ]),
-    ));
-    let tx = build_transaction(payload, &config.account, config.chain_id);
-    let transaction = config.client.submit_and_wait(&tx).await?.into_inner();
-
-    let log_memory_page_fact_continuous = MoveType::from_str(&format!(
-        "{}::memory_page_fact_registry::LogMemoryPageFactContinuous",
-        config.module_address
-    ))?;
-    let event = get_events_from_transaction(&transaction, log_memory_page_fact_continuous)?;
-    Ok(transaction.success())
+    start_addr_values.sort_by_key(|(_, values)| match values {
+        MoveValue::Vector(v) => v.len(),
+        _ => 0,
+    });
+
+    let mut chunk_size = initial_chunk_size;
+    let mut success = true;
+    let mut remaining_data = start_addr_values;
+
+    while chunk_size > 0 {
+        success = true;
+        let mut new_remaining_data = vec![];
+
+        for chunk in &remaining_data.iter().chunks(chunk_size) {
+            let chunk: Vec<_> = chunk.cloned().collect();
+            let mut chunk_start_addr = vec![];
+            let mut chunk_values = vec![];
+
+            for (addr, val) in &chunk {
+                chunk_start_addr.push(addr.clone());
+                chunk_values.push(val.clone());
+            }
+
+            let payload = TransactionPayload::EntryFunction(EntryFunction::new(
+                ModuleId::new(
+                    config.module_address,
+                    Identifier::new("memory_page_fact_registry")?,
+                ),
+                Identifier::new("register_continuous_page_batch")?,
+                vec![],
+                serialize_values(&vec![
+                    MoveValue::Vector(chunk_start_addr),
+                    MoveValue::Vector(chunk_values),
+                    MoveValue::U256(U256::from_str(&data_input.first().unwrap().z)?),
+                    MoveValue::U256(U256::from_str(&data_input.first().unwrap().alpha)?),
+                    MoveValue::U256(U256::from_str(&data_input.first().unwrap().prime)?),
+                ]),
+            ));
+            let tx = build_transaction(payload, &config.account, config.chain_id);
+            let transaction = match config.client.submit_and_wait(&tx).await {
+                Ok(tx) => tx.into_inner(),
+                Err(_) => {
+                    success = false;
+                    new_remaining_data.extend(chunk);
+                    break;
+                }
+            };
+            let transaction_info = transaction.transaction_info()?;
+            info!(
+                "register_continuous_memorypage_batch: {}; gas used: {}",
+                transaction_info.hash.to_string(),
+                transaction_info.gas_used
+            );
+
+            if !transaction.success() {
+                success = false;
+                new_remaining_data.extend(chunk);
+                break;
+            }
+        }
+
+        if success {
+            break;
+        } else {
+            remaining_data = new_remaining_data;
+            chunk_size /= 2;
+        }
+    }
+    Ok(success)
 }

src/contracts_caller/memory_page_fact_registry/sample_register_memory.rs

@@ -0,0 +1,42 @@
+use std::fs::File;
+use std::io::BufReader;
+
+use crate::config::AppConfig;
+use crate::contracts_caller::memory_page_fact_registry::register_continuous_memorypage::register_continuous_memorypage;
+use crate::contracts_caller::memory_page_fact_registry::register_continuous_page_batch::register_continuous_page_batch;
+use crate::contracts_caller::memory_page_fact_registry::types::register_continuous_memorypage::ContinuousMemorypage;
+use crate::contracts_caller::memory_page_fact_registry::types::register_continuous_page_batch::MemoryPageEntries;
+
+pub async fn sample_register_continuous_page_batch(config: &AppConfig) -> anyhow::Result<bool> {
+    let file_path =
+        "src/data_samples/memory_page_fact_registry/register_continuous_page_batch.json"
+            .to_string();
+    let input_file = File::open(file_path)?;
+    let reader = BufReader::new(input_file);
+    let memory_page_entries: MemoryPageEntries = serde_json::from_reader(reader)?;
+
+    register_continuous_page_batch(config, memory_page_entries).await
+}
+
+pub async fn sample_register_continuous_page(config: &AppConfig) -> anyhow::Result<bool> {
+    let file_path =
+        "src/data_samples/memory_page_fact_registry/register_memory_page.json".to_string();
+    let input_file = File::open(file_path)?;
+    let reader = BufReader::new(input_file);
+    let continuous_memmory_page: ContinuousMemorypage = serde_json::from_reader(reader)?;
+
+    register_continuous_memorypage(config, continuous_memmory_page).await
+}
+
+pub async fn sample_large_data_register_continuous_page_batch(
+    config: &AppConfig,
+) -> anyhow::Result<bool> {
+    let file_path =
+        "src/data_samples/memory_page_fact_registry/large_data_register_continuous_page_batch.json"
+            .to_string();
+    let input_file = File::open(file_path)?;
+    let reader = BufReader::new(input_file);
+    let memory_page_entries: MemoryPageEntries = serde_json::from_reader(reader)?;
+
+    register_continuous_page_batch(config, memory_page_entries).await
+}

src/contracts_caller/memory_page_fact_registry/types/mod.rs

@@ -1,3 +1,2 @@
-pub mod log_memory_page_fact_continuos;
-pub mod memory_page_batch;
-pub mod memory_page_fact_registry;
+pub mod register_continuous_memorypage;
+pub mod register_continuous_page_batch;

src/contracts_caller/memory_page_fact_registry/types/memory_page_fact_registry.rs → src/contracts_caller/memory_page_fact_registry/types/register_continuous_memorypage.rs

@@ -2,7 +2,7 @@ use serde::Deserialize;
 
 #[derive(Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
-pub struct RegisterMemoryPage {
+pub struct ContinuousMemorypage {
     pub start_addr: String,
     pub values: Vec<String>,
     pub z: String,

src/contracts_caller/memory_page_fact_registry/types/register_continuous_page_batch.rs

@@ -0,0 +1,8 @@
+use crate::contracts_caller::memory_page_fact_registry::types::register_continuous_memorypage::ContinuousMemorypage;
+use serde::Deserialize;
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct MemoryPageEntries {
+    pub memory_page_entries: Vec<ContinuousMemorypage>,
+}