feat(db): include database version in DbEnv (#155)

* feat(db): include database version in `DbEnv`

- Add private `version` field to `DbEnvInner` struct
- Modify `DbEnv::open()` to accept version parameter
- Update `open_ephemeral()` to use `CURRENT_DB_VERSION` 
- Add public `version()` getter method to access stored version
- Update `open_db()` and `init_db()` to read and pass version from file
- Update CLI database opening functions to handle version parameter

The database version is now accessible at the provider level through
`DbEnv::version()` method as requested in issue #154.

Co-authored-by: Ammar Arif <kariy@users.noreply.github.com>

* wip

* wip

* wip

* add back ephemeral db geometry

* wip

* fix

---------

Co-authored-by: claude[bot] <209825114+claude[bot]@users.noreply.github.com>
Co-authored-by: Ammar Arif <kariy@users.noreply.github.com>

Author: kariy

bin/katana/src/cli/db/mod.rs

@@ -1,11 +1,10 @@
 use std::path::{self};
 
-use anyhow::{Context, Result};
+use anyhow::Result;
 use clap::{Args, Subcommand};
 use comfy_table::modifiers::UTF8_ROUND_CORNERS;
 use comfy_table::presets::UTF8_FULL;
 use comfy_table::Table;
-use katana_db::mdbx::{DbEnv, DbEnvKind};
 
 mod prune;
 mod stats;
@@ -43,16 +42,16 @@ impl DbArgs {
 ///
 /// The path is expanded and resolved to an absolute path before opening the database for clearer
 /// error messages.
-pub fn open_db_ro(path: &str) -> Result<DbEnv> {
-    let path = path::absolute(shellexpand::full(path)?.into_owned())?;
-    DbEnv::open(&path, DbEnvKind::RO).with_context(|| {
-        format!("Opening database file in read-only mode at path {}", path.display())
-    })
+pub fn open_db_ro(path: &str) -> Result<katana_db::Db> {
+    katana_db::Db::open_ro(&path::absolute(shellexpand::full(path)?.into_owned())?)
 }
 
-pub fn open_db_rw(path: &str) -> Result<DbEnv> {
-    let path = path::absolute(shellexpand::full(path)?.into_owned())?;
-    katana_db::open_db(path)
+/// Open the database at `path` in read-write mode.
+///
+/// The path is expanded and resolved to an absolute path before opening the database for clearer
+/// error messages.
+pub fn open_db_rw(path: &str) -> Result<katana_db::Db> {
+    katana_db::Db::open(&path::absolute(shellexpand::full(path)?.into_owned())?)
 }
 
 /// Create a table with the default UTF-8 full border and rounded corners.

bin/katana/tests/fixtures.rs

@@ -1,6 +1,5 @@
 use std::collections::{BTreeMap, BTreeSet};
 
-use katana_db::mdbx::DbEnv;
 use katana_primitives::block::{Block, BlockHash, FinalityStatus};
 use katana_primitives::class::{ClassHash, CompiledClassHash};
 use katana_primitives::contract::{ContractAddress, Nonce, StorageKey, StorageValue};
@@ -20,7 +19,7 @@ pub struct TempDb {
 impl TempDb {
     pub fn new() -> Self {
         let temp_dir = tempfile::tempdir().expect("failed to create temp dir");
-        katana_db::init_db(temp_dir.path()).expect("failed to initialize database");
+        katana_db::Db::new(temp_dir.path()).expect("failed to initialize database");
         Self { temp_dir }
     }
 
@@ -32,11 +31,11 @@ impl TempDb {
         DbProvider::new(self.open_rw())
     }
 
-    fn open_ro(&self) -> DbEnv {
+    fn open_ro(&self) -> katana_db::Db {
         katana::cli::db::open_db_ro(self.path_str()).unwrap()
     }
 
-    fn open_rw(&self) -> DbEnv {
+    fn open_rw(&self) -> katana_db::Db {
         katana::cli::db::open_db_rw(self.path_str()).unwrap()
     }
 

crates/chain-spec/src/rollup/utils.rs

@@ -409,7 +409,7 @@ mod tests {
     fn valid_transactions() {
         let chain_spec = chain_spec(1, true);
 
-        let provider = DbProvider::new_ephemeral();
+        let provider = DbProvider::new_in_memory();
         let ef = executor(&chain_spec);
 
         let mut executor = ef.with_state(provider.latest().unwrap());
@@ -426,7 +426,7 @@ mod tests {
     fn genesis_states() {
         let chain_spec = chain_spec(1, true);
 
-        let provider = DbProvider::new_ephemeral();
+        let provider = DbProvider::new_in_memory();
         let ef = executor(&chain_spec);
 
         let mut executor = ef.with_state(provider.latest().unwrap());

crates/core/benches/commit.rs

@@ -142,7 +142,7 @@ fn commit_small(c: &mut Criterion) {
         small_transactions,
         small_receipts.as_slice(),
         &small_state_updates,
-        DbProvider::new_ephemeral(),
+        DbProvider::new_in_memory(),
     );
 
     c.bench_function("Serial", |b| {
@@ -168,7 +168,7 @@ fn commit_big(c: &mut Criterion) {
         big_transactions,
         big_receipts.as_slice(),
         &big_state_updates,
-        DbProvider::new_ephemeral(),
+        DbProvider::new_in_memory(),
     );
 
     c.bench_function("Serial", |b| {

crates/core/src/backend/storage.rs

@@ -1,7 +1,6 @@
 use std::sync::Arc;
 
 use anyhow::{anyhow, bail, Context, Result};
-use katana_db::mdbx::DbEnv;
 use katana_primitives::block::{
     BlockHashOrNumber, BlockIdOrTag, BlockNumber, FinalityStatus, GasPrice, SealedBlockWithStatus,
 };
@@ -85,13 +84,13 @@ impl Blockchain {
     }
 
     /// Creates a new [Blockchain] from a database at `path` and `genesis` state.
-    pub fn new_with_db(db: DbEnv) -> Self {
+    pub fn new_with_db(db: katana_db::Db) -> Self {
         Self::new(DbProvider::new(db))
     }
 
     /// Builds a new blockchain with a forked block.
     pub async fn new_from_forked(
-        db: DbEnv,
+        db: katana_db::Db,
         fork_url: Url,
         fork_block: Option<BlockHashOrNumber>,
         chain: &mut katana_chain_spec::dev::ChainSpec,

crates/core/src/service/block_producer_tests.rs

@@ -13,7 +13,7 @@ use crate::backend::storage::Blockchain;
 fn test_backend() -> Arc<Backend<NoopExecutorFactory>> {
     let chain_spec = Arc::new(ChainSpec::dev());
     let executor_factory = NoopExecutorFactory::new();
-    let blockchain = Blockchain::new(DbProvider::new_ephemeral());
+    let blockchain = Blockchain::new(DbProvider::new_in_memory());
     let gas_oracle = GasOracle::fixed(Default::default(), Default::default());
     let backend = Arc::new(Backend::new(chain_spec, blockchain, gas_oracle, executor_factory));
     backend.init_genesis().expect("failed to initialize genesis");

crates/core/tests/backend.rs

@@ -33,7 +33,7 @@ fn executor(chain_spec: &ChainSpec) -> BlockifierFactory {
 }
 
 fn backend(chain_spec: &ChainSpec) -> Backend<BlockifierFactory> {
-    backend_with_db(chain_spec, DbProvider::new_ephemeral())
+    backend_with_db(chain_spec, DbProvider::new_in_memory())
 }
 
 fn backend_with_db(chain_spec: &ChainSpec, provider: impl Database) -> Backend<BlockifierFactory> {
@@ -83,7 +83,7 @@ fn can_initialize_genesis(#[case] chain: ChainSpec) {
 #[case::dev(ChainSpec::Dev(dev_chain_spec()))]
 #[case::rollup(ChainSpec::Rollup(rollup_chain_spec()))]
 fn can_reinitialize_genesis(#[case] chain: ChainSpec) {
-    let db = DbProvider::new_ephemeral();
+    let db = DbProvider::new_in_memory();
 
     let backend = backend_with_db(&chain, db.clone());
     backend.init_genesis().expect("failed to initialize genesis");
@@ -94,7 +94,7 @@ fn can_reinitialize_genesis(#[case] chain: ChainSpec) {
 
 #[test]
 fn reinitialize_with_different_rollup_chain_spec() {
-    let db = DbProvider::new_ephemeral();
+    let db = DbProvider::new_in_memory();
 
     let chain1 = ChainSpec::Rollup(rollup_chain_spec());
     let backend1 = backend_with_db(&chain1, db.clone());

crates/executor/tests/fixtures/mod.rs

@@ -72,7 +72,7 @@ pub fn state_provider(chain: &ChainSpec) -> Box<dyn StateProvider> {
     let ChainSpec::Dev(chain) = chain else { panic!("should be dev chain spec") };
 
     let states = chain.state_updates();
-    let provider = DbProvider::new_ephemeral();
+    let provider = DbProvider::new_in_memory();
 
     let block = SealedBlockWithStatus {
         status: FinalityStatus::AcceptedOnL2,

crates/node/src/full/mod.rs

@@ -8,7 +8,6 @@ use std::sync::Arc;
 
 use anyhow::Result;
 use exit::NodeStoppedFuture;
-use katana_db::mdbx::DbEnv;
 use katana_feeder_gateway::client::SequencerGateway;
 use katana_metrics::exporters::prometheus::PrometheusRecorder;
 use katana_metrics::{Report, Server as MetricsServer};
@@ -38,7 +37,7 @@ pub struct Config {
 
 #[derive(Debug)]
 pub struct Node {
-    pub db: DbEnv,
+    pub db: katana_db::Db,
     pub pool: TxPool,
     pub config: Arc<Config>,
     pub task_manager: TaskManager,
@@ -62,7 +61,7 @@ impl Node {
         let path = config.db.dir.clone().expect("database path must exist");
 
         info!(target: "node", path = %path.display(), "Initializing database.");
-        let db = katana_db::init_db(path)?;
+        let db = katana_db::Db::new(path)?;
 
         let provider = DbProvider::new(db.clone());
 
@@ -134,7 +133,7 @@ impl Node {
 
 #[derive(Debug)]
 pub struct LaunchedNode {
-    pub db: DbEnv,
+    pub db: katana_db::Db,
     pub pool: TxPool,
     pub task_manager: TaskManager,
     pub config: Arc<Config>,

crates/node/src/lib.rs

@@ -25,7 +25,7 @@ use katana_core::constants::{
 };
 use katana_core::env::BlockContextGenerator;
 use katana_core::service::block_producer::BlockProducer;
-use katana_db::mdbx::DbEnv;
+use katana_db::Db;
 use katana_executor::implementation::blockifier::cache::ClassCache;
 use katana_executor::implementation::blockifier::BlockifierFactory;
 use katana_executor::ExecutionFlags;
@@ -63,7 +63,7 @@ use crate::exit::NodeStoppedFuture;
 pub struct Node {
     config: Arc<Config>,
     pool: TxPool,
-    db: DbEnv,
+    db: katana_db::Db,
     rpc_server: RpcServer,
     task_manager: TaskManager,
     backend: Arc<Backend<BlockifierFactory>>,
@@ -138,7 +138,7 @@ impl Node {
                 return Err(anyhow::anyhow!("Forking is only supported in dev mode for now"));
             };
 
-            let db = katana_db::init_ephemeral_db()?;
+            let db = katana_db::Db::in_memory()?;
             let (bc, block_num) =
                 Blockchain::new_from_forked(db.clone(), cfg.url.clone(), cfg.block, chain_spec)
                     .await?;
@@ -149,10 +149,10 @@ impl Node {
 
             (bc, db, Some(forked_client))
         } else if let Some(db_path) = &config.db.dir {
-            let db = katana_db::init_db(db_path)?;
+            let db = katana_db::Db::new(db_path)?;
             (Blockchain::new_with_db(db.clone()), db, None)
         } else {
-            let db = katana_db::init_ephemeral_db()?;
+            let db = katana_db::Db::in_memory()?;
             (Blockchain::new_with_db(db.clone()), db, None)
         };
 
@@ -371,7 +371,7 @@ impl Node {
     }
 
     /// Returns a reference to the node's database environment (if any).
-    pub fn db(&self) -> &DbEnv {
+    pub fn db(&self) -> &Db {
         &self.db
     }