wip

Author: kariy

crates/core/src/backend/mod.rs

@@ -178,9 +178,9 @@ where
             l1_data_gas_prices: block_env.l1_data_gas_prices.clone(),
         };
 
-        let provider = self.storage.provider_mut();
+        let provider_mut = self.storage.provider_mut();
         let block = commit_block(
-            provider,
+            &provider_mut,
             partial_header,
             transactions,
             &receipts,
@@ -194,10 +194,12 @@ where
         // TODO: maybe should change the arguments for insert_block_with_states_and_receipts to
         // accept ReceiptWithTxHash instead to avoid this conversion.
         let receipts = receipts.into_iter().map(|r| r.receipt).collect::<Vec<_>>();
-        self.store_block(block, execution_output.states, receipts, traces)?;
+        store_block(&provider_mut, block, execution_output.states, receipts, traces)?;
 
         info!(target: LOG_TARGET, %block_number, %tx_count, "Block mined.");
 
+        provider_mut.commit()?;
+
         Ok(MinedBlockOutcome {
             block_hash,
             block_number,
@@ -206,28 +208,6 @@ where
         })
     }
 
-    fn store_block(
-        &self,
-        block: SealedBlockWithStatus,
-        states: StateUpdatesWithClasses,
-        receipts: Vec<Receipt>,
-        traces: Vec<TypedTransactionExecutionInfo>,
-    ) -> Result<(), BlockProductionError> {
-        // Validate that all declared classes have their corresponding class artifacts
-        if let Err(missing) = states.validate_classes() {
-            return Err(BlockProductionError::InconsistentState(format!(
-                "missing class artifacts for declared classes: {:#?}",
-                missing,
-            )));
-        }
-
-        let provider_mut = self.storage.provider_mut();
-        provider_mut.insert_block_with_states_and_receipts(block, states, receipts, traces)?;
-        provider_mut.commit()?;
-
-        Ok(())
-    }
-
     pub fn mine_empty_block(
         &self,
         block_env: &BlockEnv,
@@ -349,8 +329,10 @@ where
 
             info!("Genesis has already been initialized");
         } else {
+            let provider_mut = self.storage.provider_mut();
+
             let block = commit_genesis_block(
-                self.storage.provider_mut(),
+                &provider_mut,
                 header,
                 transactions,
                 &receipts,
@@ -362,8 +344,9 @@ where
             // TODO: maybe should change the arguments for insert_block_with_states_and_receipts to
             // accept ReceiptWithTxHash instead to avoid this conversion.
             let receipts = receipts.into_iter().map(|r| r.receipt).collect::<Vec<_>>();
-            self.store_block(block, output.states, receipts, traces)?;
+            store_block(&provider_mut, block, output.states, receipts, traces)?;
 
+            provider_mut.commit()?;
             info!("Genesis initialized");
         }
 
@@ -558,6 +541,25 @@ impl<'a, P: TrieWriter> UncommittedBlock<'a, P> {
     }
 }
 
+fn store_block(
+    provider_mut: &impl BlockWriter,
+    block: SealedBlockWithStatus,
+    states: StateUpdatesWithClasses,
+    receipts: Vec<Receipt>,
+    traces: Vec<TypedTransactionExecutionInfo>,
+) -> Result<(), BlockProductionError> {
+    // Validate that all declared classes have their corresponding class artifacts
+    if let Err(missing) = states.validate_classes() {
+        return Err(BlockProductionError::InconsistentState(format!(
+            "missing class artifacts for declared classes: {:#?}",
+            missing,
+        )));
+    }
+
+    provider_mut.insert_block_with_states_and_receipts(block, states, receipts, traces)?;
+    Ok(())
+}
+
 // TODO: create a dedicated struct for this contract.
 // https://docs.starknet.io/architecture-and-concepts/network-architecture/starknet-state/#address_0x1
 fn update_block_hash_registry_contract(
@@ -587,8 +589,8 @@ fn update_block_hash_registry_contract(
     Ok(())
 }
 
-fn commit_block(
-    provider: impl ProviderRW,
+fn commit_block<P: BlockHashProvider + TrieWriter>(
+    provider: P,
     header: PartialHeader,
     transactions: Vec<TxWithHash>,
     receipts: &[ReceiptWithTxHash],

crates/core/src/service/block_producer.rs

@@ -694,7 +694,7 @@ where
 
         // TODO: don't use the previous block env, we should create on based on the current state of
         // the l1 (to determine the proper gas prices)
-        let latest_num = provider.latest_number()?;
+        let latest_num = dbg!(provider.latest_number()?);
         let mut block_env = provider.block_env_at(BlockHashOrNumber::Num(latest_num))?.unwrap();
         backend.update_block_env(&mut block_env);
 

crates/node/src/lib.rs

@@ -172,7 +172,9 @@ where
             chain_spec: config.chain.clone(),
         });
 
+        println!("initializing genesis");
         backend.init_genesis(config.forking.is_some()).context("failed to initialize genesis")?;
+        println!("genesis initialized");
 
         // --- build block producer
 
@@ -306,6 +308,8 @@ where
             None
         };
 
