fix tests

Author: kariy

Cargo.lock

@@ -22,17 +22,16 @@ derive_more.workspace = true
 futures.workspace = true
 lazy_static.workspace = true
 metrics.workspace = true
-num-traits.workspace = true
 parking_lot.workspace = true
 rayon.workspace = true
 starknet.workspace = true
 starknet-types-core.workspace = true
 thiserror.workspace = true
 tokio.workspace = true
 tracing.workspace = true
-url.workspace = true
 
 [dev-dependencies]
+url.workspace = true
 alloy-primitives = { workspace = true, features = [ "serde" ] }
 arbitrary.workspace = true
 assert_matches.workspace = true

crates/core/Cargo.toml

@@ -24,7 +24,6 @@ use katana_primitives::version::CURRENT_STARKNET_VERSION;
 use katana_primitives::{address, Felt};
 use katana_provider::api::block::BlockWriter;
 use katana_provider::api::state::{StateFactoryProvider, StateProvider};
-use katana_provider::providers::db::DbProvider;
 use katana_provider::{DbProviderFactory, MutableProvider, ProviderFactory};
 use starknet::macros::felt;
 

crates/executor/tests/fixtures/mod.rs

@@ -34,7 +34,6 @@ futures.workspace = true
 http.workspace = true
 jsonrpsee.workspace = true
 serde.workspace = true
-starknet.workspace = true
 parking_lot.workspace = true
 thiserror.workspace = true
 tracing.workspace = true

crates/node/Cargo.toml

@@ -68,7 +68,6 @@ where
     provider: P,
     config: Arc<Config>,
     pool: TxPool,
-    // db: katana_db::Db,
     rpc_server: RpcServer,
     task_manager: TaskManager,
     backend: Arc<Backend<BlockifierFactory, P>>,
