feat: make metadata receipts optional

Receipts are almost unused other than returning the nonce of the from
field for deposit transactions. This change makes the entire receipts
field optional for flashblocks. This means that deposit transactions
will not return a nonce from the RPC until the canonical block is
processed.

While this will change RPC behavior, it will decrease flashblock size
significantly, and the tradeoff of size vs a few hundred ms latency
to reading the nonce of a deposit transaction is easily worth it.

Author: meyer9

crates/flashblocks/src/processor.rs

@@ -333,7 +333,9 @@ where
                 .iter()
                 .map(|flashblock| flashblock.metadata.receipts.clone())
                 .fold(HashMap::default(), |mut acc, receipts| {
-                    acc.extend(receipts);
+                    if let Some(receipts) = receipts {
+                        acc.extend(receipts);
+                    }
                     acc
                 });
 
@@ -407,16 +409,15 @@ where
                 pending_blocks_builder.with_transaction_sender(tx_hash, sender);
                 pending_blocks_builder.increment_nonce(sender);
 
-                let receipt = receipt_by_hash
-                    .get(&tx_hash)
-                    .cloned()
-                    .ok_or(eyre!("missing receipt for {:?}", tx_hash))?;
+                let receipt = receipt_by_hash.get(&tx_hash).cloned();
 
                 let recovered_transaction = Recovered::new_unchecked(transaction.clone(), sender);
                 let envelope = recovered_transaction.clone().convert::<OpTxEnvelope>();
 
                 // Build Transaction
