Make test_eth_api_receipt work

Author: cichaczem

Cargo.lock

@@ -73,6 +73,7 @@ alloy-eips.workspace = true
 alloy-rpc-types-engine.workspace = true
 alloy-consensus.workspace = true
 
+op-alloy-rpc-types.workspace = true
 op-alloy-rpc-types-engine.workspace = true
 
 tokio-tungstenite.workspace = true

crates/world/node/Cargo.toml

@@ -6,11 +6,11 @@ use eyre::eyre::{eyre, Result};
 use flashblocks_primitives::p2p::Authorization;
 use flashblocks_rpc::{engine::FlashblocksEngineApiExtClient, op::OpApiExtClient};
 use futures::future::BoxFuture;
+use op_alloy_rpc_types::OpTransactionReceipt;
 use op_alloy_rpc_types_engine::OpExecutionPayloadEnvelopeV3;
 use reth::rpc::api::{EngineApiClient, EthApiClient};
 use reth_e2e_test_utils::testsuite::{actions::Action, Environment};
 use reth_optimism_node::{OpEngineTypes, OpPayloadAttributes};
-use reth_optimism_primitives::OpReceipt;
 use revm_primitives::{Address, Bytes, B256, U256};
 use std::{fmt::Debug, marker::PhantomData, time::Duration};
 use tokio::time::sleep;
