fix(pending): Inconsistent pending state

madara/Cargo.toml

@@ -221,6 +221,7 @@ siphasher = "1.0"
 lazy_static = { version = "1.4", default-features = false }
 bitvec = { version = "1.0", default-features = false, features = ["std"] }
 bytes = "1.6.0"
+indexmap = "2.10.0"
 
 # Error handling
 thiserror = "2.0"

madara/crates/client/block_production/src/lib.rs

@@ -272,9 +272,9 @@ impl BlockProductionTask {
 
         let (block, declared_classes) = get_pending_block_from_db(&self.backend)?;
 
-        self.backend.clear_pending_block().context("Error clearing pending block")?;
+        self.backend.clear_pending_block_in_db().context("Error clearing pending block")?;
 
-        let block_n = self.backend.get_latest_block_n().context("Getting latest block n")?.map(|n| n + 1).unwrap_or(0);
+        let block_n = self.backend.get_block_n_latest().map(|n| n + 1).unwrap_or(0);
         self.close_and_save_block(block_n, block, declared_classes, vec![]).await?;
 
         Ok(())
@@ -425,7 +425,7 @@ impl BlockProductionTask {
         let batch_size = self.backend.chain_config().block_production_concurrency.batch_size;
 
         // initial state
-        let latest_block_n = self.backend.get_latest_block_n().context("Getting latest block_n")?;
+        let latest_block_n = self.backend.get_block_n_latest();
         let latest_block_hash = if let Some(block_n) = latest_block_n {
             self.backend
                 .get_block_hash(&DbBlockId::Number(block_n))
@@ -1121,7 +1121,7 @@ pub(crate) mod tests {
             .store_block(
                 mp_block::MadaraMaybePendingBlock {
                     info: mp_block::MadaraMaybePendingBlockInfo::Pending(mp_block::MadaraPendingBlockInfo {
-                        header: mp_block::header::PendingHeader::default(),
+                        header: mp_block::header::PendingHeader { parent_block_number: Some(0), ..Default::default() },
                         tx_hashes: vec![Felt::ONE, Felt::TWO, Felt::THREE],
                     }),
                     inner: pending_inner.clone(),
@@ -1138,11 +1138,11 @@ pub(crate) mod tests {
         // This should load the pending block from db and close it
         let mut block_production_task =
             BlockProductionTask::new(Arc::clone(&backend), Arc::clone(&mempool), metrics, l1_data_provider);
-        assert_eq!(backend.get_latest_block_n().unwrap(), Some(0));
+        assert_eq!(backend.get_block_n_latest(), Some(0));
         block_production_task.close_pending_block_if_exists().await.unwrap();
 
         // Now we check this was the case.
-        assert_eq!(backend.get_latest_block_n().unwrap(), Some(1));
+        assert_eq!(backend.get_block_n_latest(), Some(1));
 
         let block_inner = backend
             .get_block(&mp_block::BlockId::Tag(mp_block::BlockTag::Latest))
@@ -1368,7 +1368,7 @@ pub(crate) mod tests {
             .store_block(
                 mp_block::MadaraMaybePendingBlock {
                     info: mp_block::MadaraMaybePendingBlockInfo::Pending(mp_block::MadaraPendingBlockInfo {
-                        header: mp_block::header::PendingHeader::default(),
+                        header: mp_block::header::PendingHeader { parent_block_number: Some(0), ..Default::default() },
                         tx_hashes: vec![Felt::ONE, Felt::TWO, Felt::THREE],
                     }),
                     inner: pending_inner.clone(),
@@ -1389,7 +1389,7 @@ pub(crate) mod tests {
         block_production_task.close_pending_block_if_exists().await.unwrap();
 
         // Now we check this was the case.
-        assert_eq!(backend.get_latest_block_n().unwrap().unwrap(), 1);
+        assert_eq!(backend.get_block_n_latest().unwrap(), 1);
 
         // Block 0 should not have been overridden!
         let block = backend
@@ -1462,11 +1462,11 @@ pub(crate) mod tests {
         // Simulates starting block production without a pending block in db
         let mut block_production_task =
             BlockProductionTask::new(Arc::clone(&backend), Arc::clone(&mempool), metrics, l1_data_provider);
-        assert_eq!(backend.get_latest_block_n().unwrap(), Some(0)); // there is a genesis block in the db.
+        assert_eq!(backend.get_block_n_latest(), Some(0)); // there is a genesis block in the db.
         block_production_task.close_pending_block_if_exists().await.unwrap();
 
         // Now we check no block was added to the db
-        assert_eq!(backend.get_latest_block_n().unwrap(), Some(0));
+        assert_eq!(backend.get_block_n_latest(), Some(0));
     }
 
     /// This test makes sure that closing the pending block from db will fail if
@@ -1713,7 +1713,7 @@ pub(crate) mod tests {
         let pending_block: mp_block::MadaraMaybePendingBlock = backend.get_block(&DbBlockId::Pending).unwrap().unwrap();
 
         assert_eq!(pending_block.inner.transactions.len(), 0);
-        assert_eq!(backend.get_latest_block_n().unwrap().unwrap(), 0);
+        assert_eq!(backend.get_block_n_latest().unwrap(), 0);
 
         // ================================================================== //
         //                  PART 3: call on pending time tick                 //
@@ -1733,7 +1733,7 @@ pub(crate) mod tests {
 
         assert!(mempool.is_empty().await);
         assert_eq!(pending_block.inner.transactions.len(), 1);
-        assert_eq!(backend.get_latest_block_n().unwrap().unwrap(), 0);
+        assert_eq!(backend.get_block_n_latest().unwrap(), 0);
     }
 
     // This test makes sure that the pending tick closes the block
@@ -1778,7 +1778,7 @@ pub(crate) mod tests {
         let pending_block: mp_block::MadaraMaybePendingBlock = backend.get_block(&DbBlockId::Pending).unwrap().unwrap();
 
         assert_eq!(pending_block.inner.transactions.len(), 0);
-        assert_eq!(backend.get_latest_block_n().unwrap().unwrap(), 0);
+        assert_eq!(backend.get_block_n_latest().unwrap(), 0);
 
         // ================================================================== //
         //                  PART 3: call on pending time tick                 //
@@ -1845,7 +1845,7 @@ pub(crate) mod tests {
         let pending_block: mp_block::MadaraMaybePendingBlock = backend.get_block(&DbBlockId::Pending).unwrap().unwrap();
 
         assert_eq!(pending_block.inner.transactions.len(), 0);
-        assert_eq!(backend.get_latest_block_n().unwrap().unwrap(), 0);
+        assert_eq!(backend.get_block_n_latest().unwrap(), 0);
 
         // ================================================================== //
         //                      PART 3: call on block time                    //
@@ -1869,7 +1869,7 @@ pub(crate) mod tests {
 
         assert!(mempool.is_empty().await);
         assert!(pending_block.inner.transactions.is_empty());
-        assert_eq!(backend.get_latest_block_n().unwrap().unwrap(), 1);
+        assert_eq!(backend.get_block_n_latest().unwrap(), 1);
     }
 
     // This test checks when the block production task starts on
@@ -1911,7 +1911,7 @@ pub(crate) mod tests {
             BlockProductionTask::new(Arc::clone(&backend), Arc::clone(&mempool), metrics, l1_data_provider);
         block_production_task.close_pending_block_if_exists().await.unwrap();
 
-        assert_eq!(backend.get_latest_block_n().unwrap().unwrap(), 0);
+        assert_eq!(backend.get_block_n_latest().unwrap(), 0);
 
         // ================================================================== //
         //                  PART 3: init block production task                //
@@ -1936,7 +1936,7 @@ pub(crate) mod tests {
         assert!(mempool.is_empty().await);
         assert!(pending_block.inner.transactions.is_empty());
         assert_eq!(block_inner.transactions.len(), 1);
-        assert_eq!(backend.get_latest_block_n().unwrap().unwrap(), 1);
+        assert_eq!(backend.get_block_n_latest().unwrap(), 1);
     }
 
     // This test just verifies that pre validation checks and
@@ -1980,7 +1980,7 @@ pub(crate) mod tests {
             BlockProductionTask::new(Arc::clone(&backend), Arc::clone(&mempool), metrics, l1_data_provider);
         block_production_task.close_pending_block_if_exists().await.unwrap();
 
-        assert_eq!(backend.get_latest_block_n().unwrap().unwrap(), 0);
+        assert_eq!(backend.get_block_n_latest().unwrap(), 0);
 
         // ================================================================== //
         //                  PART 3: init block production task                //

madara/crates/client/block_production/src/util.rs

@@ -123,6 +123,7 @@ impl BlockExecutionContext {
     pub fn into_header(self, parent_block_hash: Felt) -> PendingHeader {
         PendingHeader {
             parent_block_hash,
+            parent_block_number: self.block_n.checked_sub(1),
             sequencer_address: self.sequencer_address,
             block_timestamp: self.block_timestamp.into(),
             protocol_version: self.protocol_version,

madara/crates/client/db/Cargo.toml

@@ -40,14 +40,18 @@ starknet_api = { workspace = true }
 anyhow.workspace = true
 bincode = { workspace = true }
 bitvec = { workspace = true }
-futures = { workspace = true }
 librocksdb-sys = { workspace = true }
-rayon = { workspace = true }
 rocksdb.workspace = true
+rstest = { workspace = true, optional = true }
 serde = { workspace = true }
 siphasher.workspace = true
 tempfile = { workspace = true, optional = true }
 thiserror = { workspace = true }
+indexmap = { workspace = true }
+
+# Async
+futures = { workspace = true }
+rayon = { workspace = true }
 tokio = { workspace = true, features = [
   "macros",
   "parking_lot",
@@ -75,12 +79,12 @@ tracing-subscriber = { workspace = true, features = ["env-filter"] }
 [dev-dependencies]
 proptest = { workspace = true }
 serde_json = { workspace = true }
-tempfile = "3.10"
+tempfile = { workspace = true }
 lazy_static = { workspace = true }
 mp-transactions = { workspace = true }
 rstest = { workspace = true }
 rand = { workspace = true }
 
 [features]
 default = []
-testing = ["tempfile", "starknet_api/testing"]
+testing = ["tempfile", "rstest", "starknet_api/testing"]