@@ -87,8 +86,6 @@ where
     /// This returns a [`Node`] instance which can be launched with the all the necessary components
     /// configured.
     pub fn build_with_provider(provider: P, config: Config) -> Result<Node<P>> {
-        let mut config = config;
-
         if config.metrics.is_some() {
             // Metrics recorder must be initialized before calling any of the metrics macros, in
             // order for it to be registered.
@@ -100,33 +97,6 @@ where
         let task_manager = TaskManager::current();
         let task_spawner = task_manager.task_spawner();
 
-        // --- build backend
-
-        // let (storage, db) = if let Some(cfg) = &config.forking {
-        //     // NOTE: because the chain spec will be cloned for the BlockifierFactory (see below),
-        //     // this mutation must be performed before the chain spec is cloned. Otherwise
-        //     // this will panic.
-        //     let chain_spec = Arc::get_mut(&mut config.chain).expect("get mut Arc");
-
-        //     let ChainSpec::Dev(chain_spec) = chain_spec else {
-        //         return Err(anyhow::anyhow!("Forking is only supported in dev mode for now"));
-        //     };
-
-        //     let db = katana_db::Db::in_memory()?;
-
-        //     let provider =
-        //         StorageProvider::new_forked(db.clone(), cfg.url.clone(), cfg.block, chain_spec)
-        //             .await?;
-
-        //     (Arc::new(provider) as GenericStorageProvider, db)
-        // } else if let Some(db_path) = &config.db.dir {
-        //     let db = katana_db::Db::new(db_path)?;
-        //     (Arc::new(StorageProvider::new_with_db(db.clone())) as GenericStorageProvider, db)
-        // } else {
-        //     let db = katana_db::Db::in_memory()?;
-        //     (Arc::new(StorageProvider::new_with_db(db.clone())) as GenericStorageProvider, db)
-        // };
-
         // --- build executor factory
 
         // Create versioned constants overrides from config
@@ -191,6 +161,8 @@ where
         // Get cfg_env before moving executor_factory into Backend
         let versioned_constant_overrides = executor_factory.overrides().cloned();
 
+        // --- build backend
+
         let block_context_generator = BlockContextGenerator::default().into();
         let backend = Arc::new(Backend {
             gas_oracle: gas_oracle.clone(),
@@ -530,10 +502,10 @@ where
         Ok(LaunchedNode { node: self, rpc: rpc_handle, gateway: gateway_handle })
     }
 
-    // /// Returns a reference to the node's database environment (if any).
-    // pub fn db(&self) -> &Db {
-    //     &self.db
-    // }
+    /// Returns a reference to the node's database environment (if any).
+    pub fn provider(&self) -> &P {
+        &self.provider
+    }
 
     pub fn backend(&self) -> &Arc<Backend<BlockifierFactory, P>> {
         &self.backend

crates/node/src/lib.rs

@@ -20,9 +20,11 @@ use rstest_reuse::{self, *};
 mod fixtures;
 mod utils;
 
-use fixtures::{db_provider, mock_state_updates, provider_with_states};
+use fixtures::{db_provider, mock_state_updates};
 use katana_primitives::Felt;
 
+use crate::fixtures::db_provider_with_states;
+
 #[apply(insert_block_cases)]
 fn insert_block_with_db_provider(
     #[from(db_provider)] provider_factory: DbProviderFactory,
@@ -268,7 +270,7 @@ where
 
 #[apply(test_read_state_update)]
 fn test_read_state_update_with_db_provider(
-    #[with(db_provider())] provider_factory: DbProviderFactory,
+    #[from(db_provider_with_states)] provider_factory: DbProviderFactory,
     #[case] block_num: BlockNumber,
     #[case] expected_state_update: StateUpdatesWithClasses,
 ) -> Result<()> {
@@ -301,14 +303,13 @@ fn insert_block_cases(#[case] block_count: u64) {}
 #[case::state_update_at_block_3(3, StateUpdatesWithClasses::default())]
 #[case::state_update_at_block_5(5, mock_state_updates()[2].clone())]
 fn test_read_state_update(
-    #[from(provider_with_states)] provider_factory: impl ProviderFactory,
     #[case] block_num: BlockNumber,
     #[case] expected_state_update: StateUpdatesWithClasses,
 ) {
 }
 
 mod fork {
-    use fixtures::fork::{fork_provider, fork_provider_with_spawned_fork_network};
+    use fixtures::fork::{fork_provider, fork_provider_with_spawned_fork_network_and_states};
     use katana_provider::ForkProviderFactory;
 
     use super::*;
@@ -341,7 +342,7 @@ mod fork {
 
     #[apply(test_read_state_update)]
     fn test_read_state_update_with_fork_provider(
-        #[with(fork_provider_with_spawned_fork_network::default())]
+        #[from(fork_provider_with_spawned_fork_network_and_states)]
         provider_factory: ForkProviderFactory,
         #[case] block_num: BlockNumber,
         #[case] expected_state_update: StateUpdatesWithClasses,

crates/storage/provider/provider/tests/block.rs

@@ -1,14 +1,15 @@
 mod fixtures;
 
 use anyhow::Result;
-use fixtures::{provider_with_states, DOJO_WORLD_SIERRA_CLASS};
 use katana_primitives::block::{BlockHashOrNumber, BlockNumber};
 use katana_primitives::class::{ClassHash, CompiledClassHash, ContractClass};
 use katana_provider::api::contract::ContractClassProviderExt;
 use katana_provider::api::state::{StateFactoryProvider, StateProvider};
 use rstest_reuse::{self, *};
 use starknet::macros::felt;
 
+use crate::fixtures::{db_provider_with_states, DOJO_WORLD_SIERRA_CLASS};
+
 type ClassHashAndClasses = (ClassHash, Option<CompiledClassHash>, Option<ContractClass>);
 
 fn assert_state_provider_class(
@@ -36,7 +37,6 @@ mod latest {
     use katana_provider::{DbProviderFactory, ProviderFactory};
 
     use super::*;
-    use crate::fixtures::db_provider;
 
     fn assert_latest_class(
         provider: impl StateFactoryProvider,
@@ -55,21 +55,17 @@ mod latest {
             (felt!("33"), Some(felt!("3000")), Some(ContractClass::Class((*DOJO_WORLD_SIERRA_CLASS).clone()))),
         ]
     )]
-    fn test_latest_class_read(
-        #[from(provider_with_states)] provider_factory: impl ProviderFactory,
-        #[case] expected_class: Vec<ClassHashAndClasses>,
-    ) {
-    }
+    fn test_latest_class_read(#[case] expected_class: Vec<ClassHashAndClasses>) {}
 
     mod fork {
-        use fixtures::fork::fork_provider_with_spawned_fork_network;
-        use katana_provider::{ForkProviderFactory, ProviderFactory};
+        use fixtures::fork::fork_provider_with_spawned_fork_network_and_states;
+        use katana_provider::ForkProviderFactory;
 
         use super::*;
 
         #[apply(test_latest_class_read)]
         fn read_class_from_fork_provider(
-            #[with(fork_provider_with_spawned_fork_network::default())]
+            #[from(fork_provider_with_spawned_fork_network_and_states)]
             provider_factory: ForkProviderFactory,
             #[case] expected_classes: Vec<ClassHashAndClasses>,
         ) -> Result<()> {
@@ -80,7 +76,7 @@ mod latest {
 
     #[apply(test_latest_class_read)]
     fn read_class_from_db_provider(
-        #[with(db_provider())] provider_factory: DbProviderFactory,
+        #[from(db_provider_with_states)] provider_factory: DbProviderFactory,
         #[case] expected_classes: Vec<ClassHashAndClasses>,
     ) -> Result<()> {
         let provider = provider_factory.provider();
@@ -93,7 +89,6 @@ mod historical {
     use katana_provider::{DbProviderFactory, ProviderFactory};
 
     use super::*;
-    use crate::fixtures::db_provider;
 
     fn assert_historical_class(
         provider: impl StateFactoryProvider,
@@ -143,21 +138,20 @@ mod historical {
         ])
     ]
     fn test_historical_class_read(
-        #[from(provider_with_states)] provider_factory: impl ProviderFactory,
         #[case] block_num: BlockNumber,
         #[case] expected_class: Vec<ClassHashAndClasses>,
     ) {
     }
 
     mod fork {
-        use fixtures::fork::fork_provider_with_spawned_fork_network;
-        use katana_provider::{ForkProviderFactory, ProviderFactory};
+        use fixtures::fork::fork_provider_with_spawned_fork_network_and_states;
+        use katana_provider::ForkProviderFactory;
 
         use super::*;
 
         #[apply(test_historical_class_read)]
         fn read_class_from_fork_provider(
-            #[with(fork_provider_with_spawned_fork_network::default())]
+            #[from(fork_provider_with_spawned_fork_network_and_states)]
             provider_factory: ForkProviderFactory,
             #[case] block_num: BlockNumber,
             #[case] expected_classes: Vec<ClassHashAndClasses>,
@@ -169,7 +163,7 @@ mod historical {
 
     #[apply(test_historical_class_read)]
     fn read_class_from_db_provider(
-        #[with(db_provider())] provider_factory: DbProviderFactory,
+        #[from(db_provider_with_states)] provider_factory: DbProviderFactory,
         #[case] block_num: BlockNumber,
         #[case] expected_classes: Vec<ClassHashAndClasses>,
     ) -> Result<()> {

crates/storage/provider/provider/tests/class.rs

@@ -1,14 +1,15 @@
 mod fixtures;
 
 use anyhow::Result;
-use fixtures::{db_provider, provider_with_states};
 use katana_primitives::block::{BlockHashOrNumber, BlockNumber};
 use katana_primitives::class::ClassHash;
 use katana_primitives::contract::{ContractAddress, Nonce};
 use katana_provider::api::state::{StateFactoryProvider, StateProvider};
 use rstest_reuse::{self, *};
 use starknet::macros::felt;
 
+use crate::fixtures::db_provider_with_states;
+
 fn assert_state_provider_contract_info(
     state_provider: Box<dyn StateProvider>,
     expected_contract_info: Vec<(ContractAddress, Option<ClassHash>, Option<Nonce>)>,
@@ -46,20 +47,19 @@ mod latest {
         ]
     )]
     fn test_latest_contract_info_read(
-        #[from(provider_with_states)] provider_factory: impl ProviderFactory,
         #[case] expected_contract_info: Vec<(ContractAddress, Option<ClassHash>, Option<Nonce>)>,
     ) {
     }
 
     mod fork {
-        use fixtures::fork::fork_provider_with_spawned_fork_network;
-        use katana_provider::{ForkProviderFactory, ProviderFactory};
+        use fixtures::fork::fork_provider_with_spawned_fork_network_and_states;
+        use katana_provider::ForkProviderFactory;
 
         use super::*;
 
         #[apply(test_latest_contract_info_read)]
         fn read_storage_from_fork_provider(
-            #[with(fork_provider_with_spawned_fork_network::default())]
+            #[from(fork_provider_with_spawned_fork_network_and_states)]
             provider_factory: ForkProviderFactory,
             #[case] expected_contract_info: Vec<(
                 ContractAddress,
@@ -74,7 +74,7 @@ mod latest {
 
     #[apply(test_latest_contract_info_read)]
     fn read_storage_from_db_provider(
-        #[with(db_provider())] provider_factory: DbProviderFactory,
+        #[from(db_provider_with_states)] provider_factory: DbProviderFactory,
         #[case] expected_contract_info: Vec<(ContractAddress, Option<ClassHash>, Option<Nonce>)>,
     ) -> Result<()> {
         let provider = provider_factory.provider();
@@ -131,21 +131,20 @@ mod historical {
     ])
 ]
     fn test_historical_storage_read(
-        #[from(provider_with_states)] provider_factory: impl ProviderFactory,
         #[case] block_num: BlockNumber,
         #[case] expected_contract_info: Vec<(ContractAddress, Option<ClassHash>, Option<Nonce>)>,
     ) {
     }
 
     mod fork {
-        use fixtures::fork::fork_provider_with_spawned_fork_network;
+        use fixtures::fork::fork_provider_with_spawned_fork_network_and_states;
         use katana_provider::ForkProviderFactory;
 
         use super::*;
 
         #[apply(test_historical_storage_read)]
         fn read_storage_from_fork_provider(
-            #[with(fork_provider_with_spawned_fork_network::default())]
+            #[from(fork_provider_with_spawned_fork_network_and_states)]
             provider_factory: ForkProviderFactory,
             #[case] block_num: BlockNumber,
             #[case] expected_contract_info: Vec<(
@@ -161,7 +160,7 @@ mod historical {
 
     #[apply(test_historical_storage_read)]
     fn read_storage_from_db_provider(
-        #[with(db_provider())] provider_factory: DbProviderFactory,
+        #[from(db_provider_with_states)] provider_factory: DbProviderFactory,
         #[case] block_num: BlockNumber,
         #[case] expected_contract_info: Vec<(ContractAddress, Option<ClassHash>, Option<Nonce>)>,
     ) -> Result<()> {