WIP build receipts

Author: meyer9

Cargo.lock

@@ -116,6 +116,7 @@ alloy-rpc-types-eth = "1.0.41"
 alloy-rpc-types-engine = "1.0.41"
 
 # op-alloy
+alloy-op-evm = { version = "0.23.3", default-features = false }
 op-alloy-network = "0.22.0"
 op-alloy-rpc-types = "0.22.0"
 op-alloy-consensus = "0.22.0"

Cargo.toml

@@ -32,6 +32,7 @@ alloy-provider.workspace = true
 alloy-rpc-types.workspace = true
 alloy-consensus.workspace = true
 alloy-primitives.workspace = true
+alloy-op-evm.workspace = true
 alloy-rpc-types-eth.workspace = true
 alloy-rpc-types-engine.workspace = true
 

crates/flashblocks/Cargo.toml

@@ -5,23 +5,21 @@ use std::{
     time::{Duration, Instant},
 };
 
-use alloy_consensus::Receipt;
 use alloy_eips::{BlockHashOrNumber, Encodable2718};
-use alloy_primitives::{Address, B256, BlockNumber, Bytes, U256, b256, bytes, hex::FromHex};
+use alloy_primitives::{Address, B256, BlockNumber, Bytes, U256, bytes, hex::FromHex};
 use alloy_rpc_types_engine::PayloadId;
 use base_flashtypes::{
     ExecutionPayloadBaseV1, ExecutionPayloadFlashblockDeltaV1, Flashblock, Metadata,
 };
 use base_reth_flashblocks::{FlashblocksAPI, FlashblocksReceiver, FlashblocksState};
 use base_reth_test_utils::{LocalNodeProvider, TestAccounts, TestHarness};
 use criterion::{BatchSize, Criterion, Throughput, criterion_group, criterion_main};
-use op_alloy_consensus::OpDepositReceipt;
 use reth::{
     chainspec::{ChainSpecProvider, EthChainSpec},
     providers::BlockReader,
     transaction_pool::test_utils::TransactionBuilder,
 };
-use reth_optimism_primitives::{OpBlock, OpReceipt, OpTransactionSigned};
+use reth_optimism_primitives::{OpBlock, OpTransactionSigned};
 use reth_primitives_traits::{Block as BlockT, RecoveredBlock};
 use tokio::{runtime::Runtime, time::sleep};
 use tracing_subscriber::{EnvFilter, filter::LevelFilter};
@@ -33,8 +31,6 @@ const CHUNK_SIZE: usize = 10;
 const BLOCK_INFO_TXN: Bytes = bytes!(
     "0x7ef90104a06c0c775b6b492bab9d7e81abdf27f77cafb698551226455a82f559e0f93fea3794deaddeaddeaddeaddeaddeaddeaddeaddead00019442000000000000000000000000000000000000158080830f424080b8b0098999be000008dd00101c1200000000000000020000000068869d6300000000015f277f000000000000000000000000000000000000000000000000000000000d42ac290000000000000000000000000000000000000000000000000000000000000001abf52777e63959936b1bf633a2a643f0da38d63deffe49452fed1bf8a44975d50000000000000000000000005050f69a9786f081509234f1a7f4684b5e5b76c9000000000000000000000000"
 );
