make txn output consistent (#185)

Co-authored-by: Bo Wu <[email protected]>

Author: 2 people

Cargo.lock

@@ -252,6 +252,7 @@ members = [
     "third_party/move/tools/move-unit-test",
     "tools/calc-dep-sizes",
     "tools/compute-module-expansion-size",
+    "tools/l1-migration",
     "types",
     "vm-validator",
 ]

Cargo.toml

@@ -79,11 +79,9 @@ impl Opt {
         let all_errors = verifier.run()?;
         if !all_errors.is_empty() {
             error!("{} failed transactions", all_errors.len());
-            /* errors were printed as found.
             for e in all_errors {
                 error!("Failed: {}", e);
             }
-             */
             process::exit(2);
         }
         Ok(())

storage/db-tool/src/replay_on_archive.rs

@@ -0,0 +1,21 @@
+[package]
+name = "l1-migration"
+version = "0.1.0"
+
+authors = { workspace = true }
+edition = { workspace = true }
+homepage = { workspace = true }
+license = { workspace = true }
+publish = { workspace = true }
+repository = { workspace = true }
+rust-version = { workspace = true }
+
+
+[dependencies]
+anyhow = "1.0"
+aptos-config = { workspace = true }
+aptos-db = { workspace = true }
+aptos-storage-interface = { workspace = true }
+aptos-types = { workspace = true }
+bcs = "0.1"
+clap = { version = "4.0", features = ["derive"] }

tools/l1-migration/Cargo.toml

@@ -0,0 +1 @@
+8740519:1848ea5e9a417e1a90b1bf57f7bf22d0c627da736c5cc884971f9ef5018316d5

tools/l1-migration/data/mainnet/genesis.blob

@@ -0,0 +1,29 @@
+base:
+    data_dir: "PATH_TO_YOUR_LOCAL_DB_FOLDER"
+    role: "full_node"
+    waypoint:
+        from_file: "PATH_TO_YOUR_WAYPOINT_FILE"
+
+execution:
+    genesis_file_location: "PATH_TO_YOUR_GENESIS_BLOB"
+
+# VFN network configuration - connects to both validator and public networks
+full_node_networks:
+    # Public network for other fullnodes
+    - listen_address: "/ip4/127.0.0.1/tcp/6180"
+      discovery_method: "onchain"
+      network_id: "public"
+    
+api:
+    enabled: true
+    address: 0.0.0.0:8081
+
+storage:
+    backup_service_address: 0.0.0.0:6186
+    rocksdb_configs:
+        enable_storage_sharding: false
+
+state_sync:
+    state_sync_driver:
+        bootstrapping_mode: ApplyTransactionOutputsFromGenesis
+        continuous_syncing_mode: ExecuteTransactionsOrApplyOutputs

tools/l1-migration/data/mainnet/waypoint.txt

@@ -0,0 +1,127 @@
+use anyhow::Result;
+use aptos_config::config::{RocksdbConfigs, StorageDirPaths, NO_OP_STORAGE_PRUNER_CONFIG};
+use aptos_db::AptosDB;
+use aptos_storage_interface::DbReader;
+use aptos_types::{transaction::Transaction, waypoint::Waypoint};
+use std::path::Path;
+use std::fs;
+
+/// Extract genesis transaction and waypoint from an Aptos database
+pub fn extract_genesis_and_waypoint(db_path: &str, output_dir: &str) -> Result<()> {
+    println!("Opening database at: {}", db_path);
+    
+    // Create storage directory paths
+    let storage_dir_paths = StorageDirPaths::from_path(Path::new(db_path));
+    
+    // Open the database with correct API
+    let db = AptosDB::open(
+        storage_dir_paths,
+        true,  // readonly
+        NO_OP_STORAGE_PRUNER_CONFIG, // pruner_config
+        RocksdbConfigs::default(),
+        false, // enable_indexer
+        1,     // buffered_state_target_items
+        10000, // max_num_nodes_per_lru_cache_shard
+        None,  // internal_indexer_db
+    )?;
+
+    println!("Database opened successfully");
+
+    // Get the latest version to understand the database state
+    let latest_version = db.get_synced_version()?;
+    println!("Latest synced version: {:?}", latest_version);
+
+    if latest_version.is_none() {
+        return Err(anyhow::anyhow!("Database has no synced version"));
+    }
+
+    let latest_ver = latest_version.unwrap();
+    
+    // Extract genesis transaction
+    extract_genesis_transaction(&db, latest_ver, output_dir)?;
+    
+    // Extract waypoint
+    extract_waypoint(&db, output_dir)?;
+
+    println!("✓ Genesis extraction completed successfully!");
+    println!("  - genesis.blob: Contains the BCS-serialized genesis transaction");
+    println!("  - waypoint.txt: Contains the initial waypoint for bootstrapping");
+    
+    Ok(())
+}
+
+/// Extract the genesis transaction from the database
+fn extract_genesis_transaction(db: &AptosDB, latest_ver: u64, output_dir: &str) -> Result<()> {
+    println!("Extracting genesis transaction (version 0)...");
+    let genesis_txn_with_proof = db.get_transaction_by_version(0, latest_ver, false)?;
+    let genesis_transaction = genesis_txn_with_proof.transaction;
+
+    // Serialize the genesis transaction using BCS
+    let genesis_bytes = bcs::to_bytes(&genesis_transaction)?;
+    
+    // Write genesis.blob
+    let genesis_path = format!("{}/genesis.blob", output_dir);
+    fs::write(&genesis_path, &genesis_bytes)?;
+    println!("Genesis transaction written to: {}", genesis_path);
+    println!("Genesis blob size: {} bytes", genesis_bytes.len());
+
+    // Print information about the genesis transaction
+    print_genesis_transaction_info(&genesis_transaction);
+
+    Ok(())
+}
+
+/// Extract the waypoint from the database using proper waypoint conversion
+fn extract_waypoint(db: &AptosDB, output_dir: &str) -> Result<()> {
+    // Get the ledger info to extract waypoint
+    let ledger_info_with_sigs = db.get_latest_ledger_info()?;
+    let ledger_info = ledger_info_with_sigs.ledger_info();
+    
+    // Generate waypoint using the proper converter
+    let waypoint = Waypoint::new_any(ledger_info);
+    
+    // Write waypoint.txt
+    let waypoint_path = format!("{}/waypoint.txt", output_dir);
+    fs::write(&waypoint_path, waypoint.to_string())?;
+    println!("Waypoint written to: {}", waypoint_path);
+    println!("Waypoint: {}", waypoint);
+
+    Ok(())
+}
+
+/// Print detailed information about the genesis transaction
+fn print_genesis_transaction_info(genesis_transaction: &Transaction) {
+    match genesis_transaction {
+        Transaction::GenesisTransaction(genesis_payload) => {
+            println!("✓ Found GenesisTransaction (WriteSet transaction)");
+            // Access the payload correctly
+            match genesis_payload {
+                aptos_types::transaction::WriteSetPayload::Direct(change_set) => {
+                    println!("  Direct WriteSet payload");
+                    println!("  Change set size: {} bytes", bcs::to_bytes(change_set).unwrap_or_default().len());
+                },
+                aptos_types::transaction::WriteSetPayload::Script { .. } => {
+                    println!("  Script-based WriteSet");
+                },
+            }
+        },
+        Transaction::BlockMetadata(_) => {
+            println!("⚠ Transaction 0 is BlockMetadata (unexpected for genesis)");
+        },
+        Transaction::BlockMetadataExt(_) => {
+            println!("⚠ Transaction 0 is BlockMetadataExt (unexpected for genesis)");
+        },
+        Transaction::BlockEpilogue(_) => {
+            println!("⚠ Transaction 0 is BlockEpilogue (unexpected for genesis)");
+        },
+        Transaction::UserTransaction(_) => {
+            println!("⚠ Transaction 0 is UserTransaction (unexpected for genesis)");
+        },
+        Transaction::StateCheckpoint(_) => {
+            println!("⚠ Transaction 0 is StateCheckpoint (unexpected for genesis)");
+        },
+        Transaction::ValidatorTransaction(_) => {
+            println!("⚠ Transaction 0 is ValidatorTransaction (unexpected for genesis)");
+        },
+    }
+}

tools/l1-migration/local-node-configs/full_node.yaml

@@ -0,0 +1,3 @@
+pub mod genesis_waypoint_extraction;
+
+pub use genesis_waypoint_extraction::extract_genesis_and_waypoint;

tools/l1-migration/src/genesis_waypoint_extraction.rs

@@ -0,0 +1,50 @@
+use anyhow::Result;
+use clap::Parser;
+use l1_migration::extract_genesis_and_waypoint;
+use std::path::PathBuf;
+
+/// L1 Migration Tool - Extract genesis and waypoint from database
+#[derive(Parser)]
+#[command(name = "l1-migration")]
+#[command(about = "A tool to extract genesis and waypoint data from an Aptos database")]
+#[command(version)]
+struct Args {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Parser)]
+enum Commands {
+    /// Generate waypoint and genesis files from database
+    GenerateWaypointGenesis {
+        /// Path to the database directory
+        db_path: PathBuf,
+        /// Destination directory for extracted files
+        destination_path: PathBuf,
+    },
+}
+
+fn main() -> Result<()> {
+    let args = Args::parse();
+
+    match args.command {
+        Commands::GenerateWaypointGenesis { db_path, destination_path } => {
+            // Validate that the database path exists
+            if !db_path.exists() {
+                eprintln!("Error: Database path '{}' does not exist", db_path.display());
+                std::process::exit(1);
+            }
+
+            // Create destination directory if it doesn't exist
+            if !destination_path.exists() {
+                std::fs::create_dir_all(&destination_path)?;
+            }
+
+            // Call the extraction function from the module
+            let db_path_str = db_path.to_string_lossy();
+            let destination_path_str = destination_path.to_string_lossy();
+            
+            extract_genesis_and_waypoint(&db_path_str, &destination_path_str)
+        }
+    }
+}