test: ReceiptProviderIdExt (#10420)

crates/storage/provider/src/providers/blockchain_provider.rs

@@ -1492,14 +1492,19 @@ mod tests {
     use reth_chain_state::{ExecutedBlock, NewCanonicalChain};
     use reth_chainspec::ChainSpecProvider;
     use reth_db::{test_utils::TempDatabase, DatabaseEnv};
-    use reth_primitives::{BlockHashOrNumber, BlockNumberOrTag, Header, SealedBlock, B256};
-    use reth_storage_api::{
-        BlockHashReader, BlockNumReader, BlockReader, BlockReaderIdExt, BlockSource, HeaderProvider,
+    use reth_execution_types::ExecutionOutcome;
+    use reth_primitives::{
+        BlockHashOrNumber, BlockNumberOrTag, Header, Receipt, SealedBlock, StaticFileSegment, B256,
     };
-    use reth_testing_utils::generators::{self, random_block, random_block_range};
+    use reth_storage_api::{
+        BlockHashReader, BlockNumReader, BlockReader, BlockReaderIdExt, BlockSource,
+        HeaderProvider, ReceiptProviderIdExt,
+    };
+    use reth_testing_utils::generators::{self, random_block, random_block_range, random_receipt};
 
     use crate::{
-        providers::BlockchainProvider2, test_utils::create_test_provider_factory, CanonChainTracker,
+        providers::BlockchainProvider2, test_utils::create_test_provider_factory,
+        CanonChainTracker, StaticFileWriter,
     };
 
     const TEST_BLOCKS_COUNT: usize = 5;
@@ -1512,35 +1517,53 @@ mod tests {
         BlockchainProvider2<Arc<TempDatabase<DatabaseEnv>>>,
         Vec<SealedBlock>,
         Vec<SealedBlock>,
+        Vec<Vec<Receipt>>,
     )> {
         let mut rng = generators::rng();
         let block_range = (database_blocks + in_memory_blocks - 1) as u64;
         let blocks = random_block_range(&mut rng, 0..=block_range, B256::ZERO, 0..1);
+        let receipts: Vec<Vec<_>> = blocks
+            .iter()
+            .map(|block| block.body.iter())
+            .map(|tx| tx.map(|tx| random_receipt(&mut rng, tx, Some(2))).collect())
+            .collect();
 
         let factory = create_test_provider_factory();
         let provider_rw = factory.provider_rw()?;
 
         let mut blocks_iter = blocks.clone().into_iter();
 
-        // Insert data blocks into the database
+        // Insert blocks and receipts into the database
         for block in (0..database_blocks).map_while(|_| blocks_iter.next()) {
             provider_rw.insert_historical_block(
-                block.seal_with_senders().expect("failed to seal block with senders"),
+                block.clone().seal_with_senders().expect("failed to seal block with senders"),
             )?;
+
+            // Insert the receipts into the database using the writer from the provider_rw
+            let mut writer =
+                provider_rw.static_file_provider().latest_writer(StaticFileSegment::Receipts)?;
+            let block_number = block.number as usize;
+            for receipt in receipts.get(block_number).unwrap() {
+                writer.append_receipt(block.number, receipt)?;
+            }
         }
         provider_rw.commit()?;
 
         let provider = BlockchainProvider2::new(factory)?;
 
-        // Insert the rest of the blocks into the in-memory state
+        // Insert the rest of the blocks and receipts into the in-memory state
         let chain = NewCanonicalChain::Commit {
             new: blocks_iter
                 .map(|block| {
                     let senders = block.senders().expect("failed to recover senders");
+                    let block_receipts = receipts.get(block.number as usize).unwrap().clone();
+                    let execution_outcome =
+                        ExecutionOutcome { receipts: block_receipts.into(), ..Default::default() };
+
                     ExecutedBlock::new(
                         Arc::new(block),
                         Arc::new(senders),
-                        Default::default(),
+                        execution_outcome.into(),
                         Default::default(),
                         Default::default(),
                     )
@@ -1561,7 +1584,7 @@ mod tests {
         provider.set_finalized(finalized_block.header);
 
         let (database_blocks, in_memory_blocks) = blocks.split_at(database_blocks);
-        Ok((provider, database_blocks.to_vec(), in_memory_blocks.to_vec()))
+        Ok((provider, database_blocks.to_vec(), in_memory_blocks.to_vec(), receipts))
     }
 
     #[test]
@@ -1728,7 +1751,7 @@ mod tests {
 
     #[test]
     fn test_block_reader_pending_block() -> eyre::Result<()> {
-        let (provider, _, _) =
+        let (provider, _, _, _) =
             provider_with_random_blocks(TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT).unwrap();
 
         // Generate a random block
@@ -1828,7 +1851,7 @@ mod tests {
 
     #[test]
     fn test_block_hash_reader() -> eyre::Result<()> {
-        let (provider, database_blocks, in_memory_blocks) =
+        let (provider, database_blocks, in_memory_blocks, _) =
             provider_with_random_blocks(TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT)?;
 
         let database_block = database_blocks.first().unwrap().clone();
@@ -1851,7 +1874,7 @@ mod tests {
 
     #[test]
     fn test_header_provider() -> eyre::Result<()> {
-        let (provider, database_blocks, in_memory_blocks) =
+        let (provider, database_blocks, in_memory_blocks, _) =
             provider_with_random_blocks(TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT).unwrap();
 
         let database_block = database_blocks.first().unwrap().clone();
@@ -1915,7 +1938,7 @@ mod tests {
 
     #[test]
     fn test_block_num_reader() -> eyre::Result<()> {
-        let (provider, database_blocks, in_memory_blocks) =
+        let (provider, database_blocks, in_memory_blocks, _) =
             provider_with_random_blocks(TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT).unwrap();
 
         assert_eq!(provider.best_block_number()?, in_memory_blocks.last().unwrap().number);
@@ -1931,7 +1954,7 @@ mod tests {
 
     #[test]
     fn test_block_reader_id_ext_block_by_id() {
-        let (provider, database_blocks, in_memory_blocks) =
+        let (provider, database_blocks, in_memory_blocks, _) =
             provider_with_random_blocks(TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT).unwrap();
 
         let database_block = database_blocks.first().unwrap().clone();
@@ -1959,7 +1982,7 @@ mod tests {
 
     #[test]
     fn test_block_reader_id_ext_header_by_number_or_tag() {
-        let (provider, database_blocks, in_memory_blocks) =
+        let (provider, database_blocks, in_memory_blocks, _) =
             provider_with_random_blocks(TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT).unwrap();
 
         let database_block = database_blocks.first().unwrap().clone();
@@ -2009,7 +2032,7 @@ mod tests {
 
     #[test]
     fn test_block_reader_id_ext_header_by_id() {
-        let (provider, database_blocks, in_memory_blocks) =
+        let (provider, database_blocks, in_memory_blocks, _) =
             provider_with_random_blocks(TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT).unwrap();
 
         let database_block = database_blocks.first().unwrap().clone();
@@ -2060,7 +2083,7 @@ mod tests {
 
     #[test]
     fn test_block_reader_id_ext_ommers_by_id() {
-        let (provider, database_blocks, in_memory_blocks) =
+        let (provider, database_blocks, in_memory_blocks, _) =
             provider_with_random_blocks(TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT).unwrap();
 
         let database_block = database_blocks.first().unwrap().clone();
@@ -2090,4 +2113,71 @@ mod tests {
             in_memory_block.ommers
         );
     }
+
+    #[test]
+    fn test_receipt_provider_id_ext_receipts_by_block_id() -> eyre::Result<()> {
+        let (provider, database_blocks, in_memory_blocks, receipts) =
+            provider_with_random_blocks(TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT)?;
+
+        let database_block = database_blocks.first().unwrap().clone();
+        let in_memory_block = in_memory_blocks.last().unwrap().clone();
+
+        let block_number = database_block.number;
+        let block_hash = database_block.header.hash();
+
+        assert_eq!(
+            provider.receipts_by_block_id(block_number.into())?.unwrap_or_default(),
+            receipts.get(block_number as usize).unwrap().clone()
+        );
+        assert_eq!(
+            provider.receipts_by_block_id(block_hash.into())?.unwrap_or_default(),
+            receipts.get(block_number as usize).unwrap().clone()
+        );
+
+        let block_number = in_memory_block.number;
+        let block_hash = in_memory_block.header.hash();
+
+        assert_eq!(
+            provider.receipts_by_block_id(block_number.into())?.unwrap_or_default(),
+            receipts.get(block_number as usize).unwrap().clone()
+        );
+        assert_eq!(
+            provider.receipts_by_block_id(block_hash.into())?.unwrap_or_default(),
+            receipts.get(block_number as usize).unwrap().clone()
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_receipt_provider_id_ext_receipts_by_block_number_or_tag() -> eyre::Result<()> {
+        let (provider, database_blocks, in_memory_blocks, receipts) =
+            provider_with_random_blocks(TEST_BLOCKS_COUNT, TEST_BLOCKS_COUNT)?;
+
+        let database_block = database_blocks.first().unwrap().clone();
+
+        let in_memory_block_count = in_memory_blocks.len();
+        let canonical_block = in_memory_blocks.get(in_memory_block_count - 1).unwrap().clone();
+        let safe_block = in_memory_blocks.get(in_memory_block_count - 2).unwrap().clone();
+        let finalized_block = in_memory_blocks.get(in_memory_block_count - 3).unwrap().clone();
+
+        assert_eq!(
+            provider.receipts_by_number_or_tag(database_block.number.into())?.unwrap_or_default(),
+            receipts.get(database_block.number as usize).unwrap().clone()
+        );
+        assert_eq!(
+            provider.receipts_by_number_or_tag(BlockNumberOrTag::Latest)?.unwrap_or_default(),
+            receipts.get(canonical_block.number as usize).unwrap().clone()
+        );
+        assert_eq!(
+            provider.receipts_by_number_or_tag(BlockNumberOrTag::Safe)?.unwrap_or_default(),
+            receipts.get(safe_block.number as usize).unwrap().clone()
+        );
+        assert_eq!(
+            provider.receipts_by_number_or_tag(BlockNumberOrTag::Finalized)?.unwrap_or_default(),
+            receipts.get(finalized_block.number as usize).unwrap().clone()
+        );
+
+        Ok(())
+    }
 }