iuna

iuna.rs (91937B)

---

 use std::{
     collections::BTreeMap,
     time::{SystemTime, UNIX_EPOCH},
 };
 
 use iuna::{
     adapters::chain_store::SqliteChainStore,
     app::{
         DEFAULT_BURN_PER_BLOCK, GossipEnvelope, InMemoryNetwork, NodeConfig, NodeCore, PeerBook,
         PeerDirection, TRANSACTION_BATCH_LIMIT,
     },
     domain::{
         Amount, BLOCK_REWARD, DEFAULT_FEE_PER_BYTE, FinalizerMode, GenesisBurn, Ledger,
         MAX_BLOCK_BYTES, MICRO_IUNA, MINE_REWARD, RECOVERY_BLOCK_DELAY_MS,
         TransactionSubmitOutcome, VDF_TARGET_BLOCK_MS, Wallet, revealed_blinded_transactions,
         run_vdf, verify_vdf,
     },
 };
 use tempfile::tempdir;
 
 fn iuna(amount: Amount) -> Amount {
     amount * MICRO_IUNA
 }
 
 fn node(_network_key: &str, wallet: Wallet, allocations: BTreeMap<String, Amount>) -> NodeCore {
     NodeCore::new(NodeConfig {
         wallet,
         genesis_allocations: allocations,
         vdf_rounds: 25,
         burn_per_block: DEFAULT_BURN_PER_BLOCK,
         burn_fee: 1,
         pow_mining_workers: 1,
         recovery_vdf_top_rank_percent: 100,
     })
 }
 
 fn wallets(names: &[&str]) -> Vec<Wallet> {
     names.iter().map(|name| Wallet::from_seed(name)).collect()
 }
 
 fn allocations(wallets: &[Wallet], amount: Amount) -> BTreeMap<String, Amount> {
     wallets
         .iter()
         .map(|wallet| (wallet.address().to_string(), amount))
         .collect()
 }
 
 fn unix_now_ms() -> u64 {
     SystemTime::now()
         .duration_since(UNIX_EPOCH)
         .unwrap_or_default()
         .as_millis()
         .try_into()
         .unwrap_or(u64::MAX)
 }
 
 fn next_ticket_slot_timestamp(ledger: &Ledger, offset_ms: u64) -> u64 {
     ledger
         .chain()
         .last()
         .expect("ledger has genesis")
         .timestamp_ms
         .saturating_add(VDF_TARGET_BLOCK_MS)
         .saturating_add(offset_ms)
 }
 
 fn mine_wallet_burn_block(ledger: &mut Ledger, wallet: &Wallet, timestamp_ms: u64) -> String {
     let burn = ledger.build_burn(wallet, 1, 0).unwrap();
     ledger.submit_transaction(burn).unwrap();
     let block = ledger.mine_next_block(wallet, timestamp_ms).unwrap();
     let hash = block.hash.clone();
     ledger.apply_block(block).unwrap();
     hash
 }
 
 fn submit_burn(ledger: &mut Ledger, wallet: &Wallet, amount: Amount) {
     let tx = ledger.build_burn(wallet, amount, 0).unwrap();
     ledger.submit_transaction(tx).unwrap();
 }
 
 fn queue_plaintext_burn(
     node: &mut NodeCore,
     wallet: &Wallet,
     amount: Amount,
 ) -> iuna::domain::Transaction {
     let tx = node.ledger().build_burn(wallet, amount, 0).unwrap();
     node.receive_transaction(tx.clone()).unwrap();
     tx
 }
 
 fn queue_plaintext_transfer(
     node: &mut NodeCore,
     wallet: &Wallet,
     to: impl Into<String>,
     amount: Amount,
 ) -> iuna::domain::Transaction {
     let tx = node.ledger().build_transfer(wallet, to, amount, 0).unwrap();
     node.receive_transaction(tx.clone()).unwrap();
     tx
 }
 
 fn burn_tx(ledger: &Ledger, wallet: &Wallet, amount: Amount) -> iuna::domain::Transaction {
     ledger.build_burn(wallet, amount, 0).unwrap()
 }
 
 fn transfer_tx(
     ledger: &Ledger,
     wallet: &Wallet,
     to: impl Into<String>,
     amount: Amount,
 ) -> iuna::domain::Transaction {
     ledger.build_transfer(wallet, to, amount, 0).unwrap()
 }
 
 fn transfer_fee_tx(
     ledger: &Ledger,
     wallet: &Wallet,
     to: impl Into<String>,
     amount: Amount,
     fee: Amount,
 ) -> iuna::domain::Transaction {
     ledger.build_transfer(wallet, to, amount, fee).unwrap()
 }
 
 fn fork_with_better_vrf_block(
     base: &Ledger,
     wallet: &Wallet,
     local_fork_block_hash: &str,
     first_timestamp_ms: u64,
 ) -> Option<Ledger> {
     for offset in 0..10_000 {
         let mut candidate = base.clone();
         let timestamp_ms = next_ticket_slot_timestamp(&candidate, first_timestamp_ms + offset);
         let hash = mine_wallet_burn_block(&mut candidate, wallet, timestamp_ms);
         if hash.as_str() < local_fork_block_hash {
             return Some(candidate);
         }
     }
     None
 }
 
 fn fork_with_worse_vrf_block(
     base: &Ledger,
     wallet: &Wallet,
     local_fork_block_hash: &str,
     first_timestamp_ms: u64,
 ) -> Option<Ledger> {
     for offset in 0..10_000 {
         let mut candidate = base.clone();
         let timestamp_ms = next_ticket_slot_timestamp(&candidate, first_timestamp_ms + offset);
         let hash = mine_wallet_burn_block(&mut candidate, wallet, timestamp_ms);
         if hash.as_str() > local_fork_block_hash {
             return Some(candidate);
         }
     }
     None
 }
 
 fn starter_node(wallet: Wallet) -> NodeCore {
     let mut genesis = BTreeMap::new();
     genesis.insert(wallet.address().to_string(), 1);
     let ledger =
         Ledger::new_with_genesis_burns(genesis, vec![GenesisBurn::new(wallet.address(), 1)], 25)
             .unwrap();
     NodeCore::from_ledger_with_burn_fee_and_enabled(
         wallet,
         ledger,
         true,
         DEFAULT_BURN_PER_BLOCK,
         DEFAULT_FEE_PER_BYTE,
     )
 }
 
 #[test]
 fn genesis_burn_starts_chain_with_reward_and_first_leader() {
     let alice = Wallet::from_seed("alice");
     let node = starter_node(alice.clone());
 
     let genesis = &node.ledger().chain()[0];
     assert_eq!(node.ledger().balance_of(alice.address()), BLOCK_REWARD);
     assert_eq!(genesis.height, 0);
     assert_eq!(genesis.miner, alice.address());
     assert_eq!(genesis.reward, BLOCK_REWARD);
     assert_eq!(genesis.transactions.len(), 1);
     assert!(genesis.transactions[0].is_burn());
     assert_eq!(genesis.transactions[0].amount(), 1);
     assert_eq!(
         node.ledger().expected_leader_for_next_block().as_deref(),
         Some(alice.address())
     );
 }
 
 #[test]
 fn burn_amount_weights_leader_selection() {
     let mut high_weight_leaders = 0;
     for sample in 0..100 {
         let low = Wallet::from_seed(&format!("weighted-low-{sample}"));
         let high = Wallet::from_seed(&format!("weighted-high-{sample}"));
         let mut allocations = BTreeMap::new();
         allocations.insert(low.address().to_string(), 1_000);
         allocations.insert(high.address().to_string(), 1_000);
         let ledger = Ledger::new_with_genesis_burns(
             allocations,
             vec![
                 GenesisBurn::new(low.address(), 1),
                 GenesisBurn::new(high.address(), 99),
             ],
             25,
         )
         .unwrap();
 
         if ledger.expected_leader_for_next_block().as_deref() == Some(high.address()) {
             high_weight_leaders += 1;
         }
     }
 
     assert!(
         high_weight_leaders >= 90,
         "high burn ticket should win most weighted draws, won {high_weight_leaders}/100"
     );
 }
 
 #[test]
 fn starter_node_waits_for_a_burn_before_vdf_work() {
     let alice = Wallet::from_seed("alice");
     let mut node = starter_node(alice.clone());
 
     let outcome = node.automatic_mine_once(1);
     assert_eq!(outcome.burned.as_ref().map(|tx| tx.amount()), Some(1));
     assert!(outcome.block.is_some(), "{outcome:?}");
     assert_eq!(node.ledger().status().height, 1);
     assert!(node.ledger().balance_of(alice.address()) < BLOCK_REWARD);
 }
 
 #[test]
 fn burn_in_block_creates_ticket_after_maturity_delay() {
     let alice = Wallet::from_seed("alice");
     let bob = Wallet::from_seed("bob");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), MICRO_IUNA);
     allocations.insert(bob.address().to_string(), MICRO_IUNA);
 
     let mut ledger = Ledger::new(allocations, 10);
     submit_burn(&mut ledger, &bob, 80);
 
     let launch_leader =
         if ledger.expected_leader_for_next_block().as_deref() == Some(alice.address()) {
             &alice
         } else {
             &bob
         };
     let first = ledger.mine_next_block(launch_leader, 1).unwrap();
     ledger.apply_block(first).unwrap();
 
     for height in 2..=3 {
         let leader_wallet =
             if ledger.expected_leader_for_next_block().as_deref() == Some(alice.address()) {
                 &alice
             } else {
                 &bob
             };
         submit_burn(&mut ledger, leader_wallet, 1);
         let block = ledger.mine_next_block(leader_wallet, height).unwrap();
         ledger.apply_block(block).unwrap();
     }
 
     assert_eq!(
         ledger.expected_leader_for_next_block().as_deref(),
         Some(bob.address())
     );
 
     assert!(
         ledger.mine_next_block(&alice, 4).is_err(),
         "the block 1 burn should not be eligible before its maturity delay, and only Bob should hold it at block 4"
     );
 
     submit_burn(&mut ledger, &bob, 1);
     assert!(ledger.mine_next_block(&bob, 4).is_ok());
 }
 
 #[test]
 fn transfer_and_burn_update_balances_when_block_is_applied() {
     let alice = Wallet::from_seed("alice");
     let bob = Wallet::from_seed("bob");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), iuna(1_000));
     allocations.insert(bob.address().to_string(), iuna(100));
 
     let mut ledger = Ledger::new(allocations, 10);
     let transfer = transfer_tx(&ledger, &alice, bob.address(), iuna(125));
     ledger.submit_transaction(transfer).unwrap();
     let burn = burn_tx(&ledger, &alice, iuna(25));
     ledger.submit_transaction(burn).unwrap();
     let block = ledger.mine_next_block(&alice, 1).unwrap();
     ledger.apply_block(block).unwrap();
 
     assert_eq!(ledger.balance_of(alice.address()), iuna(850));
     assert_eq!(ledger.balance_of(bob.address()), iuna(225));
 }
 
 #[test]
 fn forged_transaction_is_rejected() {
     let alice = Wallet::from_seed("alice");
     let bob = Wallet::from_seed("bob");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), MICRO_IUNA);
     allocations.insert(bob.address().to_string(), MICRO_IUNA);
     let mut ledger = Ledger::new(allocations, 10);
 
     let mut forged = burn_tx(&ledger, &bob, 10);
     if let iuna::domain::Transaction::Burn { inputs, .. } = &mut forged {
         inputs[0].owner = alice.address().to_string();
     }
 
     let error = ledger.submit_transaction(forged).unwrap_err();
     assert!(error.to_string().contains("signature"));
 }
 
 #[test]
 fn block_with_forged_transaction_is_rejected() {
     let alice = Wallet::from_seed("alice");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), MICRO_IUNA);
     let mut ledger = Ledger::new(allocations, 10);
     submit_burn(&mut ledger, &alice, 1);
 
     let mut block = ledger.mine_next_block(&alice, 1).unwrap();
     if let iuna::domain::Transaction::Burn { signature, .. } = &mut block.transactions[0] {
         signature.push_str("00");
     }
     block.vdf_output = run_vdf(&block.vdf_seed(), block.vdf_rounds);
     block.hash = block.compute_hash();
 
     let error = ledger.apply_block(block).unwrap_err();
     assert!(error.to_string().contains("signature"));
 }
 
 #[test]
 fn mine_action_uses_fixed_reward_and_finalizer_fee() {
     let alice = Wallet::from_seed("alice");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), 2 * MICRO_IUNA);
 
     let mut ledger = Ledger::new(allocations, 10);
     submit_burn(&mut ledger, &alice, MICRO_IUNA);
     let mine = ledger.build_mine(alice.address()).unwrap();
     assert_eq!(mine.amount(), MINE_REWARD);
     assert_eq!(mine.fee(), MICRO_IUNA);
     ledger.submit_transaction(mine.clone()).unwrap();
     let block = ledger.mine_next_block(&alice, 1).unwrap();
     assert_eq!(block.reward, MICRO_IUNA);
 
     ledger.apply_block(block).unwrap();
     assert_eq!(
         ledger.balance_of(alice.address()),
         2 * MICRO_IUNA + MINE_REWARD
     );
     assert!(!ledger.submit_transaction(mine).unwrap());
     assert_eq!(
         ledger.balance_of(alice.address()),
         2 * MICRO_IUNA + MINE_REWARD
     );
 }
 
 #[test]
 fn mine_action_protocol_fee_is_paid_to_block_finalizer() {
     let alice = Wallet::from_seed("mine-fee-alice");
     let bob = Wallet::from_seed("mine-fee-bob");
     let mut allocations = BTreeMap::new();
     allocations.insert(bob.address().to_string(), 2 * MICRO_IUNA);
 
     let mut ledger = Ledger::new(allocations, 10);
     let mine = ledger.build_mine(alice.address()).unwrap();
     assert_eq!(mine.amount(), MINE_REWARD);
     assert_eq!(mine.fee(), MICRO_IUNA);
     ledger.submit_transaction(mine).unwrap();
     submit_burn(&mut ledger, &bob, MICRO_IUNA);
 
     let block = ledger.mine_next_block(&bob, 1).unwrap();
     assert_eq!(block.reward, MICRO_IUNA);
     ledger.apply_block(block).unwrap();
 
     assert_eq!(ledger.balance_of(alice.address()), MINE_REWARD);
     assert_eq!(ledger.balance_of(bob.address()), 2 * MICRO_IUNA);
 }
 
 #[test]
 fn forged_mine_action_cannot_introduce_iuna() {
     let alice = Wallet::from_seed("forged-mine-alice");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), MICRO_IUNA);
     let mut ledger = Ledger::new(allocations, 10);
 
     let mut forged = ledger.build_mine(alice.address()).unwrap();
     if let iuna::domain::Transaction::Mine { nonce, .. } = &mut forged {
         *nonce += 1;
     }
 
     let error = ledger.submit_transaction(forged).unwrap_err();
     assert!(format!("{error:#}").contains("mine transaction proof hash is invalid"));
     assert_eq!(ledger.balance_of(alice.address()), MICRO_IUNA);
 }
 
 #[test]
 fn burn_larger_than_mine_reward_is_paid_from_existing_utxos() {
     let alice = Wallet::from_seed("large-burn-existing-utxos-alice");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), BLOCK_REWARD + iuna(50));
 
     let mut ledger = Ledger::new(allocations, 10);
     let burn_amount = BLOCK_REWARD + iuna(25);
     let burn = ledger.build_burn(&alice, burn_amount, 0).unwrap();
     ledger.submit_transaction(burn).unwrap();
 
     let block = ledger.mine_next_block(&alice, 1).unwrap();
     assert_eq!(block.transactions[0].amount(), burn_amount);
     assert_eq!(block.reward, 0);
 
     ledger.apply_block(block).unwrap();
     assert_eq!(ledger.balance_of(alice.address()), iuna(25));
 }
 
 #[test]
 fn burn_larger_than_existing_balance_cannot_use_next_block_reward() {
     let alice = Wallet::from_seed("large-burn-cannot-use-next-reward-alice");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), BLOCK_REWARD);
 
     let ledger = Ledger::new(allocations, 10);
     let error = ledger
         .build_burn(&alice, BLOCK_REWARD + MICRO_IUNA, 0)
         .unwrap_err();
 
     assert!(format!("{error:#}").contains("insufficient funds"));
 }
 
 #[test]
 fn transaction_fees_are_paid_to_the_block_finalizer() {
     let alice = Wallet::from_seed("fee-miner-alice");
     let bob = Wallet::from_seed("fee-payer-bob");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), MICRO_IUNA);
     allocations.insert(bob.address().to_string(), iuna(200));
 
     let mut ledger = Ledger::new_with_genesis_burns(
         allocations,
         vec![GenesisBurn::new(alice.address(), MICRO_IUNA)],
         10,
     )
     .unwrap();
     submit_burn(&mut ledger, &alice, MICRO_IUNA);
     let tx = transfer_fee_tx(&ledger, &bob, alice.address(), iuna(10), iuna(7));
     ledger.submit_transaction(tx).unwrap();
 
     let block = ledger.mine_next_block(&alice, 1).unwrap();
     assert_eq!(block.reward, iuna(7));
     ledger.apply_block(block).unwrap();
 
     assert_eq!(ledger.balance_of(alice.address()), BLOCK_REWARD + iuna(16));
     assert_eq!(ledger.balance_of(bob.address()), iuna(183));
 }
 
 #[test]
 fn miner_orders_block_transactions_by_fee_rate_after_required_burn() {
     let wallets = wallets(&["fee-order-alice", "fee-order-bob", "fee-order-carol"]);
     let alice = &wallets[0];
     let bob = &wallets[1];
     let carol = &wallets[2];
     let mut allocations = allocations(&wallets, 1_000);
     allocations.insert(alice.address().to_string(), 1);
     let mut ledger =
         Ledger::new_with_genesis_burns(allocations, vec![GenesisBurn::new(alice.address(), 1)], 10)
             .unwrap();
     let required_burn = burn_tx(&ledger, alice, 1);
     let low_fee = transfer_fee_tx(&ledger, bob, alice.address(), 1, 1);
     let high_fee = transfer_fee_tx(&ledger, carol, alice.address(), 1, 20);
     ledger.submit_transaction(low_fee.clone()).unwrap();
     ledger.submit_transaction(high_fee.clone()).unwrap();
     ledger.submit_transaction(required_burn.clone()).unwrap();
 
     let block = ledger.mine_next_block(alice, 1).unwrap();
     let signatures = block
         .transactions
         .iter()
         .map(|tx| tx.signature().to_string())
         .collect::<Vec<_>>();
 
     assert_eq!(signatures[0], required_burn.signature());
     assert!(
         signatures
             .iter()
             .position(|signature| signature == high_fee.signature())
             < signatures
                 .iter()
                 .position(|signature| signature == low_fee.signature())
     );
 }
 
 #[test]
 fn oversized_blocks_are_rejected() {
     let alice = Wallet::from_seed("oversized-block-alice");
     let bob = Wallet::from_seed("oversized-block-bob");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), 1);
     allocations.insert(bob.address().to_string(), 1_000);
     let mut ledger =
         Ledger::new_with_genesis_burns(allocations, vec![GenesisBurn::new(alice.address(), 1)], 10)
             .unwrap();
     submit_burn(&mut ledger, &alice, 1);
     let mut block = ledger.mine_next_block(&alice, 1).unwrap();
     let mut oversized_transfer = transfer_fee_tx(&ledger, &bob, alice.address(), 1, 3);
     if let iuna::domain::Transaction::Transfer { outputs, .. } = &mut oversized_transfer {
         outputs[0].address = "x".repeat(MAX_BLOCK_BYTES);
     }
     block.transactions.push(oversized_transfer);
     block.reward = 3;
     block.hash = block.compute_hash();
 
     let error = ledger.apply_block(block).unwrap_err();
 
     assert!(format!("{error:#}").contains("max block size"));
 }
 
 #[test]
 fn transfer_that_would_overflow_recipient_balance_is_rejected() {
     let alice = Wallet::from_seed("alice");
     let bob = Wallet::from_seed("bob");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), 1);
     allocations.insert(bob.address().to_string(), Amount::MAX);
 
     let ledger = Ledger::new(allocations, 10);
     let error = ledger
         .build_transfer(&alice, bob.address(), 1, 0)
         .unwrap_err();
 
     assert!(format!("{error:#}").contains("balance overflow"));
 }
 
 #[test]
 fn mine_reward_that_would_overflow_recipient_balance_is_rejected() {
     let alice = Wallet::from_seed("alice");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), Amount::MAX);
 
     let ledger = Ledger::new(allocations, 10);
     let error = ledger.build_mine(alice.address()).unwrap_err();
 
     assert!(format!("{error:#}").contains("balance overflow"));
 }
 
 #[test]
 fn block_without_mature_ticket_cannot_be_mined() {
     let alice = Wallet::from_seed("alice");
     let allocations = BTreeMap::new();
 
     let ledger = Ledger::new(allocations, 10);
     let error = ledger.mine_next_block(&alice, 1).unwrap_err();
     assert!(error.to_string().contains("mature burn ticket"));
 }
 
 #[test]
 fn vdf_work_requires_at_least_one_pending_burn() {
     let alice = Wallet::from_seed("alice");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), MICRO_IUNA);
 
     let ledger = Ledger::new(allocations, 10);
     let error = ledger.prepare_next_block(alice.address(), 1).unwrap_err();
 
     assert!(format!("{error:#}").contains("at least one burn"));
 }
 
 #[test]
 fn leader_block_without_burn_is_rejected() {
     let alice = Wallet::from_seed("alice");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), 1_000);
 
     let mut ledger = Ledger::new(allocations, 10);
     submit_burn(&mut ledger, &alice, 1);
     let mut block = ledger.mine_next_block(&alice, 1).unwrap();
     block.transactions.clear();
     block.hash = block.compute_hash();
 
     let error = ledger.apply_block(block).unwrap_err();
     assert!(format!("{error:#}").contains("at least one burn"));
 }
 
 #[test]
 fn block_hash_is_bound_to_block_contents() {
     let alice = Wallet::from_seed("alice");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), 1_000);
 
     let mut ledger = Ledger::new(allocations, 10);
     submit_burn(&mut ledger, &alice, 1);
     let mut block = ledger.mine_next_block(&alice, 1).unwrap();
     block.timestamp_ms += 1;
 
     let error = ledger.apply_block(block).unwrap_err();
     assert!(error.to_string().contains("block hash is invalid"));
 }
 
 #[test]
 fn automatic_mining_burns_configured_amount_once_per_height() {
     let alice = Wallet::from_seed("alice");
     let bob = Wallet::from_seed("auto-once-leader");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), iuna(1_000));
     allocations.insert(bob.address().to_string(), MICRO_IUNA);
     let ledger = Ledger::new_with_genesis_burns(
         allocations,
         vec![GenesisBurn::new(bob.address(), MICRO_IUNA)],
         10,
     )
     .unwrap();
     assert_eq!(
         ledger.expected_leader_for_next_block().as_deref(),
         Some(bob.address())
     );
     let mut node = NodeCore::from_ledger_with_burn_fee_and_enabled(
         alice.clone(),
         ledger,
         true,
         iuna(25),
         DEFAULT_FEE_PER_BYTE,
     );
 
     let first = node.automatic_mine_once(1);
     assert!(first.burned.is_some());
     let burned = first.burned.as_ref().unwrap();
     assert_eq!(burned.amount(), iuna(25));
     assert!(burned.fee() > burned.economic_size_bytes() as u64 * DEFAULT_FEE_PER_BYTE);
     assert!(first.block.is_none());
     assert_eq!(node.ledger().pending_blinded_transactions().len(), 1);
 
     let second = node.automatic_mine_once(2);
     assert!(second.burned.is_none());
     assert!(second.block.is_none());
     assert_eq!(node.ledger().pending_blinded_transactions().len(), 1);
 }
 
 #[test]
 fn default_automatic_mining_does_not_burn() {
     assert_eq!(DEFAULT_BURN_PER_BLOCK, 0);
 
     let alice = Wallet::from_seed("alice");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), 1_000);
     let mut node = node("alice", alice.clone(), allocations);
 
     let outcome = node.automatic_mine_once(1);
     assert!(outcome.burned.is_none());
     assert!(outcome.block.is_none());
     assert!(
         outcome
             .skipped_reason
             .as_deref()
             .is_some_and(|reason| reason.contains("automatic mining is off"))
     );
     assert_eq!(node.ledger().balance_of(alice.address()), 1_000);
 }
 
 #[test]
 fn burn_per_block_can_be_set_to_zero() {
     let alice = Wallet::from_seed("alice");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), MICRO_IUNA);
     let mut node = node("alice", alice, allocations);
 
     let burned = node.set_burn_per_block(25).unwrap();
     assert!(burned.is_some());
     assert!(node.status().mining.automatic);
     assert_eq!(node.status().mining.burn_per_block, 25);
     let burned = node.set_burn_per_block(0).unwrap();
     assert!(burned.is_none());
     assert!(!node.status().mining.automatic);
     assert_eq!(node.status().mining.burn_per_block, 0);
 }
 
 #[test]
 fn automatic_burn_status_shows_configured_fee() {
     let alice = Wallet::from_seed("auto-fee-status-alice");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), 1_000);
     let mut node = node("alice", alice, allocations);
 
     assert_eq!(node.status().mining.automatic_burn_fee, 1);
 
     node.set_burn_per_block(1).unwrap();
     assert_eq!(node.status().mining.burn_per_block, 1);
     assert_eq!(node.status().mining.automatic_burn_fee, 1);
 
     node.set_automatic_burn(50, 3).unwrap();
     assert_eq!(node.status().mining.burn_per_block, 50);
     assert_eq!(node.status().mining.automatic_burn_fee, 3);
 }
 
 #[test]
 fn automatic_mining_uses_configured_burn_fee() {
     let alice = Wallet::from_seed("auto-fee-burn-alice");
     let bob = Wallet::from_seed("auto-fee-burn-leader");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), MICRO_IUNA);
     allocations.insert(bob.address().to_string(), MICRO_IUNA);
     let ledger = Ledger::new_with_genesis_burns(
         allocations,
         vec![GenesisBurn::new(bob.address(), MICRO_IUNA)],
         25,
     )
     .unwrap();
     assert_eq!(
         ledger.expected_leader_for_next_block().as_deref(),
         Some(bob.address())
     );
     let mut node = NodeCore::from_ledger_with_burn_fee_and_enabled(alice, ledger, true, 50, 3);
 
     let outcome = node.automatic_mine_once(1);
     let burned = outcome.burned.as_ref().unwrap();
     assert_eq!(burned.amount(), 50);
     assert!(burned.fee() > burned.economic_size_bytes() as u64 * 3);
     assert!(outcome.block.is_none());
     assert_eq!(node.ledger().pending_blinded_transactions().len(), 1);
 }
 
 #[test]
 fn automatic_mining_caps_burn_to_spendable_balance_after_fee() {
     let alice = Wallet::from_seed("auto-burn-cap-alice");
     let bob = Wallet::from_seed("auto-burn-cap-leader");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), BLOCK_REWARD);
     allocations.insert(bob.address().to_string(), MICRO_IUNA);
     let ledger = Ledger::new_with_genesis_burns(
         allocations,
         vec![GenesisBurn::new(bob.address(), MICRO_IUNA)],
         10,
     )
     .unwrap();
     assert_eq!(
         ledger.expected_leader_for_next_block().as_deref(),
         Some(bob.address())
     );
     let planning_node = NodeCore::from_ledger_with_burn_fee_and_enabled(
         alice.clone(),
         ledger.clone(),
         true,
         BLOCK_REWARD + iuna(50),
         DEFAULT_FEE_PER_BYTE,
     );
     let mut node = NodeCore::from_ledger_with_burn_fee_and_enabled(
         alice.clone(),
         ledger,
         true,
         BLOCK_REWARD + iuna(50),
         DEFAULT_FEE_PER_BYTE,
     );
 
     let outcome = node.automatic_mine_once(1);
 
     let burned = outcome.burned.as_ref().unwrap();
     let next_amount = burned.amount() + 1;
     if let Ok(next_estimate) = planning_node.estimate_burn_fee(next_amount, DEFAULT_FEE_PER_BYTE) {
         assert!(next_amount + next_estimate.fee > BLOCK_REWARD);
     }
     assert!(burned.fee() > burned.economic_size_bytes() as u64 * DEFAULT_FEE_PER_BYTE);
     assert!(outcome.block.is_none());
     assert_eq!(node.ledger().pending_blinded_transactions().len(), 1);
 }
 
 #[test]
 fn automatic_mining_preserves_configured_burn_when_only_fee_is_short() {
     let alice = Wallet::from_seed("auto-burn-exact-target-alice");
     let bob = Wallet::from_seed("auto-burn-exact-target-leader");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), MICRO_IUNA);
     allocations.insert(bob.address().to_string(), MICRO_IUNA);
     let ledger = Ledger::new_with_genesis_burns(
         allocations,
         vec![GenesisBurn::new(bob.address(), MICRO_IUNA)],
         10,
     )
     .unwrap();
     assert_eq!(
         ledger.expected_leader_for_next_block().as_deref(),
         Some(bob.address())
     );
     let mut node = NodeCore::from_ledger_with_burn_fee_and_enabled(
         alice.clone(),
         ledger,
         true,
         MICRO_IUNA,
         DEFAULT_FEE_PER_BYTE,
     );
 
     let outcome = node.automatic_mine_once(1);
 
     let burned = outcome.burned.as_ref().unwrap();
     assert_eq!(burned.amount(), MICRO_IUNA);
     assert_eq!(burned.fee(), 0);
     assert!(outcome.block.is_none());
     assert_eq!(node.ledger().pending_blinded_transactions().len(), 1);
 }
 
 #[test]
 fn setting_burn_rate_after_running_at_zero_prepares_private_anchor_burn() {
     let alice = Wallet::from_seed("alice");
     let bob = Wallet::from_seed("bob");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), MICRO_IUNA);
     allocations.insert(bob.address().to_string(), MICRO_IUNA);
 
     let mut ledger = Ledger::new(allocations.clone(), 25);
     submit_burn(&mut ledger, &alice, 1);
     let first = ledger.mine_next_block(&alice, 1).unwrap();
     ledger.apply_block(first).unwrap();
 
     let mut alice_node = node("alice", alice.clone(), allocations);
     alice_node
         .receive(iuna::app::GossipEnvelope::ChainSnapshot(ledger.snapshot()))
         .unwrap();
 
     let skipped = alice_node.automatic_mine_once(2);
     assert!(skipped.burned.is_none());
     assert!(skipped.block.is_none());
 
     let burned = alice_node.set_burn_per_block(1).unwrap();
 
     assert!(burned.is_some());
     assert!(alice_node.ledger().pending().is_empty());
     let outcome = alice_node.automatic_mine_once(2);
     assert!(outcome.block.is_some());
 }
 
 #[test]
 fn automatic_mining_waits_when_wallet_is_not_selected_leader() {
     let alice = Wallet::from_seed("alice");
     let bob = Wallet::from_seed("bob");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), 1_000);
     allocations.insert(bob.address().to_string(), MICRO_IUNA);
 
     let mut ledger = Ledger::new(allocations.clone(), 25);
     submit_burn(&mut ledger, &alice, 1);
     let first = ledger.mine_next_block(&alice, 1).unwrap();
     ledger.apply_block(first).unwrap();
 
     let mut bob_node = node("bob", bob.clone(), allocations);
     bob_node.set_burn_per_block(10).unwrap();
     bob_node
         .receive(iuna::app::GossipEnvelope::Block(ledger.chain()[1].clone()))
         .unwrap();
 
     let outcome = bob_node.automatic_mine_once(2);
     assert!(outcome.burned.is_some());
     assert!(outcome.block.is_none());
     assert!(outcome.skipped_reason.unwrap().contains(alice.address()));
     assert_eq!(bob_node.ledger().chain().len(), 2);
 }
 
 #[test]
 fn waiting_wallet_gossips_pending_burn_to_selected_leader() {
     let alice = Wallet::from_seed("deadlock-alice");
     let bob = Wallet::from_seed("deadlock-bob");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), iuna(1_000));
     allocations.insert(bob.address().to_string(), iuna(1_000));
     let ledger =
         Ledger::new_with_genesis_burns(allocations, vec![GenesisBurn::new(bob.address(), 1)], 25)
             .unwrap();
 
     assert_eq!(
         ledger.expected_leader_for_next_block().as_deref(),
         Some(bob.address())
     );
     let mut alice_node = NodeCore::from_ledger(alice.clone(), ledger.clone(), 1);
     let mut bob_node =
         NodeCore::from_ledger_with_burn_fee_and_enabled(bob.clone(), ledger, true, 1, 1);
 
     let alice_outcome = alice_node.automatic_mine_once(1);
     assert!(alice_outcome.burned.is_some());
     assert!(alice_outcome.block.is_none());
     assert!(
         alice_outcome
             .skipped_reason
             .unwrap()
             .contains(bob.address())
     );
     assert!(bob_node.ledger().pending().is_empty());
 
     for envelope in alice_node.mempool_gossip() {
         bob_node.receive(envelope).unwrap();
     }
 
     assert!(bob_node.ledger().pending().is_empty());
     assert_eq!(bob_node.ledger().pending_blinded_transactions().len(), 1);
     let bob_outcome = bob_node.automatic_mine_once(1);
     assert!(bob_outcome.skipped_reason.is_none());
     assert!(bob_outcome.block.is_some());
 }
 
 #[test]
 fn pow_only_node_gossips_mine_action_to_pob_only_finalizer() {
     let alice = Wallet::from_seed("pob-only-finalizer-alice");
     let bob = Wallet::from_seed("pow-only-miner-bob");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), 2 * MICRO_IUNA);
     let ledger = Ledger::new_with_genesis_burns(
         allocations,
         vec![GenesisBurn::new(alice.address(), MICRO_IUNA)],
         25,
     )
     .unwrap();
 
     assert_eq!(
         ledger.expected_leader_for_next_block().as_deref(),
         Some(alice.address())
     );
     let mut alice_node = NodeCore::from_ledger_with_burn_fee_and_enabled(
         alice,
         ledger.clone(),
         true,
         DEFAULT_BURN_PER_BLOCK,
         DEFAULT_FEE_PER_BYTE,
     );
     let mut bob_node = NodeCore::from_ledger_with_burn_fee_and_enabled(
         bob.clone(),
         ledger,
         false,
         DEFAULT_BURN_PER_BLOCK,
         DEFAULT_FEE_PER_BYTE,
     );
     bob_node.set_pow_mining_enabled(true);
 
     let bob_plan = (1..10_000)
         .map(|timestamp| bob_node.prepare_automatic_mining(timestamp))
         .find(|plan| plan.pow_mined.is_some())
         .expect("B should eventually queue a mine action");
     let mine = bob_plan.pow_mined.expect("B should queue a mine action");
     assert_eq!(
         bob_plan.skipped_reason.as_deref(),
         Some("automatic mining is off")
     );
     assert!(alice_node.ledger().pending().is_empty());
 
     for envelope in bob_node.drain_outbox() {
         alice_node.receive(envelope).unwrap();
     }
 
     assert!(!alice_node.ledger().pending().is_empty());
     assert!(
         alice_node
             .ledger()
             .pending_blinded_transactions()
             .is_empty()
     );
     assert!(
         alice_node
             .ledger()
             .pending()
             .iter()
             .any(|tx| tx.signature() == mine.signature())
     );
 }
 
 #[test]
 fn block_with_wrong_vdf_rounds_is_rejected() {
     let wallet = Wallet::from_seed("alice");
     let mut genesis = BTreeMap::new();
     genesis.insert(wallet.address().to_string(), 1_000);
     let mut ledger =
         Ledger::new_with_genesis_burns(genesis, vec![GenesisBurn::new(wallet.address(), 1)], 25)
             .unwrap();
     submit_burn(&mut ledger, &wallet, 1);
 
     let mut block = ledger.mine_next_block(&wallet, 1).unwrap();
     block.vdf_rounds = 1;
     block.hash = block.compute_hash();
     block.vdf_output = run_vdf(&block.vdf_seed(), block.vdf_rounds);
 
     assert!(ledger.apply_block(block).is_err());
 }
 
 #[test]
 fn fallback_finalizer_can_build_block_with_extra_vdf_rounds() {
     let alice = Wallet::from_seed("fallback-finalizer-alice");
     let bob = Wallet::from_seed("fallback-finalizer-bob");
     let wallets = [&alice, &bob];
     let mut genesis = BTreeMap::new();
     genesis.insert(alice.address().to_string(), iuna(10));
     genesis.insert(bob.address().to_string(), iuna(10));
     let mut ledger = Ledger::new_with_genesis_burns(
         genesis,
         vec![
             GenesisBurn::new(alice.address(), 1),
             GenesisBurn::new(bob.address(), 1),
         ],
         25,
     )
     .unwrap();
     let leader = ledger.expected_leader_for_next_block().unwrap();
     let fallback = wallets
         .into_iter()
         .find(|wallet| wallet.address() != leader)
         .unwrap();
 
     submit_burn(&mut ledger, fallback, 1);
     let block = ledger.mine_next_block(fallback, 1).unwrap();
 
     assert_eq!(block.miner, fallback.address());
     assert_eq!(block.finalizer_rank, 1);
     assert_eq!(block.vdf_rounds, 50);
     ledger.apply_block(block).unwrap();
 }
 
 #[test]
 fn fallback_finalizer_with_primary_vdf_rounds_is_rejected() {
     let alice = Wallet::from_seed("fallback-rounds-alice");
     let bob = Wallet::from_seed("fallback-rounds-bob");
     let wallets = [&alice, &bob];
     let mut genesis = BTreeMap::new();
     genesis.insert(alice.address().to_string(), iuna(10));
     genesis.insert(bob.address().to_string(), iuna(10));
     let mut ledger = Ledger::new_with_genesis_burns(
         genesis,
         vec![
             GenesisBurn::new(alice.address(), 1),
             GenesisBurn::new(bob.address(), 1),
         ],
         25,
     )
     .unwrap();
     let leader = ledger.expected_leader_for_next_block().unwrap();
     let fallback = wallets
         .into_iter()
         .find(|wallet| wallet.address() != leader)
         .unwrap();
 
     submit_burn(&mut ledger, fallback, 1);
     let mut block = ledger.mine_next_block(fallback, 1).unwrap();
     block.vdf_rounds = 25;
     block.vdf_output = run_vdf(&block.vdf_seed(), block.vdf_rounds);
     block.hash = block.compute_hash();
 
     let error = ledger.apply_block(block).unwrap_err();
     assert!(format!("{error:#}").contains("block VDF rounds are invalid"));
 }
 
 #[test]
 fn fallback_finalizer_unblocks_network_when_primary_does_not_publish() {
     let alice = Wallet::from_seed("fallback-network-alice");
     let bob = Wallet::from_seed("fallback-network-bob");
     let wallets = [&alice, &bob];
     let mut genesis = BTreeMap::new();
     genesis.insert(alice.address().to_string(), iuna(10));
     genesis.insert(bob.address().to_string(), iuna(10));
     let ledger = Ledger::new_with_genesis_burns(
         genesis,
         vec![
             GenesisBurn::new(alice.address(), 1),
             GenesisBurn::new(bob.address(), 1),
         ],
         25,
     )
     .unwrap();
     let primary = ledger.expected_leader_for_next_block().unwrap();
     let fallback = wallets
         .into_iter()
         .find(|wallet| wallet.address() != primary)
         .unwrap();
     let primary_wallet = wallets
         .into_iter()
         .find(|wallet| wallet.address() == primary)
         .unwrap();
 
     let mut network = InMemoryNetwork::default();
     network.insert(
         "primary",
         NodeCore::from_ledger(
             primary_wallet.clone(),
             ledger.clone(),
             DEFAULT_BURN_PER_BLOCK,
         ),
     );
     network.insert(
         "fallback",
         NodeCore::from_ledger(fallback.clone(), ledger, DEFAULT_BURN_PER_BLOCK),
     );
 
     queue_plaintext_burn(network.node_mut("fallback").unwrap(), fallback, 1);
     let block = network
         .node_mut("fallback")
         .unwrap()
         .mine_one_at(1)
         .unwrap();
     assert_eq!(block.finalizer_rank, 1);
     assert_eq!(block.miner, fallback.address());
     network.deliver_until_idle().unwrap();
 
     let tip = network.node("fallback").unwrap().ledger().status().tip_hash;
     for id in ["primary", "fallback"] {
         let status = network.node(id).unwrap().ledger().status();
         assert_eq!(status.height, 1, "{id} did not accept fallback block");
         assert_eq!(status.tip_hash, tip, "{id} has a different tip");
     }
 }
 
 #[test]
 fn recovery_block_is_rejected_before_timeout() {
     let alice = Wallet::from_seed("recovery-before-timeout-alice");
     let bob = Wallet::from_seed("recovery-before-timeout-bob");
     let mut genesis = BTreeMap::new();
     genesis.insert(alice.address().to_string(), iuna(10));
     genesis.insert(bob.address().to_string(), iuna(10));
     let mut ledger =
         Ledger::new_with_genesis_burns(genesis, vec![GenesisBurn::new(alice.address(), 1)], 25)
             .unwrap();
 
     submit_burn(&mut ledger, &bob, 1);
     let error = ledger
         .mine_recovery_block(&bob, RECOVERY_BLOCK_DELAY_MS - 1)
         .unwrap_err();
 
     assert!(format!("{error:#}").contains("recovery block is not available"));
 }
 
 #[test]
 fn recovery_block_unblocks_chain_when_only_ticket_holder_stops() {
     let alice = Wallet::from_seed("recovery-unblocks-alice");
     let bob = Wallet::from_seed("recovery-unblocks-bob");
     let mut genesis = BTreeMap::new();
     genesis.insert(alice.address().to_string(), iuna(10));
     genesis.insert(bob.address().to_string(), iuna(10));
     let mut ledger =
         Ledger::new_with_genesis_burns(genesis, vec![GenesisBurn::new(alice.address(), 1)], 25)
             .unwrap();
 
     assert_eq!(
         ledger.expected_leader_for_next_block().as_deref(),
         Some(alice.address())
     );
     submit_burn(&mut ledger, &bob, 1);
     assert!(ledger.mine_next_block(&bob, 1).is_err());
 
     let block = ledger
         .mine_recovery_block(&bob, RECOVERY_BLOCK_DELAY_MS)
         .unwrap();
 
     assert_eq!(block.miner, bob.address());
     assert_eq!(block.finalizer_mode, FinalizerMode::Recovery);
     assert_eq!(block.finalizer_rank, 0);
     assert_eq!(block.vdf_rounds, 25);
     assert!(block.leader_proof.is_none());
     ledger.apply_block(block).unwrap();
     assert_eq!(ledger.status().height, 1);
 }
 
 #[test]
 fn recovery_block_requires_finalizer_own_burn() {
     let alice = Wallet::from_seed("recovery-own-burn-alice");
     let bob = Wallet::from_seed("recovery-own-burn-bob");
     let mut genesis = BTreeMap::new();
     genesis.insert(alice.address().to_string(), iuna(10));
     genesis.insert(bob.address().to_string(), iuna(10));
     let mut ledger =
         Ledger::new_with_genesis_burns(genesis, vec![GenesisBurn::new(alice.address(), 1)], 25)
             .unwrap();
 
     submit_burn(&mut ledger, &alice, 1);
     let error = ledger
         .mine_recovery_block(&bob, RECOVERY_BLOCK_DELAY_MS)
         .unwrap_err();
 
     assert!(format!("{error:#}").contains("burn from the finalizer"));
 }
 
 #[test]
 fn recovery_block_prioritizes_finalizer_own_burn() {
     let alice = Wallet::from_seed("recovery-prioritizes-alice");
     let bob = Wallet::from_seed("recovery-prioritizes-bob");
     let mut genesis = BTreeMap::new();
     genesis.insert(alice.address().to_string(), iuna(10));
     genesis.insert(bob.address().to_string(), iuna(10));
     let mut ledger =
         Ledger::new_with_genesis_burns(genesis, vec![GenesisBurn::new(alice.address(), 1)], 25)
             .unwrap();
 
     let alice_burn = ledger.build_burn(&alice, 1, 1).unwrap();
     ledger.submit_transaction(alice_burn).unwrap();
     let bob_burn = ledger.build_burn(&bob, 1, 0).unwrap();
     let bob_burn_signature = bob_burn.signature().to_string();
     ledger.submit_transaction(bob_burn).unwrap();
 
     let block = ledger
         .mine_recovery_block(&bob, RECOVERY_BLOCK_DELAY_MS)
         .unwrap();
 
     assert!(
         block
             .transactions
             .iter()
             .any(|tx| tx.signature() == bob_burn_signature)
     );
 }
 
 #[test]
 fn recovery_vdf_seed_is_bound_to_timestamp() {
     let alice = Wallet::from_seed("recovery-vdf-seed-alice");
     let bob = Wallet::from_seed("recovery-vdf-seed-bob");
     let mut genesis = BTreeMap::new();
     genesis.insert(alice.address().to_string(), iuna(10));
     genesis.insert(bob.address().to_string(), iuna(10));
     let mut ledger =
         Ledger::new_with_genesis_burns(genesis, vec![GenesisBurn::new(alice.address(), 1)], 25)
             .unwrap();
 
     submit_burn(&mut ledger, &bob, 1);
     let mut block = ledger
         .mine_recovery_block(&bob, RECOVERY_BLOCK_DELAY_MS)
         .unwrap();
     block.timestamp_ms += 1;
     block.hash = block.compute_hash();
 
     let error = ledger.apply_block(block).unwrap_err();
     assert!(format!("{error:#}").contains("block VDF output is invalid"));
 }
 
 #[test]
 fn fork_choice_prefers_ticket_block_over_recovery_block_at_same_height() {
     let alice = Wallet::from_seed("recovery-fork-alice");
     let bob = Wallet::from_seed("recovery-fork-bob");
     let wallets = [&alice, &bob];
     let mut genesis = BTreeMap::new();
     genesis.insert(alice.address().to_string(), iuna(10));
     genesis.insert(bob.address().to_string(), iuna(10));
     let common = Ledger::new_with_genesis_burns(
         genesis,
         vec![
             GenesisBurn::new(alice.address(), 1),
             GenesisBurn::new(bob.address(), 1),
         ],
         25,
     )
     .unwrap();
     let leader_address = common.expected_leader_for_next_block().unwrap();
     let leader = wallets
         .iter()
         .copied()
         .find(|wallet| wallet.address() == leader_address)
         .unwrap();
     let recovery = wallets
         .into_iter()
         .find(|wallet| wallet.address() != leader_address)
         .unwrap();
 
     let mut local = common.clone();
     submit_burn(&mut local, recovery, 1);
     let recovery_block = local
         .mine_recovery_block(recovery, RECOVERY_BLOCK_DELAY_MS)
         .unwrap();
     assert_eq!(recovery_block.finalizer_mode, FinalizerMode::Recovery);
     local.apply_block(recovery_block).unwrap();
 
     let mut remote = common;
     submit_burn(&mut remote, leader, 1);
     let leader_block = remote.mine_next_block(leader, 1).unwrap();
     assert_eq!(leader_block.finalizer_mode, FinalizerMode::Ticket);
     let leader_hash = leader_block.hash.clone();
     remote.apply_block(leader_block).unwrap();
 
     assert!(local.extend_from_snapshot(remote.snapshot()).unwrap());
     assert_eq!(local.status().tip_hash, leader_hash);
 }
 
 #[test]
 fn fork_choice_prefers_primary_finalizer_over_fallback_rank() {
     let alice = Wallet::from_seed("fallback-fork-alice");
     let bob = Wallet::from_seed("fallback-fork-bob");
     let wallets = [&alice, &bob];
     let mut genesis = BTreeMap::new();
     genesis.insert(alice.address().to_string(), iuna(10));
     genesis.insert(bob.address().to_string(), iuna(10));
     let common = Ledger::new_with_genesis_burns(
         genesis,
         vec![
             GenesisBurn::new(alice.address(), 1),
             GenesisBurn::new(bob.address(), 1),
         ],
         25,
     )
     .unwrap();
     let leader_address = common.expected_leader_for_next_block().unwrap();
     let leader = wallets
         .iter()
         .copied()
         .find(|wallet| wallet.address() == leader_address)
         .unwrap();
     let fallback = wallets
         .into_iter()
         .find(|wallet| wallet.address() != leader_address)
         .unwrap();
 
     let mut local = common.clone();
     submit_burn(&mut local, fallback, 1);
     let fallback_block = local.mine_next_block(fallback, 1).unwrap();
     assert_eq!(fallback_block.finalizer_rank, 1);
     local.apply_block(fallback_block).unwrap();
 
     let mut remote = common;
     submit_burn(&mut remote, leader, 1);
     let leader_block = remote.mine_next_block(leader, 1).unwrap();
     assert_eq!(leader_block.finalizer_rank, 0);
     let leader_hash = leader_block.hash.clone();
     remote.apply_block(leader_block).unwrap();
 
     assert!(local.extend_from_snapshot(remote.snapshot()).unwrap());
     assert_eq!(local.status().tip_hash, leader_hash);
 }
 
 #[test]
 fn vdf_solution_verifies_without_rerunning_delay() {
     let solution = run_vdf("test-seed", 128);
 
     assert!(verify_vdf("test-seed", 128, &solution));
     assert!(!verify_vdf("other-seed", 128, &solution));
     assert!(!verify_vdf("test-seed", 129, &solution));
     assert!(!verify_vdf("test-seed", 128, "not-a-vdf-solution"));
 }
 
 #[test]
 fn vdf_rounds_retarget_toward_target_block_time() {
     let wallet = Wallet::from_seed("alice");
     let mut genesis = BTreeMap::new();
     genesis.insert(wallet.address().to_string(), 1_000);
     let mut ledger = Ledger::new(genesis, 100);
 
     submit_burn(&mut ledger, &wallet, 1);
     let block1 = ledger
         .mine_next_block(&wallet, VDF_TARGET_BLOCK_MS)
         .unwrap();
     assert_eq!(block1.vdf_rounds, 100);
     ledger.apply_block(block1).unwrap();
     assert_eq!(ledger.vdf_rounds(), 100);
 
     submit_burn(&mut ledger, &wallet, 1);
     let block2 = ledger
         .mine_next_block(&wallet, VDF_TARGET_BLOCK_MS + VDF_TARGET_BLOCK_MS / 2)
         .unwrap();
     assert_eq!(block2.vdf_rounds, 100);
     ledger.apply_block(block2).unwrap();
     assert_eq!(ledger.vdf_rounds(), 102);
 
     submit_burn(&mut ledger, &wallet, 1);
     let block3 = ledger
         .mine_next_block(
             &wallet,
             VDF_TARGET_BLOCK_MS + VDF_TARGET_BLOCK_MS / 2 + VDF_TARGET_BLOCK_MS * 2,
         )
         .unwrap();
     assert_eq!(block3.vdf_rounds, 102);
     ledger.apply_block(block3).unwrap();
     assert_eq!(ledger.vdf_rounds(), 100);
 }
 
 #[test]
 fn block_timestamp_too_far_in_future_is_rejected() {
     let wallet = Wallet::from_seed("future-timestamp-alice");
     let mut genesis = BTreeMap::new();
     genesis.insert(wallet.address().to_string(), 1_000);
     let mut ledger = Ledger::new(genesis, 25);
     submit_burn(&mut ledger, &wallet, 1);
 
     let far_future = unix_now_ms()
         .saturating_add(VDF_TARGET_BLOCK_MS)
         .saturating_add(1);
     let block = ledger.mine_next_block(&wallet, far_future).unwrap();
 
     let error = ledger.apply_block(block).unwrap_err();
 
     assert!(format!("{error:#}").contains("too far in the future"));
 }
 
 #[test]
 fn genesis_wall_clock_gap_does_not_lower_vdf_rounds() {
     let wallet = Wallet::from_seed("genesis-gap-vdf-alice");
     let mut genesis = BTreeMap::new();
     genesis.insert(wallet.address().to_string(), 1_000);
     let mut ledger = Ledger::new(genesis, 100);
     let now = unix_now_ms();
     let first_timestamp = now.saturating_sub(VDF_TARGET_BLOCK_MS);
 
     submit_burn(&mut ledger, &wallet, 1);
     let block1 = ledger.mine_next_block(&wallet, first_timestamp).unwrap();
     ledger.apply_block(block1).unwrap();
     assert_eq!(ledger.vdf_rounds(), 100);
 
     submit_burn(&mut ledger, &wallet, 1);
     let block2 = ledger.mine_next_block(&wallet, now).unwrap();
     ledger.apply_block(block2).unwrap();
 
     assert_eq!(ledger.vdf_rounds(), 100);
 }
 
 #[test]
 fn conflicting_utxo_spends_are_not_accepted_together() {
     let wallet = Wallet::from_seed("alice");
     let mut genesis = BTreeMap::new();
     genesis.insert(wallet.address().to_string(), 1_000);
     let mut ledger = Ledger::new(genesis, 25);
 
     let first = burn_tx(&ledger, &wallet, 3);
     let conflicting = burn_tx(&ledger, &wallet, 4);
     ledger.submit_transaction(first.clone()).unwrap();
     let outcome = ledger
         .submit_transaction_with_outcome(conflicting.clone())
         .unwrap();
     assert_eq!(outcome, TransactionSubmitOutcome::ConflictsWithPending);
     assert!(!ledger.submit_transaction(conflicting).unwrap());
     assert_eq!(ledger.pending().len(), 1);
 
     let block = ledger
         .prepare_next_block(wallet.address(), 1)
         .unwrap()
         .finish(&wallet, "test-vdf".to_string());
     assert_eq!(block.transactions.len(), 1);
     assert!(block.transactions.contains(&first));
 }
 
 #[test]
 fn in_memory_network_syncs_nodes_without_tcp() {
     let alice = Wallet::from_seed("alice");
     let bob = Wallet::from_seed("bob");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), 1_000);
     allocations.insert(bob.address().to_string(), 1_000);
 
     let mut network = InMemoryNetwork::default();
     network.insert("alice", node("alice", alice.clone(), allocations.clone()));
     network.insert("bob", node("bob", bob.clone(), allocations));
 
     queue_plaintext_burn(network.node_mut("alice").unwrap(), &alice, 10);
     network.deliver_until_idle().unwrap();
     assert!(network.node("bob").unwrap().ledger().pending().is_empty());
 
     network.node_mut("alice").unwrap().mine_one().unwrap();
     network.deliver_until_idle().unwrap();
 
     let alice_tip = network.node("alice").unwrap().ledger().status().tip_hash;
     let bob_tip = network.node("bob").unwrap().ledger().status().tip_hash;
     assert_eq!(alice_tip, bob_tip);
     assert_eq!(network.node("bob").unwrap().ledger().chain().len(), 2);
 }
 
 #[test]
 fn in_memory_network_delivers_transaction_to_multiple_peers() {
     let wallets = wallets(&["alice", "bob", "carol", "dave"]);
     let allocations = allocations(&wallets, MICRO_IUNA);
     let mut network = InMemoryNetwork::default();
 
     for (name, wallet) in ["alice", "bob", "carol", "dave"]
         .iter()
         .zip(wallets.clone())
     {
         network.insert(*name, node(name, wallet, allocations.clone()));
     }
 
     network.node_mut("alice").unwrap().burn(15).unwrap();
     network.deliver_until_idle().unwrap();
 
     for name in ["bob", "carol", "dave"] {
         let ledger = network.node(name).unwrap().ledger();
         assert!(
             ledger.pending().is_empty(),
             "{name} received a plaintext transaction"
         );
         assert_eq!(
             ledger.pending_blinded_transactions().len(),
             1,
             "{name} did not receive alice's blinded burn"
         );
     }
 }
 
 #[test]
 fn in_memory_network_syncs_mined_block_to_multiple_peers() {
     let wallets = wallets(&["alice", "bob", "carol", "dave"]);
     let allocations = allocations(&wallets, MICRO_IUNA);
     let mut network = InMemoryNetwork::default();
 
     for (name, wallet) in ["alice", "bob", "carol", "dave"]
         .iter()
         .zip(wallets.clone())
     {
         network.insert(*name, node(name, wallet, allocations.clone()));
     }
 
     queue_plaintext_burn(network.node_mut("alice").unwrap(), &wallets[0], 10);
     network.deliver_until_idle().unwrap();
     network.node_mut("alice").unwrap().mine_one().unwrap();
     network.deliver_until_idle().unwrap();
 
     let tip = network.node("alice").unwrap().ledger().status().tip_hash;
     for name in ["alice", "bob", "carol", "dave"] {
         let ledger = network.node(name).unwrap().ledger();
         assert_eq!(ledger.status().height, 1, "{name} is at the wrong height");
         assert_eq!(ledger.status().tip_hash, tip, "{name} has a different tip");
         assert!(
             ledger.pending().is_empty(),
             "{name} kept mined transactions"
         );
     }
 }
 
 #[test]
 fn in_memory_network_range_syncs_node_that_missed_multiple_blocks() {
     let alice = Wallet::from_seed("alice");
     let bob = Wallet::from_seed("bob");
     let wallets = vec![alice.clone(), bob];
     let allocations = allocations(&wallets, 1_000);
     let mut network = InMemoryNetwork::default();
 
     network.insert("alice", node("alice", alice.clone(), allocations.clone()));
     network.insert("bob", node("bob", wallets[1].clone(), allocations));
 
     for height in 1..=5 {
         let alice_node = network.node_mut("alice").unwrap();
         queue_plaintext_burn(alice_node, &alice, 1);
         alice_node
             .mine_one_at(height * VDF_TARGET_BLOCK_MS)
             .unwrap();
     }
     assert_eq!(network.node("alice").unwrap().ledger().status().height, 5);
     assert_eq!(network.node("bob").unwrap().ledger().status().height, 0);
 
     assert!(network.sync_node_from_peer("alice", "bob", 2).unwrap());
     assert_eq!(network.node("bob").unwrap().ledger().status().height, 2);
 
     assert!(network.sync_node_from_peer("alice", "bob", 10).unwrap());
     let alice_tip = network.node("alice").unwrap().ledger().status().tip_hash;
     let bob_status = network.node("bob").unwrap().ledger().status();
     assert_eq!(bob_status.height, 5);
     assert_eq!(bob_status.tip_hash, alice_tip);
 
     network.deliver_until_idle().unwrap();
     queue_plaintext_burn(network.node_mut("alice").unwrap(), &alice, 1);
     network.deliver_until_idle().unwrap();
     network
         .node_mut("alice")
         .unwrap()
         .mine_one_at(6 * VDF_TARGET_BLOCK_MS)
         .unwrap();
     network.deliver_until_idle().unwrap();
 
     let alice_tip = network.node("alice").unwrap().ledger().status().tip_hash;
     let bob_status = network.node("bob").unwrap().ledger().status();
     assert_eq!(bob_status.height, 6);
     assert_eq!(bob_status.tip_hash, alice_tip);
 }
 
 #[test]
 fn joined_nodes_import_transfer_block_and_blinded_burn_reveal() {
     let alice = Wallet::from_seed("flow-alice");
     let bob = Wallet::from_seed("flow-bob");
     let carol = Wallet::from_seed("flow-carol");
     let mut genesis = BTreeMap::new();
     genesis.insert(alice.address().to_string(), iuna(100));
     let alice_ledger = Ledger::new_with_genesis_burns(
         genesis,
         vec![GenesisBurn::new(alice.address(), MICRO_IUNA)],
         5,
     )
     .unwrap();
 
     let mut network = InMemoryNetwork::default();
     network.insert(
         "a",
         NodeCore::from_ledger(alice.clone(), alice_ledger, DEFAULT_BURN_PER_BLOCK),
     );
     let mut mined_by = Vec::new();
 
     for height in 1..=2 {
         queue_plaintext_burn(network.node_mut("a").unwrap(), &alice, 1);
         network.deliver_until_idle().unwrap();
         let block = network.node_mut("a").unwrap().mine_one_at(height).unwrap();
         mined_by.push(block.miner.clone());
         network.deliver_until_idle().unwrap();
     }
 
     let bob_ledger = Ledger::from_snapshot(network.node("a").unwrap().chain_snapshot()).unwrap();
     network.insert(
         "b",
         NodeCore::from_ledger(bob.clone(), bob_ledger, DEFAULT_BURN_PER_BLOCK),
     );
 
     for height in 3..=4 {
         queue_plaintext_burn(network.node_mut("a").unwrap(), &alice, 1);
         network.deliver_until_idle().unwrap();
         let block = network.node_mut("a").unwrap().mine_one_at(height).unwrap();
         mined_by.push(block.miner.clone());
         network.deliver_until_idle().unwrap();
     }
 
     let carol_ledger = Ledger::from_snapshot(network.node("a").unwrap().chain_snapshot()).unwrap();
     network.insert(
         "c",
         NodeCore::from_ledger(carol.clone(), carol_ledger, DEFAULT_BURN_PER_BLOCK),
     );
 
     queue_plaintext_transfer(
         network.node_mut("a").unwrap(),
         &alice,
         bob.address(),
         iuna(30),
     );
     queue_plaintext_burn(network.node_mut("a").unwrap(), &alice, 1);
     let block5 = network.node_mut("a").unwrap().mine_one_at(5).unwrap();
     assert!(
         block5
             .transactions
             .iter()
             .any(|tx| tx.to() == Some(bob.address()) && tx.amount() == iuna(30))
     );
     mined_by.push(block5.miner.clone());
     network.deliver_until_idle().unwrap();
 
     for id in ["a", "b", "c"] {
         assert_eq!(
             network.node(id).unwrap().ledger().status().height,
             5,
             "{id} did not import block 5"
         );
         assert_eq!(
             network.node(id).unwrap().ledger().balance_of(bob.address()),
             iuna(30),
             "{id} did not apply A -> B transfer"
         );
     }
 
     let bob_burn = network.node_mut("b").unwrap().burn(10).unwrap();
     network.deliver_until_idle().unwrap();
     assert_eq!(
         network
             .node("a")
             .unwrap()
             .ledger()
             .pending_blinded_transactions()
             .len(),
         1
     );
 
     queue_plaintext_burn(network.node_mut("a").unwrap(), &alice, 1);
     let commit_block = network.node_mut("a").unwrap().mine_one_at(6).unwrap();
     assert_eq!(commit_block.blinded_transactions.len(), 1);
     assert_eq!(commit_block.blinded_transactions[0].fee, bob_burn.fee());
     mined_by.push(commit_block.miner.clone());
     network.deliver_until_idle().unwrap();
     assert_eq!(
         network
             .node("a")
             .unwrap()
             .ledger()
             .pending_blinded_reveals()
             .len(),
         1
     );
 
     queue_plaintext_burn(network.node_mut("a").unwrap(), &alice, 1);
     let reveal_block = network.node_mut("a").unwrap().mine_one_at(7).unwrap();
     assert_eq!(reveal_block.all_blinded_reveals().len(), 1);
     mined_by.push(reveal_block.miner.clone());
     network.deliver_until_idle().unwrap();
     let revealed = revealed_blinded_transactions(&network.node("a").unwrap().chain_snapshot())
         .unwrap()
         .into_iter()
         .filter(|revealed| revealed.height == 7)
         .collect::<Vec<_>>();
     assert_eq!(revealed.len(), 1);
     assert!(revealed[0].transaction.is_burn(), "{revealed:?}");
     assert_eq!(revealed[0].transaction.amount(), 10);
 
     for height in 8..=9 {
         queue_plaintext_burn(network.node_mut("a").unwrap(), &alice, 1);
         let block = network.node_mut("a").unwrap().mine_one_at(height).unwrap();
         mined_by.push(block.miner.clone());
         network.deliver_until_idle().unwrap();
     }
 
     let final_tip = network.node("a").unwrap().ledger().status().tip_hash;
     for id in ["a", "b", "c"] {
         assert_eq!(network.node(id).unwrap().ledger().status().height, 9);
         assert_eq!(
             network.node(id).unwrap().ledger().status().tip_hash,
             final_tip
         );
     }
     let ranks = network
         .node("a")
         .unwrap()
         .burn_leader_ranks_for_block(10)
         .unwrap();
     assert!(
         ranks.iter().any(|rank| rank.owner == bob.address()
             && rank.amount == 10
             && rank.eligible_from_height == 10),
         "alice={} bob={} ranks={ranks:?}",
         alice.address(),
         bob.address()
     );
     assert!(mined_by.iter().all(|miner| miner == alice.address()));
 }
 
 #[test]
 fn persisted_joined_nodes_restart_and_keep_syncing_without_tcp() {
     let temp = tempdir().unwrap();
     let alice = Wallet::from_seed("persistent-flow-alice");
     let bob = Wallet::from_seed("persistent-flow-bob");
     let carol = Wallet::from_seed("persistent-flow-carol");
     let mut genesis = BTreeMap::new();
     genesis.insert(alice.address().to_string(), 50);
     let alice_ledger =
         Ledger::new_with_genesis_burns(genesis, vec![GenesisBurn::new(alice.address(), 1)], 5)
             .unwrap();
 
     let mut network = InMemoryNetwork::default();
     network.insert(
         "a",
         NodeCore::from_ledger(alice.clone(), alice_ledger, DEFAULT_BURN_PER_BLOCK),
     );
 
     queue_plaintext_burn(network.node_mut("a").unwrap(), &alice, 1);
     network.node_mut("a").unwrap().mine_one_at(1).unwrap();
     network.deliver_until_idle().unwrap();
 
     let bob_store = SqliteChainStore::open(temp.path().join("bob.sqlite3")).unwrap();
     bob_store
         .save(&network.node("a").unwrap().chain_snapshot())
         .unwrap();
     let bob_joined_ledger = Ledger::from_snapshot(bob_store.load().unwrap().unwrap()).unwrap();
     network.insert(
         "b",
         NodeCore::from_ledger(bob.clone(), bob_joined_ledger, DEFAULT_BURN_PER_BLOCK),
     );
     assert_eq!(
         network.node("b").unwrap().ledger().status().tip_hash,
         network.node("a").unwrap().ledger().status().tip_hash
     );
 
     queue_plaintext_transfer(network.node_mut("a").unwrap(), &alice, bob.address(), 10);
     queue_plaintext_burn(network.node_mut("a").unwrap(), &alice, 1);
     network.deliver_until_idle().unwrap();
     network.node_mut("a").unwrap().mine_one_at(2).unwrap();
     network.deliver_until_idle().unwrap();
     assert_eq!(
         network
             .node("b")
             .unwrap()
             .ledger()
             .balance_of(bob.address()),
         10
     );
 
     bob_store
         .save(&network.node("b").unwrap().chain_snapshot())
         .unwrap();
     let bob_restarted_ledger = Ledger::from_snapshot(bob_store.load().unwrap().unwrap()).unwrap();
     network.insert(
         "b",
         NodeCore::from_ledger(bob.clone(), bob_restarted_ledger, DEFAULT_BURN_PER_BLOCK),
     );
     assert_eq!(
         network.node("b").unwrap().ledger().status().tip_hash,
         network.node("a").unwrap().ledger().status().tip_hash,
         "restarted Bob should resume the persisted chain tip"
     );
 
     let carol_store = SqliteChainStore::open(temp.path().join("carol.sqlite3")).unwrap();
     carol_store
         .save(&network.node("a").unwrap().chain_snapshot())
         .unwrap();
     let carol_joined_ledger = Ledger::from_snapshot(carol_store.load().unwrap().unwrap()).unwrap();
     network.insert(
         "c",
         NodeCore::from_ledger(carol, carol_joined_ledger, DEFAULT_BURN_PER_BLOCK),
     );
 
     for height in 3..=6 {
         queue_plaintext_burn(network.node_mut("a").unwrap(), &alice, 1);
         network.node_mut("a").unwrap().mine_one_at(height).unwrap();
         network.deliver_until_idle().unwrap();
     }
 
     let final_status = network.node("a").unwrap().ledger().status();
     for id in ["b", "c"] {
         assert_eq!(
             network.node(id).unwrap().ledger().status().height,
             final_status.height,
             "{id} did not catch up after Bob restarted"
         );
         assert_eq!(
             network.node(id).unwrap().ledger().status().tip_hash,
             final_status.tip_hash,
             "{id} ended on a different tip after Bob restarted"
         );
     }
 
     bob_store
         .save(&network.node("b").unwrap().chain_snapshot())
         .unwrap();
     assert_eq!(
         bob_store
             .load()
             .unwrap()
             .unwrap()
             .blocks
             .last()
             .unwrap()
             .height,
         final_status.height
     );
 }
 
 #[test]
 fn mined_block_gossip_does_not_include_full_chain_snapshot() {
     let alice = Wallet::from_seed("alice");
     let bob = Wallet::from_seed("bob");
     let wallets = vec![alice.clone(), bob.clone()];
     let allocations = allocations(&wallets, MICRO_IUNA);
 
     let mut alice_node = NodeCore::new(NodeConfig {
         wallet: alice,
         genesis_allocations: allocations.clone(),
         vdf_rounds: 10,
         burn_per_block: 1,
         burn_fee: 1,
         pow_mining_workers: 1,
         recovery_vdf_top_rank_percent: 100,
     });
 
     let plan = alice_node.prepare_automatic_mining(1);
     let burn_outbox = alice_node.drain_outbox();
     assert!(burn_outbox.is_empty());
 
     let work = plan.work.unwrap();
     let vdf_output = run_vdf(work.vdf_seed(), work.vdf_rounds());
     alice_node
         .complete_prepared_block(work, vdf_output)
         .unwrap();
     let block_outbox = alice_node.drain_outbox();
 
     assert_eq!(block_outbox.len(), 1);
     assert!(matches!(
         block_outbox[0],
         iuna::app::GossipEnvelope::Block(_)
     ));
 }
 
 #[test]
 fn mempool_gossip_splits_blinded_batches_at_receiver_limit() {
     let alice = Wallet::from_seed("mempool-batch-alice");
     let bob = Wallet::from_seed("mempool-batch-bob");
     let burn_wallets = (0..=TRANSACTION_BATCH_LIMIT)
         .map(|index| Wallet::from_seed(&format!("mempool-batch-burn-{index}")))
         .collect::<Vec<_>>();
     let mut wallets = vec![alice.clone(), bob.clone()];
     wallets.extend(burn_wallets.clone());
     let allocations = allocations(&wallets, 10_000);
     let mut alice_node = node("alice", alice, allocations.clone());
     let mut bob_node = node("bob", bob, allocations);
 
     for wallet in &burn_wallets {
         let tx = alice_node.ledger().build_burn(wallet, 1, 0).unwrap();
         let built = alice_node
             .ledger()
             .build_blinded_transaction(wallet, tx, 20)
             .unwrap();
         alice_node
             .receive_blinded_transaction(built.transaction)
             .unwrap();
     }
     alice_node.drain_outbox();
 
     let gossip = alice_node.mempool_gossip();
     assert_eq!(gossip.len(), 2);
     let total_transactions = gossip
         .iter()
         .map(|envelope| match envelope {
             GossipEnvelope::BlindedTransactions { transactions } => {
                 assert!(transactions.len() <= TRANSACTION_BATCH_LIMIT);
                 transactions.len()
             }
             other => panic!("expected blinded transaction batch, got {other:?}"),
         })
         .sum::<usize>();
     assert_eq!(total_transactions, TRANSACTION_BATCH_LIMIT + 1);
 
     for envelope in gossip {
         bob_node.receive(envelope).unwrap();
     }
     assert!(bob_node.ledger().pending().is_empty());
     assert_eq!(
         bob_node.ledger().pending_blinded_transactions().len(),
         TRANSACTION_BATCH_LIMIT + 1
     );
 }
 
 #[test]
 fn received_block_is_rebroadcast_to_other_peers_without_networking() {
     let names = ["alice", "bob", "carol"];
     let wallets = wallets(&names);
     let allocations = allocations(&wallets, 1_000);
     let alice = wallets[0].clone();
     let bob = wallets[1].clone();
     let carol = wallets[2].clone();
 
     let mut miner = node("alice", alice.clone(), allocations.clone());
     let mut hub = node("bob", bob, allocations.clone());
     let mut carol_node = node("carol", carol, allocations);
 
     queue_plaintext_burn(&mut miner, &alice, 10);
     miner.drain_outbox();
     let block = miner.mine_one_at(1).unwrap();
     miner.drain_outbox();
 
     hub.receive(iuna::app::GossipEnvelope::Block(block.clone()))
         .unwrap();
     let forwarded = hub.drain_outbox();
     assert_eq!(forwarded.len(), 1);
     assert!(matches!(forwarded[0], iuna::app::GossipEnvelope::Block(_)));
 
     for envelope in forwarded {
         carol_node.receive(envelope).unwrap();
     }
     assert_eq!(carol_node.ledger().height(), 1);
     assert_eq!(
         carol_node.ledger().status().tip_hash,
         miner.ledger().status().tip_hash
     );
 
     hub.receive(iuna::app::GossipEnvelope::Block(block))
         .unwrap();
     assert!(hub.drain_outbox().is_empty());
 }
 
 #[test]
 fn imported_snapshot_blocks_are_rebroadcast_without_networking() {
     let alice = Wallet::from_seed("alice");
     let bob = Wallet::from_seed("bob");
     let wallets = vec![alice.clone(), bob.clone()];
     let allocations = allocations(&wallets, 1_000);
     let mut miner = node("alice", alice.clone(), allocations.clone());
     let mut hub = node("bob", bob, allocations);
 
     queue_plaintext_burn(&mut miner, &alice, 1);
     miner.drain_outbox();
     miner.mine_one_at(1).unwrap();
     miner.drain_outbox();
 
     queue_plaintext_burn(&mut miner, &alice, 1);
     miner.drain_outbox();
     miner.mine_one_at(2).unwrap();
     miner.drain_outbox();
 
     hub.import_chain_snapshot(miner.chain_snapshot()).unwrap();
     let outbox = hub.drain_outbox();
     assert_eq!(outbox.len(), 1);
     match &outbox[0] {
         iuna::app::GossipEnvelope::Blocks { blocks } => {
             assert_eq!(blocks.len(), 2);
             assert_eq!(blocks[0].height, 1);
             assert_eq!(blocks[1].height, 2);
         }
         other => panic!("expected imported blocks gossip, got {other:?}"),
     }
 }
 
 #[test]
 fn multiple_peers_can_contribute_blinded_burns_to_lottery_ranks() {
     let finalizer = Wallet::from_seed("blinded-burn-ranks-finalizer");
     let names = ["alice", "bob", "carol", "dave"];
     let wallets = wallets(&names);
     let mut all_wallets = vec![finalizer.clone()];
     all_wallets.extend(wallets.clone());
     let allocations = allocations(&all_wallets, 1_000);
     let ledger = Ledger::new_with_genesis_burns(
         allocations.clone(),
         vec![GenesisBurn::new(finalizer.address(), 1)],
         25,
     )
     .unwrap();
     let mut network = InMemoryNetwork::default();
 
     network.insert(
         "finalizer",
         NodeCore::from_ledger(finalizer.clone(), ledger.clone(), DEFAULT_BURN_PER_BLOCK),
     );
     for (name, wallet) in names.iter().zip(wallets.clone()) {
         network.insert(
             *name,
             NodeCore::from_ledger(wallet, ledger.clone(), DEFAULT_BURN_PER_BLOCK),
         );
     }
 
     for ((name, wallet), amount) in names.iter().zip(wallets.iter()).zip([10, 20, 30, 40]) {
         let tx = network.node_mut(name).unwrap().burn(amount).unwrap();
         assert!(tx.is_burn());
         assert_eq!(tx.sender(), wallet.address());
     }
     network.deliver_until_idle().unwrap();
     assert_eq!(
         network
             .node("alice")
             .unwrap()
             .ledger()
             .pending_blinded_transactions()
             .len(),
         4
     );
 
     queue_plaintext_burn(network.node_mut("finalizer").unwrap(), &finalizer, 1);
     let commit_block = network
         .node_mut("finalizer")
         .unwrap()
         .mine_one_at(1)
         .unwrap();
     assert_eq!(commit_block.blinded_transactions.len(), 4);
     network.deliver_until_idle().unwrap();
 
     assert_eq!(
         network
             .node("alice")
             .unwrap()
             .ledger()
             .pending_blinded_reveals()
             .len(),
         4
     );
     queue_plaintext_burn(network.node_mut("finalizer").unwrap(), &finalizer, 1);
     network.gossip_mempools_once().unwrap();
     network.deliver_until_idle().unwrap();
     let reveal_block = network
         .node_mut("finalizer")
         .unwrap()
         .mine_one_at(2)
         .unwrap();
     assert_eq!(reveal_block.all_blinded_reveals().len(), 4);
     network.deliver_until_idle().unwrap();
 
     for height in 3..=4 {
         queue_plaintext_burn(network.node_mut("finalizer").unwrap(), &finalizer, 1);
         network
             .node_mut("finalizer")
             .unwrap()
             .mine_one_at(height)
             .unwrap();
         network.deliver_until_idle().unwrap();
     }
 
     let final_tip = network
         .node("finalizer")
         .unwrap()
         .ledger()
         .status()
         .tip_hash;
     for name in names {
         let ledger = network.node(name).unwrap().ledger();
         assert_eq!(ledger.status().height, 4);
         assert_eq!(ledger.status().tip_hash, final_tip);
         let ranks = network
             .node(name)
             .unwrap()
             .burn_leader_ranks_for_block(5)
             .unwrap();
         for (wallet, amount) in wallets.iter().zip([10, 20, 30, 40]) {
             assert!(
                 ranks.iter().any(|rank| rank.owner == wallet.address()
                     && rank.amount == amount
                     && rank.eligible_from_height == 5),
                 "{name} missing revealed burn ticket for {} in {ranks:?}",
                 wallet.address()
             );
         }
     }
 }
 
 #[test]
 fn peer_book_tracks_multiple_peers_without_networking() {
     let mut peers = PeerBook::from_addresses(vec![
         "127.0.0.1:9444".to_string(),
         "127.0.0.1:9445".to_string(),
         "127.0.0.1:9444".to_string(),
     ]);
 
     peers.record_sent("127.0.0.1:9444", 2);
     peers.record_status("127.0.0.1:9444", 12, "tip-hash".to_string());
     peers.record_error("127.0.0.1:9445", "connection refused");
     peers.record_received("127.0.0.1:9555", 1);
     peers.record_inbound_error("127.0.0.1:56666", "invalid nonce");
 
     let mut list = peers.list();
     list.sort_by(|left, right| left.address.cmp(&right.address));
     assert_eq!(list.len(), 4);
 
     let outbound_addresses = peers.addresses();
     assert_eq!(outbound_addresses.len(), 2);
     assert!(outbound_addresses.contains(&"127.0.0.1:9444".to_string()));
     assert!(outbound_addresses.contains(&"127.0.0.1:9445".to_string()));
     assert!(!outbound_addresses.contains(&"127.0.0.1:56666".to_string()));
 
     let sent_peer = list
         .iter()
         .find(|peer| peer.address == "127.0.0.1:9444")
         .unwrap();
     assert_eq!(sent_peer.messages_sent, 2);
     assert_eq!(sent_peer.last_known_height, Some(12));
     assert_eq!(sent_peer.last_known_tip_hash.as_deref(), Some("tip-hash"));
     assert_eq!(sent_peer.last_error, None);
     assert!(sent_peer.last_contact_ms.is_some());
     assert!(sent_peer.last_success_ms.is_some());
     assert_eq!(sent_peer.last_error_ms, None);
 
     let failed_peer = list
         .iter()
         .find(|peer| peer.address == "127.0.0.1:9445")
         .unwrap();
     assert_eq!(
         failed_peer.last_error.as_deref(),
         Some("connection refused")
     );
     assert!(failed_peer.last_contact_ms.is_some());
     assert!(failed_peer.last_error_ms.is_some());
 
     let inbound_peer = list
         .iter()
         .find(|peer| peer.address == "127.0.0.1:9555")
         .unwrap();
     assert_eq!(inbound_peer.direction, PeerDirection::Inbound);
     assert_eq!(inbound_peer.messages_received, 1);
     assert!(inbound_peer.last_contact_ms.is_some());
     assert!(inbound_peer.last_success_ms.is_some());
 
     let inbound_error = list
         .iter()
         .find(|peer| peer.address == "127.0.0.1:56666")
         .unwrap();
     assert_eq!(inbound_error.direction, PeerDirection::Inbound);
     assert_eq!(inbound_error.last_error.as_deref(), Some("invalid nonce"));
 
     assert!(peers.remove_peer("127.0.0.1:9445"));
     assert!(!peers.addresses().contains(&"127.0.0.1:9445".to_string()));
     assert!(!peers.remove_peer("127.0.0.1:9555"));
     assert!(
         peers
             .list()
             .iter()
             .any(|peer| peer.address == "127.0.0.1:9555")
     );
 }
 
 #[test]
 fn peer_book_reports_only_connectable_peers_as_outbound() {
     let mut peers = PeerBook::from_addresses(vec!["127.0.0.1:9444".to_string()]);
     peers.record_received("127.0.0.1:56666", 1);
     peers.add_discovered_peer("127.0.0.1:9445");
     peers.record_inbound_misbehavior("127.0.0.1:57777", "invalid transaction");
 
     assert!(peers.is_connectable_peer("127.0.0.1:9444"));
     assert!(peers.is_connectable_peer("127.0.0.1:9445"));
     assert!(!peers.is_connectable_peer("127.0.0.1:56666"));
     assert!(!peers.is_connectable_peer("127.0.0.1:57777"));
     assert!(peers.addresses().contains(&"127.0.0.1:9445".to_string()));
 
     assert!(peers.remove_peer("127.0.0.1:9444"));
     assert!(!peers.is_connectable_peer("127.0.0.1:9444"));
 }
 
 #[test]
 fn peer_book_prunes_stale_inbound_observations() {
     let mut peers = PeerBook::from_addresses(vec!["127.0.0.1:9444".to_string()]);
     peers.record_status("127.0.0.1:9444", 1, "tip".to_string());
     peers.observe_inbound_peer("127.0.0.1:56666");
     peers.record_received("127.0.0.1:57777", 1);
 
     assert_eq!(
         peers.prune_stale_inbound_peers_at(iuna::app::now_ms(), 60_000),
         1
     );
     let listed = peers.list();
 
     assert!(listed.iter().any(|peer| peer.address == "127.0.0.1:9444"));
     assert!(listed.iter().any(|peer| peer.address == "127.0.0.1:57777"));
     assert!(!listed.iter().any(|peer| peer.address == "127.0.0.1:56666"));
 }
 
 #[test]
 fn peer_book_bans_misbehaving_peer_temporarily_and_recovers_on_success() {
     let mut peers = PeerBook::from_addresses(vec!["127.0.0.1:9444".to_string()]);
 
     peers.record_misbehavior_at("127.0.0.1:9444", "invalid transaction", 100);
     peers.record_misbehavior_at("127.0.0.1:9444", "invalid block", 200);
     assert!(!peers.is_banned_at("127.0.0.1:9444", 200));
     assert_eq!(peers.connectable_addresses_at(200), vec!["127.0.0.1:9444"]);
 
     peers.record_misbehavior_at("127.0.0.1:9444", "wrong genesis", 300);
     assert!(peers.is_banned_at("127.0.0.1:9444", 300));
     assert!(peers.connectable_addresses_at(300).is_empty());
     assert_eq!(peers.addresses(), vec!["127.0.0.1:9444"]);
     let banned = peers.list().pop().unwrap();
     assert_eq!(banned.misbehavior_score, 3);
     assert_eq!(banned.ban_reason.as_deref(), Some("wrong genesis"));
 
     assert!(!peers.is_banned_at("127.0.0.1:9444", 11 * 60 * 1_000));
     peers.record_status("127.0.0.1:9444", 1, "tip".to_string());
     let recovered = peers.list().pop().unwrap();
     assert_eq!(recovered.misbehavior_score, 0);
     assert_eq!(recovered.banned_until_ms, None);
 }
 
 #[test]
 fn peer_book_uses_median_accepted_clock_offset() {
     let mut peers = PeerBook::from_addresses(vec![
         "127.0.0.1:9444".to_string(),
         "127.0.0.1:9445".to_string(),
         "127.0.0.1:9446".to_string(),
     ]);
     let now = 1_000_000;
     peers.record_status("127.0.0.1:9444", 1, "tip-a".to_string());
     peers.record_status("127.0.0.1:9445", 1, "tip-b".to_string());
     peers.record_status("127.0.0.1:9446", 1, "tip-c".to_string());
     peers.record_clock_observation("127.0.0.1:9444", PeerDirection::Outbound, now + 1_000, now);
     peers.record_clock_observation("127.0.0.1:9445", PeerDirection::Outbound, now + 2_000, now);
     peers.record_clock_observation(
         "127.0.0.1:9446",
         PeerDirection::Outbound,
         now + 20 * 60 * 1_000,
         now,
     );
 
     assert_eq!(peers.network_time_offset_ms_at(now), Some(2_000));
     assert_eq!(peers.adjusted_time_ms_at(now), now + 2_000);
     assert_eq!(peers.bad_clock_peer_count_at(now), 1);
     assert!(!peers.is_banned_at("127.0.0.1:9446", now));
 }
 
 #[test]
 fn peer_book_address_replacement_keeps_newest_clock_observation() {
     let mut peers = PeerBook::from_addresses(vec![
         "seed.example:9444".to_string(),
         "142.132.164.59:9444".to_string(),
     ]);
     peers.record_clock_observation(
         "seed.example:9444",
         PeerDirection::Outbound,
         1_001_000,
         1_000_000,
     );
     peers.record_clock_observation(
         "142.132.164.59:9444",
         PeerDirection::Outbound,
         2_002_000,
         2_000_000,
     );
 
     peers.replace_peer_address("seed.example:9444", "142.132.164.59:9444");
 
     let peer = peers.list().pop().unwrap();
     assert_eq!(peer.last_clock_offset_ms, Some(2_000));
     assert_eq!(peer.last_clock_observed_ms, Some(2_000_000));
 }
 
 #[test]
 fn chain_snapshot_round_trips_ledger_state() {
     let alice = Wallet::from_seed("alice");
     let mut allocations = BTreeMap::new();
     allocations.insert(alice.address().to_string(), 1_000);
 
     let mut ledger = Ledger::new(allocations, 10);
     submit_burn(&mut ledger, &alice, 10);
     let block = ledger.mine_next_block(&alice, 1).unwrap();
     ledger.apply_block(block).unwrap();
 
     let restored = Ledger::from_snapshot(ledger.snapshot()).unwrap();
     assert_eq!(restored.status().height, ledger.status().height);
     assert_eq!(restored.status().tip_hash, ledger.status().tip_hash);
     assert_eq!(
         restored.balance_of(alice.address()),
         ledger.balance_of(alice.address())
     );
 }
 
 #[test]
 fn friend_node_can_join_snapshot_from_started_chain() {
     let alice = Wallet::from_seed("alice");
     let bob = Wallet::from_seed("bob");
 
     let mut alice_genesis = BTreeMap::new();
     alice_genesis.insert(alice.address().to_string(), 1_000);
     let mut alice_node = node("alice", alice.clone(), alice_genesis);
     alice_node
         .set_automatic_burn_settings(true, DEFAULT_BURN_PER_BLOCK, DEFAULT_FEE_PER_BYTE)
         .unwrap();
     queue_plaintext_burn(&mut alice_node, &alice, 1);
     alice_node.automatic_mine_once(1);
 
     let joined_ledger = Ledger::from_snapshot(alice_node.chain_snapshot()).unwrap();
     let mut bob_node = NodeCore::from_ledger(bob.clone(), joined_ledger, DEFAULT_BURN_PER_BLOCK);
 
     assert_eq!(
         bob_node.ledger().status().tip_hash,
         alice_node.ledger().status().tip_hash
     );
     assert_eq!(bob_node.ledger().status().height, 1);
     assert_eq!(bob_node.ledger().balance_of(bob.address()), 0);
 
     let outcome = bob_node.automatic_mine_once(2);
     assert!(outcome.burned.is_none());
 }
 
 #[test]
 fn running_node_rejects_snapshot_from_different_genesis() {
     let alice = Wallet::from_seed("alice");
     let bob = Wallet::from_seed("bob");
 
     let mut alice_genesis = BTreeMap::new();
     alice_genesis.insert(alice.address().to_string(), 1_000);
     let alice_node = node("alice", alice, alice_genesis);
 
     let mut bob_genesis = BTreeMap::new();
     bob_genesis.insert(bob.address().to_string(), 1_000);
     let mut bob_node = node("bob", bob, bob_genesis);
 
     let error = bob_node
         .import_chain_snapshot(alice_node.chain_snapshot())
         .unwrap_err();
 
     assert!(error.to_string().contains("genesis"));
 }
 
 #[test]
 fn same_height_fork_snapshot_does_not_reorg() {
     let alice = Wallet::from_seed("alice");
     let bob = Wallet::from_seed("bob");
     let wallets = vec![alice.clone(), bob.clone()];
     let shared_genesis = allocations(&wallets, 1_000);
     let base = Ledger::new_with_genesis_burns(
         shared_genesis,
         vec![GenesisBurn::new(alice.address(), 1)],
         1,
     )
     .unwrap();
     let mut local = base.clone();
 
     let local_first_fork_hash = mine_wallet_burn_block(&mut local, &alice, 1);
     let remote = fork_with_worse_vrf_block(&base, &alice, &local_first_fork_hash, 1).unwrap();
 
     let local_tip = local.status().tip_hash;
     assert!(!local.extend_from_snapshot(remote.snapshot()).unwrap());
     assert_eq!(local.status().tip_hash, local_tip);
 }
 
 #[test]
 fn fork_choice_preflight_rejects_non_matching_genesis_before_scoring() {
     let alice = Wallet::from_seed("preflight-genesis-alice");
     let bob = Wallet::from_seed("preflight-genesis-bob");
     let mut local_genesis = BTreeMap::new();
     local_genesis.insert(alice.address().to_string(), 1_000);
     let mut remote_genesis = BTreeMap::new();
     remote_genesis.insert(bob.address().to_string(), 1_000);
     let mut local = Ledger::new(local_genesis, 1);
     let mut remote = Ledger::new(remote_genesis, 1);
 
     mine_wallet_burn_block(&mut local, &alice, 1);
     for timestamp in 1..=3 {
         mine_wallet_burn_block(&mut remote, &bob, timestamp);
     }
 
     let local_tip = local.status().tip_hash;
     let error = local.extend_from_snapshot(remote.snapshot()).unwrap_err();
 
     assert!(error.to_string().contains("genesis"));
     assert_eq!(local.status().tip_hash, local_tip);
 }
 
 #[test]
 fn fork_choice_preflight_rejects_invalid_fork_before_vrf_scoring() {
     let alice = Wallet::from_seed("preflight-invalid-alice");
     let shared_genesis = allocations(std::slice::from_ref(&alice), 10_000);
     let mut common = Ledger::new(shared_genesis, 1);
     for timestamp in 1..=5 {
         mine_wallet_burn_block(&mut common, &alice, timestamp);
     }
 
     let mut local = common.clone();
     let local_first_fork_hash = mine_wallet_burn_block(&mut local, &alice, 6);
     mine_wallet_burn_block(&mut local, &alice, 7);
     mine_wallet_burn_block(&mut local, &alice, 8);
 
     let remote = fork_with_better_vrf_block(&common, &alice, &local_first_fork_hash, 100).unwrap();
     assert!(remote.chain()[6].hash < local.chain()[6].hash);
     let mut invalid_snapshot = remote.snapshot();
     if let Some(transaction) = invalid_snapshot.blocks[6].transactions.first_mut() {
         match transaction {
             iuna::domain::Transaction::Burn { signature, .. }
             | iuna::domain::Transaction::Transfer { signature, .. }
             | iuna::domain::Transaction::Mine { signature, .. } => signature.push_str("00"),
         }
     }
 
     let local_tip = local.status().tip_hash;
     let error = local.extend_from_snapshot(invalid_snapshot).unwrap_err();
 
     assert!(error.to_string().contains("invalid"));
     assert_eq!(local.status().height, 8);
     assert_eq!(local.status().tip_hash, local_tip);
 }
 
 #[test]
 fn fork_conflict_before_last_six_blocks_is_finalized_even_if_remote_is_longer() {
     let alice = Wallet::from_seed("finality-alice");
     let shared_genesis = allocations(std::slice::from_ref(&alice), 10_000);
     let mut common = Ledger::new(shared_genesis, 1);
     mine_wallet_burn_block(&mut common, &alice, 1);
 
     let mut local = common.clone();
     for timestamp in 2..=8 {
         let timestamp_ms = next_ticket_slot_timestamp(&local, timestamp);
         mine_wallet_burn_block(&mut local, &alice, timestamp_ms);
     }
 
     let mut remote = common;
     for timestamp in 20..=29 {
         let timestamp_ms = next_ticket_slot_timestamp(&remote, timestamp);
         mine_wallet_burn_block(&mut remote, &alice, timestamp_ms);
     }
 
     assert_eq!(local.status().height, 8);
     assert_eq!(remote.status().height, 11);
     let finalized_local_tip = local.status().tip_hash;
 
     assert!(
         !local.extend_from_snapshot(remote.snapshot()).unwrap(),
         "forks that rewrite blocks before the last six should not be accepted"
     );
     assert_eq!(local.status().height, 8);
     assert_eq!(local.status().tip_hash, finalized_local_tip);
 }
 
 #[test]
 fn shorter_better_rank_fork_inside_last_six_does_not_beat_positive_quality() {
     let alice = Wallet::from_seed("better-vrf-alice");
     let shared_genesis = allocations(std::slice::from_ref(&alice), 10_000);
     let mut common = Ledger::new(shared_genesis, 1);
     for timestamp in 1..=5 {
         mine_wallet_burn_block(&mut common, &alice, timestamp);
     }
 
     let mut local = common.clone();
     let local_first_fork_hash = mine_wallet_burn_block(&mut local, &alice, 6);
     mine_wallet_burn_block(&mut local, &alice, 7);
     mine_wallet_burn_block(&mut local, &alice, 8);
 
     let remote = fork_with_better_vrf_block(&common, &alice, &local_first_fork_hash, 100).unwrap();
 
     assert_eq!(local.status().height, 8);
     assert_eq!(remote.status().height, 6);
     assert!(remote.status().height + 2 >= local.status().height);
     assert!(
         remote.chain()[6].hash < local.chain()[6].hash,
         "test setup should give the remote fork the better VRF leader score"
     );
     let remote_tip = remote.status().tip_hash;
 
     assert!(
         !local.extend_from_snapshot(remote.snapshot()).unwrap(),
         "a shorter fork should not beat greater positive chain quality"
     );
     assert_eq!(local.status().height, 8);
     assert_ne!(local.status().tip_hash, remote_tip);
 }
 
 #[test]
 fn better_vrf_fork_inside_last_six_loses_when_more_than_two_blocks_shorter() {
     let alice = Wallet::from_seed("too-short-vrf-alice");
     let shared_genesis = allocations(std::slice::from_ref(&alice), 10_000);
     let mut common = Ledger::new(shared_genesis, 1);
     for timestamp in 1..=5 {
         mine_wallet_burn_block(&mut common, &alice, timestamp);
     }
 
     let mut local = common.clone();
     let local_first_fork_hash = mine_wallet_burn_block(&mut local, &alice, 6);
     mine_wallet_burn_block(&mut local, &alice, 7);
     mine_wallet_burn_block(&mut local, &alice, 8);
     mine_wallet_burn_block(&mut local, &alice, 9);
 
     let remote = fork_with_better_vrf_block(&common, &alice, &local_first_fork_hash, 100).unwrap();
 
     assert_eq!(local.status().height, 9);
     assert_eq!(remote.status().height, 6);
     assert!(remote.chain()[6].hash < local.chain()[6].hash);
     let local_tip = local.status().tip_hash;
 
     assert!(
         !local.extend_from_snapshot(remote.snapshot()).unwrap(),
         "even a better VRF fork should not win when more than two blocks shorter"
     );
     assert_eq!(local.status().height, 9);
     assert_eq!(local.status().tip_hash, local_tip);
 }
 
 #[test]
 fn transactions_from_abandoned_fork_blocks_return_to_mempool_after_switch() {
     let alice = Wallet::from_seed("reorg-alice");
     let bob = Wallet::from_seed("reorg-bob");
     let carol = Wallet::from_seed("reorg-carol");
     let wallets = vec![alice.clone(), bob.clone(), carol.clone()];
     let shared_genesis = allocations(&wallets, 10_000);
     let mut common = Ledger::new_with_genesis_burns(
         shared_genesis,
         vec![GenesisBurn::new(alice.address(), 1)],
         1,
     )
     .unwrap();
     mine_wallet_burn_block(&mut common, &alice, 1);
 
     let mut local = common.clone();
     let abandoned_transfer = transfer_tx(&local, &bob, carol.address(), 7);
     local
         .submit_transaction(abandoned_transfer.clone())
         .unwrap();
     mine_wallet_burn_block(&mut local, &alice, 2);
 
     let mut remote = common;
     for timestamp in 20..=23 {
         mine_wallet_burn_block(&mut remote, &alice, timestamp);
     }
 
     assert!(local.extend_from_snapshot(remote.snapshot()).unwrap());
     assert!(
         local
             .pending()
             .iter()
             .any(|tx| tx.signature() == abandoned_transfer.signature()),
         "transactions mined only on the abandoned fork should return to the mempool"
     );
 }
 
 #[test]
 fn longer_valid_fork_snapshot_reorgs_and_preserves_local_transactions() {
     let alice = Wallet::from_seed("alice");
     let bob = Wallet::from_seed("bob");
     let wallets = vec![alice.clone(), bob.clone()];
     let shared_genesis = allocations(&wallets, 1_000);
     let mut local = Ledger::new_with_genesis_burns(
         shared_genesis.clone(),
         vec![GenesisBurn::new(alice.address(), 1)],
         1,
     )
     .unwrap();
     let mut remote = Ledger::new_with_genesis_burns(
         shared_genesis,
         vec![GenesisBurn::new(alice.address(), 1)],
         1,
     )
     .unwrap();
 
     let local_burn = burn_tx(&local, &alice, 1);
     local.submit_transaction(local_burn.clone()).unwrap();
     let local_block = local.mine_next_block(&alice, 1).unwrap();
     local.apply_block(local_block).unwrap();
     let local_transfer = transfer_tx(&local, &bob, alice.address(), 5);
     local.submit_transaction(local_transfer.clone()).unwrap();
 
     submit_burn(&mut remote, &alice, 1);
     let remote_block_1 = remote.mine_next_block(&alice, 1).unwrap();
     remote.apply_block(remote_block_1).unwrap();
     submit_burn(&mut remote, &alice, 1);
     let remote_block_2 = remote.mine_next_block(&alice, 2).unwrap();
     remote.apply_block(remote_block_2).unwrap();
 
     let remote_tip = remote.status().tip_hash;
     assert!(local.extend_from_snapshot(remote.snapshot()).unwrap());
     assert_eq!(local.status().height, 2);
     assert_eq!(local.status().tip_hash, remote_tip);
     assert!(
         local
             .pending()
             .iter()
             .any(|tx| tx.signature() == local_transfer.signature())
     );
 }
 
 #[test]
 fn node_receives_chain_snapshot_envelope_when_joining_without_tcp() {
     let alice = Wallet::from_seed("alice");
     let bob = Wallet::from_seed("bob");
 
     let wallets = vec![alice.clone(), bob.clone()];
     let shared_genesis = allocations(&wallets, 1_000);
     let mut alice_node = node("alice", alice.clone(), shared_genesis.clone());
     queue_plaintext_burn(&mut alice_node, &alice, 1);
     alice_node.mine_one().unwrap();
 
     let mut bob_node = node("bob", bob, shared_genesis);
 
     bob_node
         .receive(iuna::app::GossipEnvelope::ChainSnapshot(
             alice_node.chain_snapshot(),
         ))
         .unwrap();
 
     assert_eq!(
         bob_node.ledger().status().tip_hash,
         alice_node.ledger().status().tip_hash
     );
 }