-const BLOCK_INFO_TXN_HASH: B256 =
-    b256!("0xba56c8b0deb460ff070f8fca8e2ee01e51a3db27841cc862fdd94cc1a47662b6");
 
 struct BenchSetup {
     provider: LocalNodeProvider,
@@ -203,20 +199,6 @@ fn base_flashblock(
     canonical_block: &RecoveredBlock<OpBlock>,
     block_number: BlockNumber,
 ) -> Flashblock {
-    let mut receipts = alloy_primitives::map::HashMap::default();
-    receipts.insert(
-        BLOCK_INFO_TXN_HASH,
-        OpReceipt::Deposit(OpDepositReceipt {
-            inner: Receipt {
-                status: true.into(),
-                cumulative_gas_used: DEPOSIT_GAS_USED,
-                logs: vec![],
-            },
-            deposit_nonce: Some(0),
-            deposit_receipt_version: None,
-        }),
-    );
-
     Flashblock {
         payload_id: PayloadId::default(),
         index: 0,
@@ -242,7 +224,11 @@ fn base_flashblock(
             transactions: vec![BLOCK_INFO_TXN.clone()],
             blob_gas_used: Default::default(),
         },
-        metadata: Metadata { block_number, receipts, new_account_balances: Default::default() },
+        metadata: Metadata {
+            block_number,
+            receipts: None,
+            new_account_balances: Default::default(),
+        },
     }
 }
 
@@ -252,20 +238,11 @@ fn transaction_flashblock(
     transactions: &[OpTransactionSigned],
     gas_used: &mut u64,
 ) -> Flashblock {
-    let mut tx_receipts = alloy_primitives::map::HashMap::default();
     let mut tx_bytes = Vec::with_capacity(transactions.len());
 
     for tx in transactions {
         *gas_used += TX_GAS_USED;
         tx_bytes.push(tx.encoded_2718().into());
-        tx_receipts.insert(
-            tx.hash().clone(),
-            OpReceipt::Eip1559(Receipt {
-                status: true.into(),
-                cumulative_gas_used: *gas_used,
-                logs: vec![],
-            }),
-        );
     }
 
     Flashblock {
@@ -285,7 +262,7 @@ fn transaction_flashblock(
         },
         metadata: Metadata {
             block_number,
-            receipts: tx_receipts,
+            receipts: None,
             new_account_balances: Default::default(),
         },
     }

crates/flashblocks/benches/pending_state.rs

@@ -7,18 +7,19 @@ use std::{
 };
 
 use alloy_consensus::{
-    Header, TxReceipt,
+    Eip658Value, Header, TxReceipt,
     transaction::{Recovered, SignerRecoverable, TransactionMeta},
 };
 use alloy_eips::BlockNumberOrTag;
+use alloy_op_evm::block::receipt_builder::OpReceiptBuilder;
 use alloy_primitives::{B256, BlockNumber, Bytes, Sealable, map::foldhash::HashMap};
 use alloy_rpc_types::{TransactionTrait, Withdrawal};
 use alloy_rpc_types_engine::{ExecutionPayloadV1, ExecutionPayloadV2, ExecutionPayloadV3};
 use alloy_rpc_types_eth::state::StateOverride;
 use arc_swap::ArcSwapOption;
 use base_flashtypes::Flashblock;
 use eyre::eyre;
-use op_alloy_consensus::OpTxEnvelope;
+use op_alloy_consensus::{OpDepositReceipt, OpTxEnvelope};
 use op_alloy_network::TransactionResponse;
 use op_alloy_rpc_types::Transaction;
 use reth::{
@@ -29,11 +30,11 @@ use reth::{
         db::CacheDB,
     },
 };
-use reth_evm::{ConfigureEvm, Evm};
+use reth_evm::{ConfigureEvm, Evm, eth::receipt_builder::ReceiptBuilderCtx};
 use reth_optimism_chainspec::OpHardforks;
 use reth_optimism_evm::{OpEvmConfig, OpNextBlockEnvAttributes};
 use reth_optimism_primitives::{DepositReceipt, OpBlock, OpPrimitives};
-use reth_optimism_rpc::OpReceiptBuilder;
+use reth_optimism_rpc::OpReceiptBuilder as OpRpcReceiptBuilder;
 use reth_primitives::RecoveredBlock;
 use reth_rpc_convert::transaction::ConvertReceiptInput;
 use tokio::sync::{Mutex, broadcast::Sender, mpsc::UnboundedReceiver};
@@ -333,7 +334,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
                 });
 
@@ -390,7 +393,7 @@ where
             let evm_env = evm_config.next_evm_env(&last_block_header, &block_env_attributes)?;
             let mut evm = evm_config.evm_with_env(db, evm_env);
 
