iuna

main.rs (25343B)

 use std::{
     collections::BTreeMap,
     net::SocketAddr,
     path::{Path, PathBuf},
     sync::Arc,
     time::{Duration, Instant},
 };
 
 use anyhow::{Context, Result, bail};
 use iuna::{
     adapters::{
         chain_store::SqliteChainStore, config_store, http, p2p, stratum,
         ui_data_store::SqliteUiDataStore, wallet_store,
     },
     app::{
         NodeCore, PeerBook, SharedNode, SharedPeerBook, StratumStatus, debug_logging_enabled,
         now_ms, set_debug_logging,
     },
     domain::{
         Amount, ChainSnapshot, GenesisBurn, Ledger, MAX_VDF_ROUNDS, MICRO_IUNA,
         VDF_TARGET_BLOCK_MS, run_vdf,
     },
 };
 use tokio::sync::Mutex;
 
 mod cli;
 use cli::{
     ChainMode, CliOptions, apply_cli_p2p_config_overrides, configured_p2p_announce_addr,
     configured_p2p_bind_addr, initial_burn_fee, initial_burn_per_block, validate_wallet_for_mode,
 };
 #[cfg(test)]
 use cli::{default_data_dir, help_text};
 
 const GENESIS_BOOTSTRAP_BURN_AMOUNT: Amount = MICRO_IUNA;
 const GENESIS_INITIAL_BURN_PER_BLOCK: Amount = config_store::DEFAULT_BURN_AMOUNT;
 const GENESIS_INITIAL_BURN_FEE: Amount = config_store::DEFAULT_BURN_FEE;
 const VDF_MEASUREMENT_INITIAL_ROUNDS: u64 = 1_000;
 const VDF_MEASUREMENT_MAX_ROUNDS: u64 = 10_000_000;
 const VDF_MEASUREMENT_MIN_ELAPSED: Duration = Duration::from_millis(150);
 
 #[tokio::main]
 async fn main() -> Result<()> {
     let Some(opts) = CliOptions::parse()? else {
         return Ok(());
     };
     set_debug_logging(opts.debug);
     let debug_logging = opts.debug;
     let wallet_path = opts.wallet_path();
     let config_path = opts.config_path();
     let wallet_file_exists = wallet_path.exists();
     validate_wallet_for_mode(&opts, &wallet_path, wallet_file_exists)?;
     let chain_db_path = opts.chain_db_path();
     let ui_data_db_path = ui_data_db_path(&chain_db_path);
     let chain_store = SqliteChainStore::open(&chain_db_path)?;
     let ui_data_store = SqliteUiDataStore::open(&ui_data_db_path)?;
     let persisted_chain_exists = chain_store.load()?.is_some();
     if opts.chain_mode == ChainMode::Genesis && persisted_chain_exists {
         bail!(
             "--genesis refuses to run because chain database already contains a blockchain at {}; start without --genesis to resume it",
             chain_store.path().display()
         );
     }
     let mut ui_config = config_store::load_or_create(&config_path)?;
     let ui_config_dirty = apply_cli_p2p_config_overrides(&opts, &mut ui_config);
     let p2p_announce_addr = configured_p2p_announce_addr(&opts, &ui_config)?;
     let configured_p2p_addr = configured_p2p_bind_addr(&opts, &ui_config);
     let p2p_accept_inbound = ui_config.p2p_accept_inbound;
     let advertised_p2p_addr = p2p_announce_addr.unwrap_or(configured_p2p_addr);
     let wallet_load = load_startup_wallet(&wallet_path)?;
     let wallet_address = wallet_load.address().to_string();
     if opts.chain_mode == ChainMode::Genesis {
         ui_config.setup_complete = false;
         ui_config.mining_enabled = true;
         ui_config.pow_mining_enabled = false;
         ui_config.burn_per_block = GENESIS_INITIAL_BURN_PER_BLOCK;
         ui_config.burn_fee = GENESIS_INITIAL_BURN_FEE;
         config_store::save(&config_path, &ui_config)?;
     } else if ui_config_dirty {
         config_store::save(&config_path, &ui_config)?;
     }
     let ledger =
         initialize_ledger(&opts, &wallet_address, &chain_store, advertised_p2p_addr).await?;
     let has_chain = opts.has_chain() || persisted_chain_exists;
     let initial_burn_per_block = initial_burn_per_block(&opts, &ui_config);
     let initial_burn_fee = initial_burn_fee(&opts, &ui_config);
 
     let mut node_core = match wallet_load {
         StartupWallet::Unlocked {
             wallet,
             owned_blinded_transactions,
         } => {
             let mut node = NodeCore::from_ledger_with_burn_fee_and_enabled(
                 wallet,
                 ledger,
                 ui_config.mining_enabled,
                 initial_burn_per_block,
                 initial_burn_fee,
             );
             node.restore_owned_blinded_transactions(owned_blinded_transactions)?;
             node
         }
         StartupWallet::Locked { address } => NodeCore::from_locked_wallet_address(
             address,
             ledger,
             ui_config.mining_enabled,
             initial_burn_per_block,
             initial_burn_fee,
         ),
     };
     node_core.set_pow_mining_workers(ui_config.pow_mining_workers);
     node_core.set_pow_mining_enabled(ui_config.pow_mining_enabled);
     node_core.set_recovery_vdf_top_rank_percent(ui_config.recovery_vdf_top_rank_percent);
     let node: SharedNode = Arc::new(Mutex::new(node_core));
     let ui_config = Arc::new(Mutex::new(ui_config));
     let mut peers = ui_config.lock().await.peers.clone();
     peers.extend(opts.peers);
     let peers: SharedPeerBook = Arc::new(Mutex::new(PeerBook::from_addresses(peers)));
     if has_chain {
         let initial_snapshot = { node.lock().await.chain_snapshot() };
         let keep_metrics = ui_config.lock().await.keep_track_of_metrics;
         persist_chain_snapshot(&chain_store, initial_snapshot.clone()).await?;
         warm_ui_data_store(&ui_data_store, initial_snapshot, keep_metrics).await?;
     } else {
         clear_ui_data_store(&ui_data_store).await?;
     }
 
     println!("iuna wallet: {}", node.lock().await.wallet_address());
     if node.lock().await.wallet_is_locked() {
         println!("wallet locked: unlock it in the management UI");
     }
     println!("wallet file: {}", wallet_path.display());
     println!("config file: {}", config_path.display());
     println!("chain database: {}", chain_store.path().display());
     println!("UI data database: {}", ui_data_store.path().display());
     println!("management UI: http://{}", opts.http_addr);
     if p2p_accept_inbound {
         println!("p2p listener: {}", configured_p2p_addr);
     } else {
         println!("p2p listener: disabled (outbound-only)");
     }
     if p2p_accept_inbound {
         if let Some(addr) = p2p_announce_addr {
             println!("p2p announce address: {addr}");
         }
     }
     println!(
         "automatic finalization: VDF-driven, burning {} IUNA per block with {} IUNA per byte fee rate",
         format_iuna(initial_burn_per_block),
         format_iuna(initial_burn_fee)
     );
 
     let gossip = p2p::GossipNetwork::start(
         Arc::clone(&node),
         Arc::clone(&peers),
         configured_p2p_addr,
         p2p_announce_addr,
         p2p_accept_inbound,
     )
     .await?;
     let mut stratum_status = StratumStatus {
         enabled: false,
         listen_addr: None,
     };
     if let Some(stratum_addr) = opts.stratum_addr {
         let stratum =
             stratum::StratumServer::start(Arc::clone(&node), gossip.clone(), stratum_addr).await?;
         println!("stratum listener: {}", stratum.listen_addr());
         stratum_status = StratumStatus {
             enabled: true,
             listen_addr: Some(stratum.listen_addr().to_string()),
         };
     }
 
     let persistence_node = Arc::clone(&node);
     let persistence_store = chain_store.clone();
     let persistence_ui_data_store = ui_data_store.clone();
     let persistence_config = Arc::clone(&ui_config);
     let persistence_initial_tip = {
         let node = node.lock().await;
         if node.has_real_chain() {
             Some(node.chain_tip_hash())
         } else {
             None
         }
     };
     tokio::spawn(async move {
         run_chain_persistence(
             persistence_node,
             persistence_store,
             persistence_ui_data_store,
             persistence_config,
             persistence_initial_tip,
         )
         .await;
     });
 
     let finalizer_node = Arc::clone(&node);
     let finalizer_gossip = gossip.clone();
     tokio::spawn(async move {
         run_automatic_finalizer(finalizer_node, finalizer_gossip, debug_logging).await;
     });
 
     let pow_miner_node = Arc::clone(&node);
     let pow_miner_gossip = gossip.clone();
     tokio::spawn(async move {
         run_automatic_pow_miner(pow_miner_node, pow_miner_gossip, debug_logging).await;
     });
 
     let sync_node = Arc::clone(&node);
     let sync_gossip = gossip.clone();
     tokio::spawn(async move {
         run_peer_sync(sync_node, sync_gossip, debug_logging).await;
     });
 
     if !has_chain {
         println!("setup mode: waiting to join or create a chain");
     }
 
     http::serve(
         node,
         peers,
         gossip,
         ui_config,
         http::ServeOptions {
             config_path,
             chain_store,
             ui_data_store,
             wallet_path,
             stratum: stratum_status,
             addr: opts.http_addr,
         },
     )
     .await
 }
 
 enum StartupWallet {
     Unlocked {
         wallet: iuna::domain::Wallet,
         owned_blinded_transactions: Vec<iuna::domain::OwnedBlindedTransaction>,
     },
     Locked {
         address: String,
     },
 }
 
 impl StartupWallet {
     fn address(&self) -> &str {
         match self {
             Self::Unlocked { wallet, .. } => wallet.address(),
             Self::Locked { address } => address,
         }
     }
 }
 
 fn load_startup_wallet(wallet_path: &Path) -> Result<StartupWallet> {
     match wallet_store::load_or_create(wallet_path) {
         Ok(wallet) => {
             let owned_blinded_transactions =
                 wallet_store::load_owned_blinded_transactions(wallet_path, None)?;
             Ok(StartupWallet::Unlocked {
                 wallet,
                 owned_blinded_transactions,
             })
         }
         Err(error) => {
             let Some(metadata) = wallet_store::metadata(wallet_path)? else {
                 return Err(error);
             };
             if metadata.encrypted {
                 Ok(StartupWallet::Locked {
                     address: metadata.address,
                 })
             } else {
                 Err(error)
             }
         }
     }
 }
 
 fn format_iuna(amount: Amount) -> String {
     let whole = amount / MICRO_IUNA;
     let fractional = amount % MICRO_IUNA;
     if fractional == 0 {
         whole.to_string()
     } else {
         let mut fractional = format!("{fractional:06}");
         while fractional.ends_with('0') {
             fractional.pop();
         }
         format!("{whole}.{fractional}")
     }
 }
 
 fn ui_data_db_path(chain_db_path: &Path) -> PathBuf {
     chain_db_path.with_file_name("ui_data.sqlite3")
 }
 
 async fn initialize_ledger(
     opts: &CliOptions,
     wallet_address: &str,
     chain_store: &SqliteChainStore,
     advertised_p2p_addr: SocketAddr,
 ) -> Result<Ledger> {
     if let Some(snapshot) = chain_store.load()? {
         if opts.chain_mode == ChainMode::Genesis {
             bail!(
                 "--genesis refuses to run because chain database already contains a blockchain at {}; start without --genesis to resume it",
                 chain_store.path().display()
             );
         }
         let height = snapshot_height(&snapshot);
         let ledger = Ledger::from_persisted_snapshot(snapshot).with_context(|| {
             format!(
                 "failed to load chain database {}",
                 chain_store.path().display()
             )
         })?;
         println!(
             "resumed chain from {} at height {height}",
             chain_store.path().display()
         );
         Ok(ledger)
     } else {
         match opts.chain_mode {
             ChainMode::Setup => Ok(setup_ledger()),
             ChainMode::Genesis => start_genesis_ledger(wallet_address),
             ChainMode::Join => join_chain_ledger(&opts.join_peers, advertised_p2p_addr).await,
         }
     }
 }
 
 fn snapshot_height(snapshot: &ChainSnapshot) -> u64 {
     snapshot
         .blocks
         .last()
         .map(|block| block.height)
         .unwrap_or(0)
 }
 
 fn setup_ledger() -> Ledger {
     Ledger::new(BTreeMap::new(), 1)
 }
 
 fn start_genesis_ledger(wallet_address: &str) -> Result<Ledger> {
     let vdf_rounds = measure_initial_vdf_rounds();
     let mut genesis = BTreeMap::new();
     genesis.insert(wallet_address.to_string(), GENESIS_BOOTSTRAP_BURN_AMOUNT);
     Ledger::new_with_genesis_burns(
         genesis,
         vec![GenesisBurn::new(
             wallet_address,
             GENESIS_BOOTSTRAP_BURN_AMOUNT,
         )],
         vdf_rounds,
     )
 }
 
 fn measure_initial_vdf_rounds() -> u64 {
     let seed = "iuna-vdf-calibration";
     let (measured_rounds, elapsed) = measure_vdf_rounds(
         seed,
         VDF_MEASUREMENT_INITIAL_ROUNDS,
         VDF_MEASUREMENT_MIN_ELAPSED,
         VDF_MEASUREMENT_MAX_ROUNDS,
     );
     let rounds = extrapolate_vdf_rounds(
         measured_rounds,
         elapsed,
         Duration::from_millis(VDF_TARGET_BLOCK_MS),
     );
     println!(
         "measured {measured_rounds} VDF rounds in {:.3}ms; initial VDF rounds: {rounds}",
         elapsed.as_secs_f64() * 1000.0
     );
     rounds
 }
 
 fn measure_vdf_rounds(
     seed: &str,
     initial_rounds: u64,
     min_elapsed: Duration,
     max_rounds_per_attempt: u64,
 ) -> (u64, Duration) {
     let mut rounds = initial_rounds.max(1).min(max_rounds_per_attempt.max(1));
     let mut measured_rounds = 0_u64;
     let mut measured_elapsed = Duration::ZERO;
 
     loop {
         let started = Instant::now();
         let _ = run_vdf(seed, rounds);
         measured_elapsed += started.elapsed();
         measured_rounds = measured_rounds.saturating_add(rounds);
 
         if measured_elapsed >= min_elapsed || rounds >= max_rounds_per_attempt {
             return (measured_rounds, measured_elapsed);
         }
         rounds = rounds.saturating_mul(2).min(max_rounds_per_attempt);
     }
 }
 
 fn extrapolate_vdf_rounds(measured_rounds: u64, elapsed: Duration, target: Duration) -> u64 {
     let elapsed_ns = elapsed.as_nanos().max(1);
     let target_ns = target.as_nanos().max(1);
     let rounds = u128::from(measured_rounds)
         .saturating_mul(target_ns)
         .saturating_div(elapsed_ns)
         .max(1);
     rounds.min(u128::from(MAX_VDF_ROUNDS)) as u64
 }
 
 async fn join_chain_ledger(join_peers: &[String], advertised_addr: SocketAddr) -> Result<Ledger> {
     let mut errors = Vec::new();
     for peer in join_peers {
         match p2p::fetch_snapshot_with_announcement(peer, Some(advertised_addr)).await {
             Ok(snapshot) => {
                 let height = snapshot
                     .blocks
                     .last()
                     .map(|block| block.height)
                     .unwrap_or(0);
                 println!("joined chain from {peer} at height {height}");
                 return Ledger::from_snapshot(snapshot);
             }
             Err(error) => {
                 errors.push(format!("{peer}: {error:#}"));
             }
         }
     }
 
     bail!(
         "could not join any requested peer; refusing to start a separate chain: {}",
         errors.join("; ")
     )
 }
 
 async fn run_automatic_finalizer(node: SharedNode, gossip: p2p::GossipNetwork, debug: bool) {
     let mut last_logged_skip: Option<(u64, String)> = None;
     loop {
         if !node.lock().await.has_real_chain() {
             tokio::time::sleep(std::time::Duration::from_secs(1)).await;
             continue;
         }
         let (height, plan, outbox) = {
             let mut node = node.lock().await;
             let height = node.chain_height();
             let plan = node.prepare_automatic_finalization(now_ms());
             let outbox = node.drain_outbox();
             (height, plan, outbox)
         };
 
         if let Err(error) = gossip.broadcast(outbox).await {
             if debug {
                 eprintln!("p2p broadcast failed after automatic burn: {error:#}");
             }
         }
 
         let Some(work) = plan.work else {
             if let Some(reason) = &plan.skipped_reason {
                 let skip = (height, reason.clone());
                 if debug && last_logged_skip.as_ref() != Some(&skip) {
                     println!("auto-finalization skipped at height {height}: {reason}");
                     last_logged_skip = Some(skip);
                 }
             }
             tokio::time::sleep(std::time::Duration::from_secs(1)).await;
             continue;
         };
 
         last_logged_skip = None;
         if debug {
             println!(
                 "leader selected locally for candidate block {}; running VDF for {} rounds",
                 work.height(),
                 work.vdf_rounds()
             );
         }
 
         let seed = work.vdf_seed().to_string();
         let rounds = work.vdf_rounds();
         let publish_at_ms = work.timestamp_ms();
         let vdf_output = match tokio::task::spawn_blocking(move || run_vdf(&seed, rounds)).await {
             Ok(output) => output,
             Err(error) => {
                 if debug {
                     eprintln!("VDF worker failed: {error:#}");
                 }
                 continue;
             }
         };
 
         let completed_at_ms = now_ms();
         let publish_timestamp_ms = completed_at_ms.max(publish_at_ms);
         if completed_at_ms < publish_at_ms {
             let wait_ms = publish_at_ms - completed_at_ms;
             if debug {
                 println!(
                     "VDF completed early for candidate block {}; waiting {:.3}s for rank time slot",
                     work.height(),
                     wait_ms as f64 / 1000.0
                 );
             }
             tokio::time::sleep(std::time::Duration::from_millis(wait_ms)).await;
         }
 
         let (finalized, outbox) = {
             let mut node = node.lock().await;
             let finalized = node.complete_prepared_block_at(work, vdf_output, publish_timestamp_ms);
             match &finalized {
                 Ok(block) => node.record_automatic_finalization_status(format!(
                     "finalized block {} ({})",
                     block.height, block.hash
                 )),
                 Err(error) => node
                     .record_automatic_finalization_status(format!("skipped after VDF: {error:#}")),
             }
             let outbox = node.drain_outbox();
             (finalized, outbox)
         };
 
         match finalized {
             Ok(block) if debug => {
                 println!("auto-finalized block {} ({})", block.height, block.hash);
             }
             Ok(_) => {}
             Err(error) if debug => println!("auto-finalization skipped after VDF: {error:#}"),
             Err(_) => {}
         }
 
         if let Err(error) = gossip.broadcast(outbox).await {
             if debug {
                 eprintln!("p2p broadcast failed after automatic block: {error:#}");
             }
         }
 
         tokio::task::yield_now().await;
     }
 }
 
 async fn run_automatic_pow_miner(node: SharedNode, gossip: p2p::GossipNetwork, debug: bool) {
     loop {
         tokio::time::sleep(std::time::Duration::from_secs(1)).await;
         let (height, job) = {
             let mut node = node.lock().await;
             if !node.pow_mining_enabled() {
                 continue;
             }
             if !node.has_real_chain() {
                 continue;
             }
             let height = node.chain_height();
             let job = match node.prepare_automatic_pow_mining_job() {
                 Ok(job) => job,
                 Err(error) => {
                     node.record_automatic_pow_mining_error(format!(
                         "automatic PoW mining failed: {error:#}"
                     ));
                     None
                 }
             };
             (height, job)
         };
         let Some(job) = job else {
             continue;
         };
 
         let search = tokio::task::spawn_blocking(move || job.search()).await;
         let (pow_mined, outbox) = {
             let mut node = node.lock().await;
             let pow_mined = match search {
                 Ok(Ok((job, outcome))) => {
                     match node.finish_automatic_pow_mining_job(job, outcome) {
                         Ok(tx) => tx,
                         Err(error) => {
                             node.record_automatic_pow_mining_error(format!(
                                 "automatic PoW mining failed: {error:#}"
                             ));
                             None
                         }
                     }
                 }
                 Ok(Err(error)) => {
                     node.record_automatic_pow_mining_error(format!(
                         "automatic PoW mining failed: {error:#}"
                     ));
                     None
                 }
                 Err(error) => {
                     node.record_automatic_pow_mining_error(format!(
                         "automatic PoW mining task failed: {error:#}"
                     ));
                     None
                 }
             };
             let outbox = node.drain_outbox();
             (pow_mined, outbox)
         };
 
         if let Err(error) = gossip.broadcast(outbox).await {
             if debug {
                 eprintln!("p2p broadcast failed after automatic PoW mining: {error:#}");
             }
         }
 
         if debug {
             if let Some(tx) = &pow_mined {
                 println!(
                     "auto-pow queued mine action for height {} ({})",
                     height,
                     tx.signature()
                 );
             }
         }
     }
 }
 
 async fn run_peer_sync(node: SharedNode, gossip: p2p::GossipNetwork, debug: bool) {
     loop {
         tokio::time::sleep(std::time::Duration::from_secs(5)).await;
         let envelopes = {
             let mut node = node.lock().await;
             let mut envelopes = vec![node.peer_status()];
             envelopes.extend(node.drain_outbox());
             envelopes.extend(node.mempool_gossip());
             envelopes
         };
         let mut envelopes = envelopes;
         envelopes.push(gossip.peer_exchange().await);
         if let Err(error) = gossip.broadcast(envelopes).await {
             if debug {
                 eprintln!("p2p sync gossip failed: {error:#}");
             }
         }
     }
 }
 
 async fn run_chain_persistence(
     node: SharedNode,
     store: SqliteChainStore,
     ui_data_store: SqliteUiDataStore,
     ui_config: Arc<Mutex<config_store::UiConfig>>,
     initial_saved_tip: Option<String>,
 ) {
     run_chain_persistence_with_interval(
         node,
         store,
         ui_data_store,
         ui_config,
         Duration::from_secs(2),
         initial_saved_tip,
     )
     .await;
 }
 
 async fn run_chain_persistence_with_interval(
     node: SharedNode,
     store: SqliteChainStore,
     ui_data_store: SqliteUiDataStore,
     ui_config: Arc<Mutex<config_store::UiConfig>>,
     interval: Duration,
     initial_saved_tip: Option<String>,
 ) {
     let mut last_saved_tip = initial_saved_tip;
     loop {
         tokio::time::sleep(interval).await;
         let snapshot = {
             let node = node.lock().await;
             if !node.has_real_chain() {
                 continue;
             }
             node.chain_snapshot()
         };
         let Some(tip_hash) = snapshot.blocks.last().map(|block| block.hash.clone()) else {
             continue;
         };
         if last_saved_tip.as_deref() == Some(tip_hash.as_str()) {
             continue;
         }
 
         let keep_metrics = ui_config.lock().await.keep_track_of_metrics;
         match persist_chain_and_project_ui_data(&store, &ui_data_store, snapshot, keep_metrics)
             .await
         {
             Ok(()) => last_saved_tip = Some(tip_hash),
             Err(error) if debug_logging_enabled() => {
                 eprintln!("chain persistence failed: {error:#}")
             }
             Err(_) => {}
         }
     }
 }
 
 async fn persist_chain_and_project_ui_data(
     store: &SqliteChainStore,
     ui_data_store: &SqliteUiDataStore,
     snapshot: ChainSnapshot,
     keep_metrics: bool,
 ) -> Result<()> {
     persist_chain_snapshot(store, snapshot.clone()).await?;
     project_ui_data_store(ui_data_store, snapshot, keep_metrics).await
 }
 
 async fn persist_chain_snapshot(store: &SqliteChainStore, snapshot: ChainSnapshot) -> Result<()> {
     let store = store.clone();
     tokio::task::spawn_blocking(move || store.save(&snapshot))
         .await
         .context("chain persistence worker failed")??;
     Ok(())
 }
 
 async fn warm_ui_data_store(
     store: &SqliteUiDataStore,
     snapshot: ChainSnapshot,
     keep_metrics: bool,
 ) -> Result<()> {
     println!("warming UI data database...");
     let started = Instant::now();
     project_ui_data_store(store, snapshot, keep_metrics).await?;
     println!(
         "UI data database ready in {:.2}s",
         started.elapsed().as_secs_f64()
     );
     Ok(())
 }
 
 async fn project_ui_data_store(
     store: &SqliteUiDataStore,
     snapshot: ChainSnapshot,
     keep_metrics: bool,
 ) -> Result<()> {
     let store = store.clone();
     tokio::task::spawn_blocking(move || store.project_snapshot(&snapshot, keep_metrics))
         .await
         .context("UI data projection worker failed")??;
     Ok(())
 }
 
 async fn clear_ui_data_store(store: &SqliteUiDataStore) -> Result<()> {
     println!("clearing UI data database...");
     let started = Instant::now();
     let store = store.clone();
     tokio::task::spawn_blocking(move || store.clear_all())
         .await
         .context("UI data cleanup worker failed")??;
     println!(
         "UI data database ready in {:.2}s",
         started.elapsed().as_secs_f64()
     );
     Ok(())
 }
 
 #[cfg(test)]
 #[path = "main_tests.rs"]
 mod tests;