@feltdb/core 0.8.4 → 0.8.5

package/dist/create/server-source/crates/feltdb/benches/gate_14b_causal_backlog_scaling.rs

@@ -33,11 +33,11 @@
 /// - Resource usage (memory, CPU)
 /// - Rejection behavior
 /// - Correctness verification
-
 use criterion::{criterion_group, criterion_main, Criterion};
 use feltdb::{
     causal_dependency_barrier::CausalDependencyBarrier,
-    convergence::VectorClock, submission::{SubmissionManager, SubmissionMetrics},
+    convergence::VectorClock,
+    submission::{SubmissionManager, SubmissionMetrics},
     transactions::{Operation, OperationCommand, OperationId, StateVersion},
 };
 use std::collections::HashMap;
@@ -78,7 +78,13 @@ impl SeededRng {
     }
 }
 
-fn generate_operation(rng: &mut SeededRng, op_id: u64, seq: u64, node: &str, client_id: usize) -> Operation {
+fn generate_operation(
+    rng: &mut SeededRng,
+    op_id: u64,
+    seq: u64,
+    node: &str,
+    client_id: usize,
+) -> Operation {
     let record_id = format!("rec_{}", rng.next_range(0, 99));
     let _is_write = rng.next_f64() >= 0.7; // 70% reads, 30% writes
 
@@ -163,10 +169,7 @@ struct BacklogMetrics {
 // MEASUREMENT
 // ============================================================================
 
-async fn measure_backlog_level(
-    writers: usize,
-    backlog_depth: usize,
-) -> BacklogMetrics {
+async fn measure_backlog_level(writers: usize, backlog_depth: usize) -> BacklogMetrics {
     // Create causal dependency barrier for this measurement
     let mut barrier = CausalDependencyBarrier::new();
     let mut frontier = VectorClock::new();
@@ -180,7 +183,9 @@ async fn measure_backlog_level(
         let mut required_deps = VectorClock::new();
         // Create dependencies on future state (far beyond current frontier)
         // This ensures the operation will be causally blocked
-        required_deps.clocks.insert("backlog_producer".to_string(), (10000 + i) as u64);
+        required_deps
+            .clocks
+            .insert("backlog_producer".to_string(), (10000 + i) as u64);
         let op_id = format!("pending_backlog_{}", i);
         let _ = barrier.receive_operation(op_id, required_deps);
     }
@@ -198,8 +203,10 @@ async fn measure_backlog_level(
 
     // Now measure submission performance while backlog exists
     let tx_manager = Arc::new(Mutex::new(
-        feltdb::transaction_api::TransactionManager::new("node1".to_string(),
-            StateVersion::new(frontier.clone(), "hash0".to_string())),
+        feltdb::transaction_api::TransactionManager::new(
+            "node1".to_string(),
+            StateVersion::new(frontier.clone(), "hash0".to_string()),
+        ),
     ));
 
     let submission_manager = SubmissionManager::new(Arc::clone(&tx_manager));
@@ -238,11 +245,13 @@ async fn measure_backlog_level(
     let outcomes = outcomes.lock().unwrap().clone();
 
     let initial_attempted = outcomes.len();
-    let initial_accepted = outcomes.iter()
+    let initial_accepted = outcomes
+        .iter()
         .filter(|(eventually, first_lat, _)| *first_lat > 0 && *eventually)
         .count();
     let initial_rejected = initial_attempted - initial_accepted;
-    let final_accepted = outcomes.iter()
+    let final_accepted = outcomes
+        .iter()
         .filter(|(eventually, _, _)| *eventually)
         .count();
     let final_permanently_rejected = initial_attempted - final_accepted;
@@ -287,7 +296,10 @@ async fn measure_backlog_level(
     // State hash: for causal barrier measurement, hash reflects frontier state
     let frontier_hash = format!("{:?}", frontier.clocks);
     let expected_hash = format!("{:08x}", frontier_hash.len() as u32);
-    let actual_hash = format!("{:08x}", (backlog_depth ^ writers ^ final_accepted as usize) as u32);
+    let actual_hash = format!(
+        "{:08x}",
+        (backlog_depth ^ writers ^ final_accepted as usize) as u32
+    );
 
     let correctness_verified = actual_pending_count == backlog_depth;
     BacklogMetrics {
@@ -333,28 +345,51 @@ fn gate_14b_causal_backlog_scaling(c: &mut Criterion) {
     println!("\nTEST MATRIX:");
     println!("  Writers: {:?}", WRITERS);
     println!("  Backlog levels: {:?}", BACKLOG_LEVELS);
-    println!("  Total combinations: {}\n", WRITERS.len() * BACKLOG_LEVELS.len());
+    println!(
+        "  Total combinations: {}\n",
+        WRITERS.len() * BACKLOG_LEVELS.len()
+    );
 
     for &writer_count in WRITERS {
         println!("\n--- Writers: {} ---", writer_count);
         for &backlog_level in BACKLOG_LEVELS {
             let result = rt.block_on(measure_backlog_level(writer_count, backlog_level));
 
-            println!("\n=== Writers={} Backlog={} ===", writer_count, backlog_level);
+            println!(
+                "\n=== Writers={} Backlog={} ===",
+                writer_count, backlog_level
+            );
             println!("\nADMISSION SEMANTICS (14A preserved):");
-            println!("  initial_admission_attempted:           {}", result.initial_attempted);
-            println!("  initial_admission_accepted:            {}", result.initial_accepted);
-            println!("  initial_admission_rejected:            {}", result.initial_rejected);
-            println!("  initial_acceptance_rate_percent:       {:.1}%",
+            println!(
+                "  initial_admission_attempted:           {}",
+                result.initial_attempted
+            );
+            println!(
+                "  initial_admission_accepted:            {}",
+                result.initial_accepted
+            );
+            println!(
+                "  initial_admission_rejected:            {}",
+                result.initial_rejected
+            );
+            println!(
+                "  initial_acceptance_rate_percent:       {:.1}%",
                 if result.initial_attempted > 0 {
                     (result.initial_accepted as f64 / result.initial_attempted as f64) * 100.0
                 } else {
                     0.0
                 }
             );
-            println!("  final_outcome_accepted:                {}", result.final_accepted);
-            println!("  final_outcome_permanently_rejected:    {}", result.final_permanently_rejected);
-            println!("  eventual_acceptance_rate_percent:      {:.1}%",
+            println!(
+                "  final_outcome_accepted:                {}",
+                result.final_accepted
+            );
+            println!(
+                "  final_outcome_permanently_rejected:    {}",
+                result.final_permanently_rejected
+            );
+            println!(
+                "  eventual_acceptance_rate_percent:      {:.1}%",
                 if result.initial_attempted > 0 {
                     (result.final_accepted as f64 / result.initial_attempted as f64) * 100.0
                 } else {
@@ -363,21 +398,53 @@ fn gate_14b_causal_backlog_scaling(c: &mut Criterion) {
             );
 
             println!("\nPERFORMANCE:");
-            println!("  throughput_ops_sec:                    {:.3}", result.throughput_ops_sec);
-            println!("  admission_rate_ops_sec:                {:.3}", result.admission_rate_ops_sec);
-            println!("  backlog_drain_rate_ops_sec:            {:.3}", result.backlog_drain_rate_ops_sec);
-            println!("  causal_readiness_p50_us:               {}", result.p50_causal_readiness_us);
-            println!("  causal_readiness_p95_us:               {}", result.p95_causal_readiness_us);
-            println!("  causal_readiness_p99_us:               {}", result.p99_causal_readiness_us);
+            println!(
+                "  throughput_ops_sec:                    {:.3}",
+                result.throughput_ops_sec
+            );
+            println!(
+                "  admission_rate_ops_sec:                {:.3}",
+                result.admission_rate_ops_sec
+            );
+            println!(
+                "  backlog_drain_rate_ops_sec:            {:.3}",
+                result.backlog_drain_rate_ops_sec
+            );
+            println!(
+                "  causal_readiness_p50_us:               {}",
+                result.p50_causal_readiness_us
+            );
+            println!(
+                "  causal_readiness_p95_us:               {}",
+                result.p95_causal_readiness_us
+            );
+            println!(
+                "  causal_readiness_p99_us:               {}",
+                result.p99_causal_readiness_us
+            );
 
             println!("\nRESOURCES:");
-            println!("  peak_total_heap_kb:                    {}", result.peak_heap_kb);
+            println!(
+                "  peak_total_heap_kb:                    {}",
+                result.peak_heap_kb
+            );
 
             println!("\nCORRECTNESS:");
-            println!("  expected_state_hash:                   {}", result.expected_state_hash);
-            println!("  actual_state_hash:                     {}", result.actual_state_hash);
-            println!("  match:                                 {}",
-                if result.correctness_verified { "PASS" } else { "FAIL" }
+            println!(
+                "  expected_state_hash:                   {}",
+                result.expected_state_hash
+            );
+            println!(
+                "  actual_state_hash:                     {}",
+                result.actual_state_hash
+            );
+            println!(
+                "  match:                                 {}",
+                if result.correctness_verified {
+                    "PASS"
+                } else {
+                    "FAIL"
+                }
             );
         }
     }

package/dist/create/server-source/crates/feltdb/benches/gate_14c_replication_contract_test.rs

@@ -14,7 +14,6 @@
 /// 4. Delayed: Messages arrive late → eventual convergence ✓
 /// 5. Dropped + Retx: Message lost then resent → reconciliation recovers it
 /// 6. Causal dependency: Operation depends on prior → waiting/ready state correct
-
 use feltdb::{
     convergence::VectorClock,
     distributed_transactions::{DistributedTransactionExecutor, ReplicationMessage},
@@ -116,7 +115,8 @@ fn main() {
 async fn test_basic_2replica_convergence() {
     // Setup: 1 leader + 1 replica
     let initial_hash = StateHash::from_hex("hash0".to_string());
-    let mut leader = DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone());
+    let mut leader =
+        DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone());
     leader.register_replica("replica_1".to_string(), initial_hash.clone());
     let mut replica = DistributedTransactionExecutor::new("replica_1".to_string(), initial_hash);
 
@@ -155,7 +155,10 @@ async fn test_basic_2replica_convergence() {
 
         match result {
             Ok(envelope) => {
-                leader_hashes.push(format!("{:?}", leader.get_replica_state("leader").map(|s| s.state_hash)));
+                leader_hashes.push(format!(
+                    "{:?}",
+                    leader.get_replica_state("leader").map(|s| s.state_hash)
+                ));
                 println!("  ✓ Leader applied operation {}", seq);
 
                 // Replicate to follower
@@ -203,7 +206,8 @@ async fn test_basic_2replica_convergence() {
 
 async fn test_duplicate_message_handling() {
     let initial_hash = StateHash::from_hex("hash0".to_string());
-    let mut leader = DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone());
+    let mut leader =
+        DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone());
     leader.register_replica("replica_1".to_string(), initial_hash.clone());
     let mut replica = DistributedTransactionExecutor::new("replica_1".to_string(), initial_hash);
 
@@ -247,14 +251,28 @@ async fn test_duplicate_message_handling() {
         msg.clone(),
         StateVersion::new(VectorClock::new(), "hash0".to_string()),
     );
-    println!("  First delivery: {}", if result1.is_ok() { "✓ OK" } else { "✗ Failed" });
+    println!(
+        "  First delivery: {}",
+        if result1.is_ok() {
+            "✓ OK"
+        } else {
+            "✗ Failed"
+        }
+    );
 
     // Deliver same message again (duplicate)
     let result2 = replica.receive_replicated_transaction(
         msg,
         StateVersion::new(VectorClock::new(), "hash0".to_string()),
     );
-    println!("  Duplicate delivery: {}", if result2.is_err() { "✓ Rejected (correct)" } else { "✗ Accepted (wrong!)" });
+    println!(
+        "  Duplicate delivery: {}",
+        if result2.is_err() {
+            "✓ Rejected (correct)"
+        } else {
+            "✗ Accepted (wrong!)"
+        }
+    );
 
     // Verify only applied once
     if let Some(state) = replica.get_replica_state("replica_1") {
@@ -264,7 +282,8 @@ async fn test_duplicate_message_handling() {
 
 async fn test_out_of_order_delivery() {
     let initial_hash = StateHash::from_hex("hash0".to_string());
-    let mut leader = DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone());
+    let mut leader =
+        DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone());
     leader.register_replica("replica_1".to_string(), initial_hash.clone());
     let mut replica = DistributedTransactionExecutor::new("replica_1".to_string(), initial_hash);
 
@@ -317,19 +336,27 @@ async fn test_out_of_order_delivery() {
                 msg,
                 StateVersion::new(VectorClock::new(), "hash0".to_string()),
             );
-            println!("  Operation {} delivered: {}", seq, if result.is_ok() { "✓" } else { "✗" });
+            println!(
+                "  Operation {} delivered: {}",
+                seq,
+                if result.is_ok() { "✓" } else { "✗" }
+            );
         }
     }
 
     // Verify replica eventually has all operations
     if let Some(state) = replica.get_replica_state("replica_1") {
-        println!("  Replica has {} operations (expected 3)", state.operations_applied);
+        println!(
+            "  Replica has {} operations (expected 3)",
+            state.operations_applied
+        );
     }
 }
 
 async fn test_delayed_delivery() {
     let initial_hash = StateHash::from_hex("hash0".to_string());
-    let mut leader = DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone());
+    let mut leader =
+        DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone());
     leader.register_replica("replica_1".to_string(), initial_hash.clone());
     let mut replica = DistributedTransactionExecutor::new("replica_1".to_string(), initial_hash);
 
@@ -361,12 +388,7 @@ async fn test_delayed_delivery() {
         )
         .expect("Leader execution failed");
 
-    let msg = ReplicationMessage::new(
-        envelope,
-        "leader".to_string(),
-        "replica_1".to_string(),
-        0,
-    );
+    let msg = ReplicationMessage::new(envelope, "leader".to_string(), "replica_1".to_string(), 0);
 
     println!("  Simulating delay...");
     // In a real test, this would use tokio::time::sleep, but for now just immediate delivery
@@ -374,7 +396,14 @@ async fn test_delayed_delivery() {
         msg,
         StateVersion::new(VectorClock::new(), "hash0".to_string()),
     );
-    println!("  After delay delivery: {}", if result.is_ok() { "✓ OK" } else { "✗ Failed" });
+    println!(
+        "  After delay delivery: {}",
+        if result.is_ok() {
+            "✓ OK"
+        } else {
+            "✗ Failed"
+        }
+    );
 
     // Verify convergence
     let leader_state = leader.get_replica_state("leader");
@@ -398,7 +427,8 @@ async fn test_delayed_delivery() {
 
 async fn test_drop_and_retransmission() {
     let initial_hash = StateHash::from_hex("hash0".to_string());
-    let mut leader = DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone());
+    let mut leader =
+        DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone());
     leader.register_replica("replica_1".to_string(), initial_hash.clone());
     let mut replica = DistributedTransactionExecutor::new("replica_1".to_string(), initial_hash);
 
@@ -445,7 +475,14 @@ async fn test_drop_and_retransmission() {
         msg,
         StateVersion::new(VectorClock::new(), "hash0".to_string()),
     );
-    println!("  Message retransmitted: {}", if result.is_ok() { "✓ OK" } else { "✗ Failed" });
+    println!(
+        "  Message retransmitted: {}",
+        if result.is_ok() {
+            "✓ OK"
+        } else {
+            "✗ Failed"
+        }
+    );
 
     // Verify convergence
     let leader_state = leader.get_replica_state("leader");
@@ -466,4 +503,3 @@ async fn test_drop_and_retransmission() {
         _ => println!("  ✗ State retrieval failed"),
     }
 }
-

package/dist/create/server-source/crates/feltdb/benches/gate_14c_replication_scaling.rs

@@ -26,14 +26,15 @@
 /// - Convergence time
 /// - Peak heap per replica
 /// - State hash correctness across all replicas
-
 use feltdb::{
-    convergence::VectorClock, distributed_transactions::{
+    convergence::VectorClock,
+    distributed_transactions::{
         DistributedTransactionExecutor, ReplicationMessage, TransactionEnvelope,
     },
-    state_hash::StateHash, submission::{SubmissionManager},
+    state_hash::StateHash,
+    submission::SubmissionManager,
     transaction_api::TransactionManager,
-    transactions::{Operation, OperationCommand, OperationId, StateVersion, ConsistencyContract},
+    transactions::{ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion},
 };
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
@@ -73,7 +74,13 @@ impl SeededRng {
     }
 }
 
-fn generate_operation(rng: &mut SeededRng, op_id: u64, seq: u64, node: &str, client_id: usize) -> Operation {
+fn generate_operation(
+    rng: &mut SeededRng,
+    op_id: u64,
+    seq: u64,
+    node: &str,
+    client_id: usize,
+) -> Operation {
     let record_id = format!("rec_{}", rng.next_range(0, 99));
     let _is_write = rng.next_f64() >= 0.7; // 70% reads, 30% writes
 
@@ -155,15 +162,13 @@ struct ReplicationMetrics {
 // MEASUREMENT
 // ============================================================================
 
-async fn measure_replication_level(
-    writers: usize,
-    replica_count: usize,
-) -> ReplicationMetrics {
+async fn measure_replication_level(writers: usize, replica_count: usize) -> ReplicationMetrics {
     // Initialize distributed system with N replicas
     let initial_hash = StateHash::from_hex("hash0".to_string());
-    let leader_executor = Arc::new(Mutex::new(
-        DistributedTransactionExecutor::new("leader".to_string(), initial_hash.clone()),
-    ));
+    let leader_executor = Arc::new(Mutex::new(DistributedTransactionExecutor::new(
+        "leader".to_string(),
+        initial_hash.clone(),
+    )));
 
     // Create follower replicas
     let mut follower_executors = Vec::new();
@@ -173,9 +178,10 @@ async fn measure_replication_level(
             let replica_id = format!("replica_{}", i);
             leader.register_replica(replica_id.clone(), initial_hash.clone());
 
-            let replica_executor = Arc::new(Mutex::new(
-                DistributedTransactionExecutor::new(replica_id, initial_hash.clone()),
-            ));
+            let replica_executor = Arc::new(Mutex::new(DistributedTransactionExecutor::new(
+                replica_id,
+                initial_hash.clone(),
+            )));
             follower_executors.push(replica_executor);
         }
     }
@@ -188,7 +194,10 @@ async fn measure_replication_level(
     for client_id in 0..writers {
         let outcomes = Arc::clone(&outcomes);
         let leader = Arc::clone(&leader_executor);
-        let followers = follower_executors.iter().map(Arc::clone).collect::<Vec<_>>();
+        let followers = follower_executors
+            .iter()
+            .map(Arc::clone)
+            .collect::<Vec<_>>();
         let global_seq = Arc::clone(&global_seq);
 
         let handle = tokio::spawn(async move {
@@ -279,13 +288,16 @@ async fn measure_replication_level(
     }
 
     let avg_applied = if !operations_applied_per_replica.is_empty() {
-        operations_applied_per_replica.iter().sum::<usize>() as f64 / operations_applied_per_replica.len() as f64
+        operations_applied_per_replica.iter().sum::<usize>() as f64
+            / operations_applied_per_replica.len() as f64
     } else {
         0.0
     };
 
     // Check convergence: all replicas should have applied same operations
-    let all_same = operations_applied_per_replica.iter().all(|&c| c == operations_accepted);
+    let all_same = operations_applied_per_replica
+        .iter()
+        .all(|&c| c == operations_accepted);
     let converged = all_same && operations_applied_per_replica.len() == replica_count;
 
     // Estimate lag
@@ -295,7 +307,10 @@ async fn measure_replication_level(
         0
     };
 
-    let correctness_check = converged && operations_applied_per_replica.iter().all(|&c| c == operations_accepted);
+    let correctness_check = converged
+        && operations_applied_per_replica
+            .iter()
+            .all(|&c| c == operations_accepted);
 
     ReplicationMetrics {
         replica_count,
@@ -346,59 +361,119 @@ fn main() {
     println!("\nTEST MATRIX:");
     println!("  Writers: {:?}", WRITERS);
     println!("  Replica counts: {:?}", REPLICA_COUNTS);
-    println!("  Total combinations: {}\n", WRITERS.len() * REPLICA_COUNTS.len());
+    println!(
+        "  Total combinations: {}\n",
+        WRITERS.len() * REPLICA_COUNTS.len()
+    );
 
     for &writer_count in WRITERS {
         println!("\n--- Writers: {} ---", writer_count);
         for &replica_count in REPLICA_COUNTS {
             let result = rt.block_on(measure_replication_level(writer_count, replica_count));
 
-            println!("\n=== Writers={} Replicas={} ===", writer_count, replica_count);
+            println!(
+                "\n=== Writers={} Replicas={} ===",
+                writer_count, replica_count
+            );
             println!("\nREPLICATION SEMANTICS:");
-            println!("  operations_attempted:                  {}", result.operations_attempted);
-            println!("  operations_accepted_by_leader:         {}", result.operations_accepted_by_leader);
-            println!("  acceptance_rate_percent:               {:.1}%", result.acceptance_rate_percent);
+            println!(
+                "  operations_attempted:                  {}",
+                result.operations_attempted
+            );
+            println!(
+                "  operations_accepted_by_leader:         {}",
+                result.operations_accepted_by_leader
+            );
+            println!(
+                "  acceptance_rate_percent:               {:.1}%",
+                result.acceptance_rate_percent
+            );
 
             println!("\nREPLICATION THROUGHPUT:");
-            println!("  replication_throughput_ops_sec:        {:.3}",
+            println!(
+                "  replication_throughput_ops_sec:        {:.3}",
                 if result.convergence_time_us > 0 {
-                    (result.operations_accepted_by_leader as f64 * 1_000_000.0) / result.convergence_time_us as f64
+                    (result.operations_accepted_by_leader as f64 * 1_000_000.0)
+                        / result.convergence_time_us as f64
                 } else {
                     0.0
-                });
+                }
+            );
             for (i, &applied) in result.operations_applied_per_replica.iter().enumerate() {
                 if i == 0 {
                     println!("  operations_applied_by_leader:          {}", applied);
                 } else {
-                    println!("  operations_applied_by_replica_{}:      {}", i - 1, applied);
+                    println!(
+                        "  operations_applied_by_replica_{}:      {}",
+                        i - 1,
+                        applied
+                    );
                 }
             }
 
             println!("\nREPLICATION LATENCY:");
-            println!("  p50_replication_lag_us:                {}", result.p50_replication_lag_us);
-            println!("  p95_replication_lag_us:                {}", result.p95_replication_lag_us);
-            println!("  p99_replication_lag_us:                {}", result.p99_replication_lag_us);
-            println!("  max_replication_lag_us:                {}", result.max_replication_lag_us);
+            println!(
+                "  p50_replication_lag_us:                {}",
+                result.p50_replication_lag_us
+            );
+            println!(
+                "  p95_replication_lag_us:                {}",
+                result.p95_replication_lag_us
+            );
+            println!(
+                "  p99_replication_lag_us:                {}",
+                result.p99_replication_lag_us
+            );
+            println!(
+                "  max_replication_lag_us:                {}",
+                result.max_replication_lag_us
+            );
 
             println!("\nCONVERGENCE:");
-            println!("  convergence_time_us:                   {}", result.convergence_time_us);
-            println!("  all_replicas_converged:                {}",
-                if result.all_replicas_converged { "YES" } else { "NO" });
+            println!(
+                "  convergence_time_us:                   {}",
+                result.convergence_time_us
+            );
+            println!(
+                "  all_replicas_converged:                {}",
+                if result.all_replicas_converged {
+                    "YES"
+                } else {
+                    "NO"
+                }
+            );
 
             println!("\nRECONCILIATION:");
-            println!("  reconciliation_messages:               {}", result.reconciliation_messages);
-            println!("  network_amplification:                 {:.3}", result.network_amplification);
+            println!(
+                "  reconciliation_messages:               {}",
+                result.reconciliation_messages
+            );
+            println!(
+                "  network_amplification:                 {:.3}",
+                result.network_amplification
+            );
 
             println!("\nRESOURCES:");
-            println!("  peak_heap_kb:                          {}", result.peak_heap_kb);
+            println!(
+                "  peak_heap_kb:                          {}",
+                result.peak_heap_kb
+            );
 
             println!("\nCORRECTNESS:");
-            println!("  expected_state_hash:                   {}", result.expected_hash);
+            println!(
+                "  expected_state_hash:                   {}",
+                result.expected_hash
+            );
             for (i, hash) in result.replica_hashes.iter().enumerate() {
                 println!("  replica_{}_state_hash:                 {}", i, hash);
             }
-            println!("  correctness_verified:                  {}",
-                if result.correctness_verified { "PASS" } else { "FAIL" }
+            println!(
+                "  correctness_verified:                  {}",
+                if result.correctness_verified {
+                    "PASS"
+                } else {
+                    "FAIL"
+                }
             );
         }
     }