feat: add append_receipts function

crates/static-file/static-file/src/segments/receipts.rs

@@ -42,8 +42,9 @@ impl<DB: Database> Segment<DB> for Receipts {
             let mut receipts_cursor = provider.tx_ref().cursor_read::<tables::Receipts>()?;
             let receipts_walker = receipts_cursor.walk_range(block_body_indices.tx_num_range())?;
 
-            let receipts = receipts_walker.collect::<Result<Vec<_>, _>>()?;
-            static_file_writer.append_receipts(receipts.into_iter().map(Ok))?;
+            static_file_writer.append_receipts(
+                receipts_walker.map(|result| result.map_err(ProviderError::from)),
+            )?;
         }
 
         Ok(())

crates/storage/provider/src/bundle_state/bundle_state_with_receipts.rs

@@ -42,18 +42,13 @@ impl StateWriter for BundleStateWithReceipts {
             if let Some(static_file_producer) = &mut static_file_producer {
                 // Increment block on static file header.
                 static_file_producer.increment_block(StaticFileSegment::Receipts, block_number)?;
-                let receipts = receipts
-                    .into_iter()
-                    .enumerate()
-                    .map(|(tx_idx, receipt)| {
-                        (
-                            first_tx_index + tx_idx as u64,
-                            receipt.expect(
-                                "receipt should not be filtered when saving to static files.",
-                            ),
-                        )
-                    })
-                    .map(Ok);
+                let receipts = receipts.into_iter().enumerate().map(|(tx_idx, receipt)| {
+                    Ok((
+                        first_tx_index + tx_idx as u64,
+                        receipt
+                            .expect("receipt should not be filtered when saving to static files."),
+                    ))
+                });
                 static_file_producer.append_receipts(receipts)?;
             } else if !receipts.is_empty() {
                 for (tx_idx, receipt) in receipts.into_iter().enumerate() {

crates/storage/provider/src/providers/static_file/metrics.rs

@@ -80,6 +80,28 @@ impl StaticFileProviderMetrics {
                 .record(duration.as_secs_f64());
         }
     }
+
+    pub(crate) fn record_segment_operations(
+        &self,
+        segment: StaticFileSegment,
+        operation: StaticFileProviderOperation,
+        count: u64,
+        duration: Option<Duration>,
+    ) {
+        self.segment_operations
+            .get(&(segment, operation))
+            .expect("segment operation metrics should exist")
+            .calls_total
+            .increment(count);
+
+        if let Some(duration) = duration {
+            self.segment_operations
+                .get(&(segment, operation))
+                .expect("segment operation metrics should exist")
+                .write_duration_seconds
+                .record(duration.as_secs_f64() / count as f64);
+        }
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EnumIter)]

crates/storage/provider/src/providers/static_file/writer.rs

@@ -566,7 +566,7 @@ impl StaticFileProviderRW {
 
         // At this point receipts contains at least one receipt, so this would be overwritten.
         let mut tx_number = 0;
-        let mut count = 0;
+        let mut count: u64 = 0;
 
         for receipt_result in receipts_iter {
             let (tx_num, receipt) = receipt_result?;
@@ -575,10 +575,11 @@ impl StaticFileProviderRW {
         }
 
         if let Some(metrics) = &self.metrics {
-            metrics.record_segment_operation(
+            metrics.record_segment_operations(
                 StaticFileSegment::Receipts,
                 StaticFileProviderOperation::AppendAverage,
-                Some(start.elapsed() / count as u32),
+                count,
+                Some(start.elapsed()),
             );
         }