+        println!("node built");
+
         Ok(Node {
             provider,
             pool,
@@ -419,6 +423,7 @@ impl Node<ForkProviderFactory> {
 
         block.header.l1_da_mode = forked_block.l1_da_mode;
 
+        println!("ohayo");
         Self::build_with_provider(provider_factory, config)
     }
 }

crates/rpc/rpc-server/tests/forking.rs

@@ -14,6 +14,7 @@ use katana_rpc_types::{
     BlockNumberResponse, EventFilter, GetBlockWithReceiptsResponse, GetBlockWithTxHashesResponse,
     MaybePreConfirmedBlock,
 };
+use katana_utils::node::ForkTestNode;
 use katana_utils::TestNode;
 use url::Url;
 
@@ -36,12 +37,12 @@ type LocalTestVector = Vec<((BlockNumber, BlockHash), TxHash)>;
 /// a single transaction.
 ///
 /// The returned [`TestVector`] is a list of all the locally created blocks and transactions.
-async fn setup_test_inner(no_mining: bool) -> (TestNode, StarknetClient, LocalTestVector) {
+async fn setup_test_inner(no_mining: bool) -> (ForkTestNode, StarknetClient, LocalTestVector) {
     let mut config = katana_utils::node::test_config();
     config.sequencing.no_mining = no_mining;
     config.forking = Some(forking_cfg());
 
-    let sequencer = TestNode::new_with_config(config).await;
+    let sequencer = TestNode::new_forked_with_config(config).await;
     let provider = sequencer.starknet_rpc_client();
 
     let mut txs_vector: LocalTestVector = Vec::new();
@@ -72,7 +73,7 @@ async fn setup_test_inner(no_mining: bool) -> (TestNode, StarknetClient, LocalTe
             let block_num = (FORK_BLOCK_NUMBER + 1) + i; // plus 1 because fork genesis is FORK_BLOCK_NUMBER + 1
 
             let block_id = BlockIdOrTag::Number(block_num);
-            let block = provider.get_block_with_tx_hashes(block_id).await.unwrap();
+            let block = provider.get_block_with_tx_hashes(dbg!(block_id)).await.unwrap();
             let block_hash = match block {
                 GetBlockWithTxHashesResponse::Block(b) => {
                     assert_eq!(b.transactions.len(), 1);
@@ -89,11 +90,11 @@ async fn setup_test_inner(no_mining: bool) -> (TestNode, StarknetClient, LocalTe
     (sequencer, provider, txs_vector)
 }
 
-async fn setup_test() -> (TestNode, StarknetClient, LocalTestVector) {
+async fn setup_test() -> (ForkTestNode, StarknetClient, LocalTestVector) {
     setup_test_inner(false).await
 }
 
-async fn setup_test_pending() -> (TestNode, StarknetClient, LocalTestVector) {
+async fn setup_test_pending() -> (ForkTestNode, StarknetClient, LocalTestVector) {
     setup_test_inner(true).await
 }
 

crates/storage/provider/provider/src/lib.rs

@@ -106,23 +106,22 @@ impl Debug for ForkProviderFactory {
 }
 
 impl ProviderFactory for ForkProviderFactory {
-    type Provider =
-        ForkedProvider<<katana_db::Db as Database>::Tx, <katana_db::Db as Database>::TxMut>;
+    type Provider = ForkedProvider<<katana_db::Db as Database>::Tx>;
 
-    type ProviderMut =
-        ForkedProvider<<katana_db::Db as Database>::TxMut, <katana_db::Db as Database>::TxMut>;
+    type ProviderMut = ForkedProvider<<katana_db::Db as Database>::TxMut>;
 
     fn provider(&self) -> Self::Provider {
         ForkedProvider::new(
             self.local_factory.provider(),
-            ForkedDb::new(self.backend.clone(), self.block_id, self.fork_factory.provider_mut()),
+            ForkedDb::new(self.backend.clone(), self.block_id, self.fork_factory.clone()),
         )
     }
 
     fn provider_mut(&self) -> Self::ProviderMut {
+        dbg!("creating provider_mut");
         ForkedProvider::new(
             self.local_factory.provider_mut(),
-            ForkedDb::new(self.backend.clone(), self.block_id, self.fork_factory.provider_mut()),
+            ForkedDb::new(self.backend.clone(), self.block_id, self.fork_factory.clone()),
         )
     }
 }