wip

Author: kariy

Cargo.lock

@@ -5,16 +5,11 @@ use clap::{Args, Subcommand};
 use comfy_table::modifiers::UTF8_ROUND_CORNERS;
 use comfy_table::presets::UTF8_FULL;
 use comfy_table::Table;
-use katana_db::abstraction::{
-    Database, DbCursor, DbDupSortCursor, DbDupSortCursorMut, DbTx, DbTxMut,
-};
+use katana_db::abstraction::{Database, DbCursor, DbDupSortCursorMut, DbTx, DbTxMut};
 use katana_db::mdbx::{DbEnv, DbEnvKind};
 use katana_db::models::list::BlockList;
 use katana_db::models::trie::TrieDatabaseKey;
-use katana_db::tables::{
-    self, ClassesTrieChangeSet, ClassesTrieHistory, ContractsTrieChangeSet, ContractsTrieHistory,
-    Headers, StoragesTrieChangeSet, StoragesTrieHistory, NUM_TABLES,
-};
+use katana_db::tables::{self, NUM_TABLES};
 use katana_primitives::block::BlockNumber;
 
 /// Create a human-readable byte unit string (eg. 16.00 KiB)
@@ -28,7 +23,7 @@ macro_rules! byte_unit {
     };
 }
 
-#[derive(Args)]
+#[derive(Debug, Args)]
 pub struct DbArgs {
     #[arg(short, long)]
     #[arg(global = true)]
@@ -40,21 +35,21 @@ pub struct DbArgs {
     commands: Commands,
 }
 
-#[derive(Subcommand)]
+#[derive(Debug, Subcommand)]
 pub enum Commands {
     #[command(about = "Retrieves database statistics")]
     Stats,
     #[command(about = "Prune historical trie data")]
     Prune(PruneArgs),
 }
 
-#[derive(Args)]
+#[derive(Debug, Args)]
 pub struct PruneArgs {
     #[command(subcommand)]
     mode: PruneMode,
 }
 
-#[derive(Subcommand)]
+#[derive(Debug, Subcommand)]
 pub enum PruneMode {
     // Keep only the latest trie state (remove all historical data)
     Latest,
@@ -232,8 +227,8 @@ fn table() -> Table {
 }
 
 /// Get the latest block number from the Headers table
-pub fn get_latest_block_number<Tx: DbTx>(tx: &Tx) -> Result<BlockNumber> {
-    let mut cursor = tx.cursor::<Headers>()?;
+fn get_latest_block_number(tx: &impl DbTx) -> Result<BlockNumber> {
+    let mut cursor = tx.cursor::<tables::Headers>()?;
     if let Some((block_num, _)) = cursor.last()? {
         Ok(block_num)
     } else {
@@ -242,24 +237,20 @@ pub fn get_latest_block_number<Tx: DbTx>(tx: &Tx) -> Result<BlockNumber> {
 }
 
 /// Prune all historical trie data (keeping only current state)
-pub fn prune_all_history<Tx: DbTxMut>(tx: &Tx) -> Result<()> {
-    tx.clear::<ClassesTrieHistory>()?;
-    tx.clear::<ContractsTrieHistory>()?;
-    tx.clear::<StoragesTrieHistory>()?;
+fn prune_all_history(tx: &impl DbTxMut) -> Result<()> {
+    tx.clear::<tables::ClassesTrieHistory>()?;
+    tx.clear::<tables::ContractsTrieHistory>()?;
+    tx.clear::<tables::StoragesTrieHistory>()?;
 
-    tx.clear::<ClassesTrieChangeSet>()?;
-    tx.clear::<ContractsTrieChangeSet>()?;
-    tx.clear::<StoragesTrieChangeSet>()?;
+    tx.clear::<tables::ClassesTrieChangeSet>()?;
+    tx.clear::<tables::ContractsTrieChangeSet>()?;
+    tx.clear::<tables::StoragesTrieChangeSet>()?;
 
     Ok(())
 }
 
 /// Prune historical data keeping only the last N blocks
-pub fn prune_keep_last_n<Tx: DbTxMut>(
-    tx: &Tx,
-    latest_block: BlockNumber,
-    keep_blocks: u64,
-) -> Result<()> {
+fn prune_keep_last_n(tx: &impl DbTxMut, latest_block: BlockNumber, keep_blocks: u64) -> Result<()> {
     let cutoff_block = latest_block.saturating_sub(keep_blocks);
 
     if cutoff_block == 0 {
@@ -278,36 +269,29 @@ pub fn prune_keep_last_n<Tx: DbTxMut>(
 }
 
 /// Prune historical entries for a specific trie type up to the cutoff block
-pub fn prune_history_table<T: tables::Trie>(
+fn prune_history_table<T: tables::Trie>(
     tx: &impl DbTxMut,
     cutoff_block: BlockNumber,
 ) -> Result<()> {
     let mut cursor = tx.cursor_dup_mut::<T::History>()?;
-    let mut blocks_to_delete = Vec::new();
 
     if let Some((block, _)) = cursor.first()? {
         let mut current_block = block;
         while current_block <= cutoff_block {
-            blocks_to_delete.push(current_block);
-            if let Some((next_block, _)) = cursor.next_no_dup()? {
+            cursor.delete_current_duplicates()?;
+            if let Some((next_block, _)) = cursor.next()? {
                 current_block = next_block;
             } else {
                 break;
             }
         }
     }
 
-    for block in blocks_to_delete {
-        if cursor.seek(block)?.is_some() {
-            cursor.delete_current_duplicates()?;
-        }
-    }
-
     Ok(())
 }
 
 /// Prune changeset entries by removing blocks up to the cutoff
-pub fn prune_changeset_table<T: tables::Trie>(
+fn prune_changeset_table<T: tables::Trie>(
     tx: &impl DbTxMut,
     cutoff_block: BlockNumber,
 ) -> Result<()> {

bin/katana/src/cli/db.rs

@@ -13,7 +13,7 @@ mod version;
 
 use version::{generate_long, generate_short};
 
-#[derive(Parser)]
+#[derive(Debug, Parser)]
 #[command(name = "katana", author, version = generate_short(), long_version = generate_long() ,about, long_about = None)]
 pub struct Cli {
     #[command(subcommand)]
@@ -38,7 +38,7 @@ impl Cli {
     }
 }
 
-#[derive(Subcommand)]
+#[derive(Debug, Subcommand)]
 enum Commands {
     #[command(about = "Initialize chain")]
     Init(Box<init::InitArgs>),