-            let mut gas_used = 0;
+            let mut cumulative_gas_used: u64 = 0;
             let mut next_log_index = 0;
 
             for (idx, transaction) in block.body.transactions.iter().enumerate() {
@@ -407,16 +410,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"))?;
@@ -451,54 +453,32 @@ where
                 };
 
                 pending_blocks_builder.with_transaction(rpc_txn);
+                let mut should_execute_transaction = true;
 
                 // 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();
+                let saved_receipt = {
+                    let receipt = prev_pending_blocks.as_ref().and_then(|p| p.get_receipt(tx_hash));
+
+                    if let Some(receipt) = receipt {
+                        pending_blocks_builder.with_receipt(tx_hash, receipt);
+                        true
+                    } else {
+                        false
+                    }
+                };
 
-                let mut should_execute_transaction = true;
-                if let Some(state) =
-                    prev_pending_blocks.as_ref().and_then(|p| p.get_transaction_state(&tx_hash))
+                if saved_receipt
+                    && let Some(state) =
+                        prev_pending_blocks.as_ref().and_then(|p| p.get_transaction_state(&tx_hash))
                 {
                     pending_blocks_builder.with_transaction_state(tx_hash, state);
                     should_execute_transaction = false;
                 }
 
                 if should_execute_transaction {
-                    match evm.transact(recovered_transaction) {
-                        Ok(ResultAndState { state, .. }) => {
+                    match evm.transact(recovered_transaction.clone()) {
+                        Ok(ResultAndState { state, result }) => {
+                            let gas_used = result.gas_used();
                             for (addr, acc) in &state {
                                 let existing_override = state_overrides.entry(*addr).or_default();
                                 existing_override.balance = Some(acc.info.balance);
@@ -514,6 +494,77 @@ where
 
                                 existing.extend(changed_slots);
                             }
+
+                            cumulative_gas_used = cumulative_gas_used
+                                .checked_add(gas_used)
+                                .ok_or(eyre!("cumulative gas used overflow"))?;
+
+                            let receipt_builder =
+                                evm_config.block_executor_factory().receipt_builder();
+
+                            let is_canyon_active = self
+                                .client
+                                .chain_spec()
+                                .is_canyon_active_at_timestamp(block.timestamp);
+                            let receipt = match receipt_builder.build_receipt(ReceiptBuilderCtx {
+                                tx: &recovered_transaction,
+                                evm: &evm,
+                                result,
+                                state: &state,
+                                cumulative_gas_used,
+                            }) {
+                                Ok(receipt) => receipt,
+                                Err(ctx) => {
+                                    let receipt = alloy_consensus::Receipt {
+                                        // Success flag was added in `EIP-658: Embedding transaction status code
+                                        // in receipts`.
+                                        status: Eip658Value::Eip658(ctx.result.is_success()),
+                                        cumulative_gas_used: ctx.cumulative_gas_used,
+                                        logs: ctx.result.into_logs(),
+                                    };
+
+                                    receipt_builder.build_deposit_receipt(OpDepositReceipt {
+                                        inner: receipt,
+                                        deposit_nonce,
+                                        // The deposit receipt version was introduced in Canyon to indicate an
+                                        // update to how receipt hashes should be computed
+                                        // when set. The state transition process ensures
+                                        // this is only set for post-Canyon deposit
+                                        // transactions.
+                                        deposit_receipt_version: is_canyon_active.then_some(1),
+                                    })
+                                }
+                            };
+
+                            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,
+                                    next_log_index,
+                                    meta,
+                                };
+
+                            let op_receipt = OpRpcReceiptBuilder::new(
+                                self.client.chain_spec().as_ref(),
+                                input,
+                                &mut l1_block_info,
+                            )
+                            .unwrap()
+                            .build();
+                            next_log_index = next_log_index + receipt.logs().len();
+
+                            pending_blocks_builder.with_receipt(tx_hash, op_receipt);
                             pending_blocks_builder.with_transaction_state(tx_hash, state.clone());
                             evm.db_mut().commit(state);
                         }