-                let (deposit_receipt_version, deposit_nonce) = if transaction.is_deposit() {
+                let (deposit_receipt_version, deposit_nonce) = if transaction.is_deposit()
+                    && let Some(receipt) = &receipt
+                {
                     let deposit_receipt = receipt
                         .as_deposit_receipt()
                         .ok_or(eyre!("deposit transaction, non deposit receipt"))?;
@@ -453,40 +454,43 @@ where
                 pending_blocks_builder.with_transaction(rpc_txn);
 
                 // Receipt Generation
-                let op_receipt = prev_pending_blocks
-                    .as_ref()
-                    .and_then(|pending_blocks| pending_blocks.get_receipt(tx_hash))
-                    .unwrap_or_else(|| {
-                        let meta = TransactionMeta {
-                            tx_hash,
-                            index: idx as u64,
-                            block_hash: header.hash(),
-                            block_number: block.number,
-                            base_fee: block.base_fee_per_gas,
-                            excess_blob_gas: block.excess_blob_gas,
-                            timestamp: block.timestamp,
-                        };
-
-                        let input: ConvertReceiptInput<'_, OpPrimitives> = ConvertReceiptInput {
-                            receipt: receipt.clone(),
-                            tx: Recovered::new_unchecked(transaction, sender),
-                            gas_used: receipt.cumulative_gas_used() - gas_used,
-                            next_log_index,
-                            meta,
-                        };
-
-                        OpReceiptBuilder::new(
-                            self.client.chain_spec().as_ref(),
-                            input,
-                            &mut l1_block_info,
-                        )
-                        .unwrap()
-                        .build()
-                    });
-
-                pending_blocks_builder.with_receipt(tx_hash, op_receipt);
-                gas_used = receipt.cumulative_gas_used();
-                next_log_index += receipt.logs().len();
+                if let Some(receipt) = receipt {
+                    let op_receipt = prev_pending_blocks
+                        .as_ref()
+                        .and_then(|pending_blocks| pending_blocks.get_receipt(tx_hash))
+                        .unwrap_or_else(|| {
+                            let meta = TransactionMeta {
+                                tx_hash,
+                                index: idx as u64,
+                                block_hash: header.hash(),
+                                block_number: block.number,
+                                base_fee: block.base_fee_per_gas,
+                                excess_blob_gas: block.excess_blob_gas,
+                                timestamp: block.timestamp,
+                            };
+
+                            let input: ConvertReceiptInput<'_, OpPrimitives> =
+                                ConvertReceiptInput {
+                                    receipt: receipt.clone(),
+                                    tx: Recovered::new_unchecked(transaction, sender),
+                                    gas_used: receipt.cumulative_gas_used() - gas_used,
+                                    next_log_index,
+                                    meta,
+                                };
+
+                            OpReceiptBuilder::new(
+                                self.client.chain_spec().as_ref(),
+                                input,
+                                &mut l1_block_info,
+                            )
+                            .unwrap()
+                            .build()
+                        });
+
+                    pending_blocks_builder.with_receipt(tx_hash, op_receipt);
+                    gas_used = receipt.cumulative_gas_used();
+                    next_log_index += receipt.logs().len();
+                }
 
                 let mut should_execute_transaction = true;
                 if let Some(state) =

crates/flashblocks/tests/state.rs

@@ -215,7 +215,7 @@ impl TestHarness {
 
 struct FlashblockBuilder<'a> {
     transactions: Vec<Bytes>,
-    receipts: HashMap<B256, OpReceipt>,
+    receipts: Option<HashMap<B256, OpReceipt>>,
     harness: &'a TestHarness,
     canonical_block_number: Option<BlockNumber>,
     index: u64,
@@ -226,7 +226,7 @@ impl<'a> FlashblockBuilder<'a> {
         Self {
             canonical_block_number: None,
             transactions: vec![L1_BLOCK_INFO_DEPOSIT_TX.clone()],
-            receipts: {
+            receipts: Some({
                 let mut receipts = alloy_primitives::map::HashMap::default();
                 receipts.insert(
                     L1_BLOCK_INFO_DEPOSIT_TX_HASH,
@@ -241,7 +241,7 @@ impl<'a> FlashblockBuilder<'a> {
                     }),
                 );
                 receipts
-            },
+            }),
             index: 0,
             harness,
         }
@@ -250,13 +250,13 @@ impl<'a> FlashblockBuilder<'a> {
         Self {
             canonical_block_number: None,
             transactions: Vec::new(),
-            receipts: HashMap::default(),
+            receipts: Some(HashMap::default()),
             harness,
             index,
         }
     }
 
-    fn with_receipts(&mut self, receipts: HashMap<B256, OpReceipt>) -> &mut Self {
+    fn with_receipts(&mut self, receipts: Option<HashMap<B256, OpReceipt>>) -> &mut Self {
         self.receipts = receipts;
         self
     }
@@ -269,14 +269,16 @@ impl<'a> FlashblockBuilder<'a> {
         for txn in transactions.iter() {
             cumulative_gas_used = cumulative_gas_used + txn.gas_limit();
             self.transactions.push(txn.encoded_2718().into());
-            self.receipts.insert(
-                txn.hash().clone(),
-                OpReceipt::Eip1559(Receipt {
-                    status: true.into(),
-                    cumulative_gas_used,
-                    logs: vec![],
-                }),
-            );
+            if let Some(ref mut receipts) = self.receipts {
+                receipts.insert(
+                    txn.hash().clone(),
+                    OpReceipt::Eip1559(Receipt {
+                        status: true.into(),
+                        cumulative_gas_used,
+                        logs: vec![],
+                    }),
+                );
+            }
         }
         self
     }
@@ -715,29 +717,25 @@ async fn test_nonce_uses_pending_canon_block_instead_of_latest() {
 }
 
 #[tokio::test]
-async fn test_missing_receipts_will_not_process() {
+async fn test_metadata_receipts_are_optional() {
+    // Test to ensure that receipts are optional in the metadata
+    // and deposit receipts return None for nonce until the canonical block is processed
     let test = TestHarness::new().await;
 
-    test.send_flashblock(FlashblockBuilder::new_base(&test).build()).await;
+    // Send a flashblock with no receipts (only deposit transaction)
+    test.send_flashblock(FlashblockBuilder::new_base(&test).with_receipts(None).build()).await;
 
-    let current_block = test.flashblocks.get_pending_blocks().get_block(true);
-
-    test.send_flashblock(
-        FlashblockBuilder::new(&test, 1)
-            .with_transactions(vec![test.build_transaction_to_send_eth(
-                User::Alice,
-                User::Bob,
-                100,
-            )])
-            .with_receipts(HashMap::default()) // Clear the receipts
-            .build(),
-    )
-    .await;
+    // Verify the block was created with the deposit transaction
+    let pending_block =
+        test.flashblocks.get_pending_blocks().get_block(true).expect("block should be created");
+    assert_eq!(pending_block.transactions.len(), 1);
 
-    let pending_block = test.flashblocks.get_pending_blocks().get_block(true);
+    // Check that the deposit transaction has None for deposit_nonce
+    let deposit_tx = &pending_block.transactions.as_transactions().unwrap()[0];
+    assert_eq!(deposit_tx.deposit_nonce, None, "deposit_nonce should be None when no receipts");
 
-    // When the flashblock is invalid, the chain doesn't progress
-    assert_eq!(pending_block.unwrap().hash(), current_block.unwrap().hash());
+    // Canonical blocks trivially have the deposit_nonce since they are handled by canonical RPC
+    // logic.
 }
 
 #[tokio::test]

crates/flashtypes/src/metadata.rs

@@ -8,7 +8,7 @@ use serde::{Deserialize, Serialize};
 #[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Default)]
 pub struct Metadata {
     /// Transaction receipts indexed by hash.
-    pub receipts: HashMap<B256, OpReceipt>,
+    pub receipts: Option<HashMap<B256, OpReceipt>>,
     /// Updated account balances.
     pub new_account_balances: HashMap<Address, U256>,
     /// Block number this flashblock belongs to.