@@ -643,7 +643,7 @@ pub struct EthGetTransactionReceipt {
     /// Duration in milliseconds of backoff before fetching the receipt
     pub backoff: u64,
     /// Tx sender for receipt results
-    pub tx: tokio::sync::mpsc::Sender<Vec<Option<OpReceipt>>>,
+    pub tx: tokio::sync::mpsc::Sender<Vec<Option<OpTransactionReceipt>>>,
 }
 
 impl EthGetTransactionReceipt {
@@ -652,7 +652,7 @@ impl EthGetTransactionReceipt {
         hash: B256,
         node_idxs: Vec<usize>,
         backoff: u64,
-        tx: tokio::sync::mpsc::Sender<Vec<Option<OpReceipt>>>,
+        tx: tokio::sync::mpsc::Sender<Vec<Option<OpTransactionReceipt>>>,
     ) -> Self {
         Self {
             hash,
@@ -674,12 +674,12 @@ impl Action<OpEngineTypes> for EthGetTransactionReceipt {
             let mut receipts = vec![];
             for node_idx in &self.node_idxs {
                 let rpc_client = env.node_clients[*node_idx].rpc.clone();
-                let receipt: Option<OpReceipt> =
+                let receipt: Option<OpTransactionReceipt> =
                     EthApiClient::<
                         TransactionRequest,
                         Transaction,
                         alloy_rpc_types_eth::Block,
-                        OpReceipt,
+                        OpTransactionReceipt,
                         Header,
                     >::transaction_receipt(&rpc_client, self.hash)
                     .await?;

crates/world/node/tests/e2e-testsuite/actions.rs

@@ -1,9 +1,13 @@
+use alloy_eips::eip2718::Encodable2718;
 use alloy_genesis::{Genesis, GenesisAccount};
+use alloy_primitives::{address, Address, Sealed};
 use eyre::eyre::eyre;
+use op_alloy_consensus::{OpTxEnvelope, TxDeposit};
 use reth::api::TreeConfig;
 use reth::args::PayloadBuilderArgs;
 use reth::builder::{EngineNodeLauncher, Node, NodeBuilder, NodeConfig, NodeHandle};
 use reth::network::PeersHandleProvider;
+use reth::payload::{EthPayloadBuilderAttributes, PayloadId};
 use reth::tasks::TaskManager;
 use reth_e2e_test_utils::testsuite::{Environment, NodeClient};
 use reth_e2e_test_utils::{Adapter, NodeHelperType, TmpDB};
@@ -17,7 +21,8 @@ use reth_optimism_chainspec::{OpChainSpec, OpChainSpecBuilder};
 use reth_optimism_node::OpEngineTypes;
 use reth_optimism_primitives::OpPrimitives;
 use reth_provider::providers::{BlockchainProvider, ChainStorage};
-use revm_primitives::U256;
+use revm_primitives::TxKind;
+use revm_primitives::{Bytes, U256};
 use std::{
     collections::BTreeMap,
     ops::Range,
@@ -40,6 +45,68 @@ use world_chain_rpc::{EthApiExtServer, SequencerClient, WorldChainEthApiExt};
 
 const GENESIS: &str = include_str!("../res/genesis.json");
 
+// Optimism protocol constants - these addresses are defined by the Optimism specification
+const L1_BLOCK_PREDEPLOY: Address = address!("4200000000000000000000000000000000000015");
+const SYSTEM_DEPOSITOR: Address = address!("DeaDDEaDDeAdDeAdDEAdDEaddeAddEAdDEAd0001");
+
+fn create_l1_attributes_deposit_tx() -> Bytes {
+    const SELECTOR: [u8; 4] = [0x44, 0x0a, 0x5e, 0x20];
+    let mut calldata = SELECTOR.to_vec();
+    calldata.extend_from_slice(&[0u8; 32]);
+    calldata.extend_from_slice(&[0u8; 32]);
+    calldata.extend_from_slice(&[0u8; 32]);
+    calldata.extend_from_slice(&[0u8; 32]);
+    calldata.extend_from_slice(&[0u8; 32]);
+
+    let deposit = TxDeposit {
+        source_hash: revm_primitives::B256::ZERO,
+        from: SYSTEM_DEPOSITOR,
+        to: TxKind::Call(L1_BLOCK_PREDEPLOY),
+        mint: 0u128,
+        value: U256::ZERO,
+        gas_limit: 1_000_000,
+        is_system_transaction: true,
+        input: calldata.into(),
+    };
+
+    let sealed_deposit = Sealed::new_unchecked(deposit, revm_primitives::B256::ZERO);
+    let envelope = OpTxEnvelope::Deposit(sealed_deposit);
+    let mut buf = Vec::new();
+    envelope.encode_2718(&mut buf);
+    buf.into()
+}
+
+/// L1 attributes deposit transaction - required as the first transaction in Optimism blocks
+pub static TX_SET_L1_BLOCK: LazyLock<Bytes> = LazyLock::new(create_l1_attributes_deposit_tx);
+
+/// Generate basic Optimism payload attributes for testing
+pub fn optimism_payload_attributes(
+    timestamp: u64,
+) -> reth_optimism_payload_builder::OpPayloadBuilderAttributes<op_alloy_consensus::OpTxEnvelope> {
+    use alloy_eips::eip4895::Withdrawals;
+    use alloy_primitives::b64;
+    use revm_primitives::{Address, B256};
+
+    let eth_attrs = EthPayloadBuilderAttributes {
+        id: PayloadId::new([0u8; 8]),
+        parent: B256::ZERO,
+        timestamp,
+        suggested_fee_recipient: Address::random(),
+        prev_randao: B256::random(),
+        withdrawals: Withdrawals::default(),
+        parent_beacon_block_root: Some(B256::ZERO),
+    };
+
+    reth_optimism_payload_builder::OpPayloadBuilderAttributes {
+        payload_attributes: eth_attrs,
+        transactions: vec![],
+        no_tx_pool: false,
+        eip_1559_params: Some(b64!("0000000800000008")),
+        gas_limit: Some(30_000_000),
+        min_base_fee: None,
+    }
+}
+
 pub struct WorldChainTestingNodeContext<T: WorldChainTestContextBounds>
 where
     WorldChainNode<T>: WorldChainNodeTestBounds<T>,

crates/world/node/tests/e2e-testsuite/setup.rs

@@ -10,7 +10,6 @@ use reth::primitives::RecoveredBlock;
 use reth_e2e_test_utils::testsuite::actions::Action;
 use reth_e2e_test_utils::transaction::TransactionTestContext;
 use reth_node_api::{Block, PayloadAttributes};
-use reth_optimism_node::utils::optimism_payload_attributes;
 use reth_optimism_node::OpPayloadAttributes;
 use reth_optimism_payload_builder::payload_id_optimism;
 use reth_optimism_primitives::OpTransactionSigned;
@@ -27,7 +26,7 @@ use world_chain_node::context::FlashblocksContext;
 use world_chain_test::node::{raw_pbh_bundle_bytes, tx};
 use world_chain_test::utils::signer;
 
-use crate::setup::{setup, CHAIN_SPEC};
+use crate::setup::{optimism_payload_attributes, setup, CHAIN_SPEC};
 
 #[tokio::test]
 async fn test_can_build_pbh_payload() -> eyre::Result<()> {
@@ -354,90 +353,122 @@ async fn test_flashblocks() -> eyre::Result<()> {
     Ok(())
 }
 
-// #[tokio::test(flavor = "multi_thread")]
-// async fn test_eth_api_receipt() -> eyre::Result<()> {
-//     reth_tracing::init_test_tracing();
-//     let (_, nodes, _tasks, mut env) =
-//         setup::<FlashblocksContext>(3, optimism_payload_attributes).await?;
-
-//     let ext_context = nodes[0].ext_context.clone();
-
-//     let block_hash = nodes[0].node.block_hash(0);
-
-//     let authorization_generator = move |attrs: OpPayloadAttributes| {
-//         let authorizer_sk = SigningKey::from_bytes(&[0; 32]);
-
-//         let payload_id = payload_id_optimism(&block_hash, &attrs, 3);
-
-//         Authorization::new(
-//             payload_id,
-//             attrs.timestamp(),
-//             &authorizer_sk,
-//             ext_context
-//                 .flashblocks_handle
-//                 .builder_sk()
-//                 .unwrap()
-//                 .verifying_key(),
-//         )
-//     };
-
-//     let timestamp = std::time::SystemTime::now()
-//         .duration_since(std::time::UNIX_EPOCH)
-//         .unwrap()
-//         .as_secs();
-
-//     let (sender, _) = tokio::sync::mpsc::channel(1);
-
-//     // Compose a Mine Block action with an eth_getTransactionReceipt action
-//     let attributes = OpPayloadAttributes {
-//         payload_attributes: alloy_rpc_types_engine::PayloadAttributes {
-//             timestamp,
-//             prev_randao: B256::random(),
-//             suggested_fee_recipient: Address::random(),
-//             withdrawals: Some(vec![]),
-//             parent_beacon_block_root: Some(B256::ZERO),
-//         },
-//         transactions: Some(vec![crate::setup::TX_SET_L1_BLOCK.into()]),
-//         no_tx_pool: Some(false),
-//         eip_1559_params: Some(b64!("0000000800000008")),
-//         gas_limit: Some(30_000_000),
-//     };
-
-//     let mock_tx =
-//         TransactionTestContext::transfer_tx(nodes[0].node.inner.chain_spec().chain_id(), signer(0))
-//             .await;
-
-//     let raw_tx: Bytes = mock_tx.encoded_2718().into();
-
-//     nodes[0].node.rpc.inject_tx(raw_tx.clone()).await?;
-
-//     let mine_block = crate::actions::AssertMineBlock::new(
-//         0,
-//         vec![raw_tx],
-//         Some(B256::ZERO),
-//         attributes,
-//         authorization_generator,
-//         std::time::Duration::from_millis(2000),
-//         true,
-//         false,
-//         sender,
-//     )
-//     .await;
-
-//     let (tx, mut rx) = tokio::sync::mpsc::channel(1);
-
-//     // 200ms backoff should be enough time to fetch the pending receipt
-//     let transaction_receipt =
-//         crate::actions::EthGetTransactionReceipt::new(*mock_tx.hash(), vec![0, 1, 2], 230, tx);
-
-//     let mut action = crate::actions::EthApiAction::new(mine_block, transaction_receipt);
-//     action.execute(&mut env).await?;
-
-//     let _receipts = rx.recv().await.expect("should receive receipts");
-//     info!("Receipts: {:?}", _receipts);
-//     // TODO: Assertions once EthApi is fixed
-//     Ok(())
-// }
+#[tokio::test(flavor = "multi_thread")]
+async fn test_eth_api_receipt() -> eyre::Result<()> {
+    reth_tracing::init_test_tracing();
+    let (_, nodes, _tasks, mut env) =
+        setup::<FlashblocksContext>(3, optimism_payload_attributes).await?;
+
+    let ext_context = nodes[0].ext_context.clone();
+
+    let block_hash = nodes[0].node.block_hash(0);
+
+    let authorization_generator = move |attrs: OpPayloadAttributes| {
+        let authorizer_sk = SigningKey::from_bytes(&[0; 32]);
+
+        let payload_id = payload_id_optimism(&block_hash, &attrs, 3);
+
+        Authorization::new(
+            payload_id,
+            attrs.timestamp(),
+            &authorizer_sk,
+            ext_context
+                .flashblocks_handle
+                .builder_sk()
+                .unwrap()
+                .verifying_key(),
+        )
+    };
+
+    let timestamp = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+
+    let (sender, _) = tokio::sync::mpsc::channel(1);
+
+    // Compose a Mine Block action with an eth_getTransactionReceipt action
+    let attributes = OpPayloadAttributes {
+        payload_attributes: alloy_rpc_types_engine::PayloadAttributes {
+            timestamp,
+            prev_randao: B256::random(),
+            suggested_fee_recipient: Address::random(),
+            withdrawals: Some(vec![]),
+            parent_beacon_block_root: Some(B256::ZERO),
+        },
+        transactions: Some(vec![crate::setup::TX_SET_L1_BLOCK.clone()]),
+        no_tx_pool: Some(false),
+        eip_1559_params: Some(b64!("0000000800000008")),
+        gas_limit: Some(30_000_000),
+        min_base_fee: None,
+    };
+
+    let mock_tx =
+        TransactionTestContext::transfer_tx(nodes[0].node.inner.chain_spec().chain_id(), signer(0))
+            .await;
+
+    let raw_tx: Bytes = mock_tx.encoded_2718().into();
+
+    nodes[0].node.rpc.inject_tx(raw_tx.clone()).await?;
+
+    let mine_block = crate::actions::AssertMineBlock::new(
+        0,
+        vec![],
+        None,
+        attributes,
+        authorization_generator,
+        std::time::Duration::from_millis(2000),
+        true,
+        false,
+        sender,
+    )
+    .await;
+
+    let (tx, mut rx) = tokio::sync::mpsc::channel(1);
+
+    let transaction_receipt =
+        crate::actions::EthGetTransactionReceipt::new(*mock_tx.hash(), vec![0, 1, 2], 230, tx);
+
+    let mut action = crate::actions::EthApiAction::new(mine_block, transaction_receipt);
+    action.execute(&mut env).await?;
+
+    let receipts = rx.recv().await.expect("should receive receipts");
+    info!("Receipts: {:?}", receipts);
+
+    assert_eq!(
+        receipts.len(),
+        3,
+        "Should receive receipts from all 3 nodes"
+    );
+
+    for (idx, receipt_opt) in receipts.iter().enumerate() {
+        assert!(
+            receipt_opt.is_some(),
+            "Node {} should return a receipt",
+            idx
+        );
+    }
+
+    let receipts: Vec<_> = receipts.into_iter().map(|r| r.unwrap()).collect();
+
+    for (idx, receipt) in receipts.iter().enumerate() {
+        assert!(
+            receipt.inner.inner.status(),
+            "Transaction should succeed on node {}",
+            idx
+        );
+    }
+
+    for (idx, receipt) in receipts.iter().enumerate().skip(1) {
+        assert_eq!(
+            receipt, &receipts[0],
+            "Node {} receipt doesn't match node 0",
+            idx
+        );
+    }
+
+    Ok(())
+}
 
 #[tokio::test(flavor = "multi_thread")]
 async fn test_eth_api_call() -> eyre::Result<()> {