tests: add a simple DB test

Author: prestwich

crates/db/Cargo.toml

@@ -33,4 +33,5 @@ auto_impl = "1.3.0"
 [dev-dependencies]
 serde_json.workspace = true
 reth-db = { workspace = true, features = ["test-utils"] }
-reth-exex-test-utils.workspace = true
+reth-exex-test-utils.workspace = true
+signet-constants = { workspace = true, features = ["test-utils"] }

crates/db/src/provider.rs

@@ -8,16 +8,14 @@ use alloy::{
     primitives::{Address, B256, BlockNumber, U256, map::HashSet},
 };
 use reth::{
-    primitives::{Account, StaticFileSegment},
+    primitives::StaticFileSegment,
     providers::{
-        AccountReader, BlockBodyIndicesProvider, BlockNumReader, BlockReader, BlockWriter, Chain,
-        DBProvider, HistoryWriter, OriginalValuesKnown, ProviderError, ProviderResult,
-        StageCheckpointWriter, StateWriter, StaticFileProviderFactory, StaticFileWriter,
-        StorageLocation,
+        BlockBodyIndicesProvider, BlockNumReader, BlockReader, BlockWriter, Chain, DBProvider,
+        HistoryWriter, OriginalValuesKnown, ProviderError, ProviderResult, StageCheckpointWriter,
+        StateWriter, StaticFileProviderFactory, StaticFileWriter, StorageLocation,
     },
 };
 use reth_db::{
-    PlainAccountState,
     cursor::{DbCursorRO, DbCursorRW},
     models::{BlockNumberAddress, StoredBlockBodyIndices},
     tables,

crates/db/src/traits.rs

@@ -1,10 +1,7 @@
 use crate::{DbExtractionResults, DbSignetEvent, RuChain, SignetDbRw};
-use alloy::primitives::{Address, B256, BlockNumber, U256};
+use alloy::primitives::{B256, BlockNumber};
 use itertools::Itertools;
-use reth::{
-    primitives::Account,
-    providers::{OriginalValuesKnown, ProviderResult, StorageLocation},
-};
+use reth::providers::{OriginalValuesKnown, ProviderResult, StorageLocation};
 use reth_db::models::StoredBlockBodyIndices;
 use signet_evm::BlockResult;
 use signet_node_types::NodeTypesDbTrait;

crates/db/tests/db.rs

@@ -1,7 +1,16 @@
 #[path = "./common/mod.rs"]
 mod test_common;
 
+use alloy::{
+    consensus::{BlockBody, BlockHeader, Signed, TxEip1559, TxEnvelope},
+    primitives::{Address, B256, U256},
+    signers::Signature,
+};
+use reth::providers::{BlockNumReader, BlockReader};
+use signet_constants::test_utils::{DEPLOY_HEIGHT, RU_CHAIN_ID};
 use signet_db::RuWriter;
+use signet_types::primitives::{RecoveredBlock, SealedBlock, SealedHeader};
+use signet_zenith::Zenith;
 
 #[test]
 fn test_ru_writer() {
@@ -11,3 +20,63 @@ fn test_ru_writer() {
 
     dbg!(writer.last_block_number().unwrap());
 }
+
+#[test]
+fn test_insert_signet_block() {
+    let factory = test_common::create_test_provider_factory();
+    let writer = factory.provider_rw().unwrap();
+
+    let journal_hash = B256::repeat_byte(0x55);
+    let header = Some(Zenith::BlockHeader {
+        rollupChainId: U256::from(RU_CHAIN_ID),
+        hostBlockNumber: U256::from(DEPLOY_HEIGHT),
+        gasLimit: U256::from(30_000_000),
+        rewardAddress: Address::repeat_byte(0x11),
+        blockDataHash: B256::repeat_byte(0x22),
+    });
+
+    let block = RecoveredBlock {
+        block: SealedBlock {
+            header: SealedHeader::new(alloy::consensus::Header::default()),
+            body: BlockBody {
+                transactions: std::iter::repeat(
+                    TxEnvelope::Eip1559(Signed::new_unhashed(
+                        TxEip1559::default(),
+                        Signature::test_signature(),
+                    ))
+                    .into(),
+                )
+                .take(10)
+                .collect(),
+                ommers: vec![],
+                withdrawals: None,
+            },
+        },
+        senders: std::iter::repeat(Address::repeat_byte(0x33)).take(10).collect(),
+    };
+
+    writer
+        .insert_signet_block(header, &block, journal_hash, reth::providers::StorageLocation::Both)
+        .unwrap();
+
+    // Check basic updates
+    assert_eq!(writer.last_block_number().unwrap(), block.number());
+    assert_eq!(writer.latest_journal_hash().unwrap(), journal_hash);
+    assert_eq!(writer.get_journal_hash(block.number()).unwrap(), Some(journal_hash));
+    // This tests resolving `BlockId::Latest`
+    assert_eq!(writer.best_block_number().unwrap(), block.number());
+
+    // Check that the block can be loaded back
+    let loaded_block = writer
+        .recovered_block_range(block.number()..=block.number())
+        .unwrap()
+        .first()
+        .cloned()
+        .unwrap();
+    assert_eq!(loaded_block.header(), block.block.header.header());
+    assert_eq!(loaded_block.body().transactions.len(), block.block.body.transactions.len());
+
+    // Check that the ZenithHeader can be loaded back
+    let loaded_header = writer.get_signet_header(block.number()).unwrap();
+    assert_eq!(loaded_header, header);
+}