test

Author: klkvr

crates/ethereum/node/tests/e2e/blobs.rs

@@ -5,13 +5,17 @@ use reth_chainspec::{ChainSpecBuilder, MAINNET};
 use reth_e2e_test_utils::{
     node::NodeTestContext, transaction::TransactionTestContext, wallet::Wallet,
 };
+use reth_ethereum_engine_primitives::BlobSidecars;
 use reth_ethereum_primitives::PooledTransactionVariant;
 use reth_node_builder::{NodeBuilder, NodeHandle};
 use reth_node_core::{args::RpcServerArgs, node_config::NodeConfig};
 use reth_node_ethereum::EthereumNode;
 use reth_tasks::TaskManager;
 use reth_transaction_pool::TransactionPool;
-use std::sync::Arc;
+use std::{
+    sync::Arc,
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
 
 #[tokio::test]
 async fn can_handle_blobs() -> eyre::Result<()> {
@@ -136,3 +140,113 @@ async fn can_send_legacy_sidecar_post_activation() -> eyre::Result<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn blob_conversion_at_osaka() -> eyre::Result<()> {
+    reth_tracing::init_test_tracing();
+    let tasks = TaskManager::current();
+    let exec = tasks.executor();
+
+    let current_timestamp = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
+    // Osaka activates in 2 slots
+    let osaka_timestamp = current_timestamp + 24;
+
+    let genesis: Genesis = serde_json::from_str(include_str!("../assets/genesis.json")).unwrap();
+    let chain_spec = Arc::new(
+        ChainSpecBuilder::default()
+            .chain(MAINNET.chain)
+            .genesis(genesis)
+            .prague_activated()
+            .with_osaka_at(osaka_timestamp)
+            .build(),
+    );
+    let genesis_hash = chain_spec.genesis_hash();
+    let node_config = NodeConfig::test()
+        .with_chain(chain_spec)
+        .with_unused_ports()
+        .with_rpc(RpcServerArgs::default().with_unused_ports().with_http());
+    let NodeHandle { node, node_exit_future: _ } = NodeBuilder::new(node_config.clone())
+        .testing_node(exec.clone())
+        .node(EthereumNode::default())
+        .launch()
+        .await?;
+
+    let mut node = NodeTestContext::new(node, eth_payload_attributes).await?;
+
+    let mut wallets = Wallet::new(3).wallet_gen();
+    let first = wallets.pop().unwrap();
+    let second = wallets.pop().unwrap();
+
+    // build a dummy payload at `current_timestamp`
+    let raw_tx = TransactionTestContext::transfer_tx_bytes(1, wallets.pop().unwrap()).await;
+    node.rpc.inject_tx(raw_tx).await?;
+    node.payload.timestamp = current_timestamp - 1;
+    node.advance_block().await?;
+
+    // build blob txs
+    let first_blob = TransactionTestContext::tx_with_blobs_bytes(1, first.clone()).await?;
+    let second_blob = TransactionTestContext::tx_with_blobs_bytes(1, second.clone()).await?;
+
+    // assert both txs have legacy sidecars
+    assert!(PooledTransactionVariant::decode_2718_exact(&first_blob)
+        .unwrap()
+        .as_eip4844()
+        .unwrap()
+        .tx()
+        .sidecar
+        .is_eip4844());
+    assert!(PooledTransactionVariant::decode_2718_exact(&second_blob)
+        .unwrap()
+        .as_eip4844()
+        .unwrap()
+        .tx()
+        .sidecar
+        .is_eip4844());
+
+    // inject first blob tx to the pool
+    let blob_tx_hash = node.rpc.inject_tx(first_blob).await?;
+    // fetch it from rpc
+    let envelope = node.rpc.envelope_by_hash(blob_tx_hash).await?;
+    // assert that it still has a legacy sidecar
+    assert!(envelope.as_eip4844().unwrap().tx().sidecar().unwrap().is_eip4844());
+    // validate sidecar
+    TransactionTestContext::validate_sidecar(envelope);
+
+    // build last Prague payload
+    node.payload.timestamp = current_timestamp + 11;
+    let prague_payload = node.new_payload().await?;
+    assert!(matches!(prague_payload.sidecars(), BlobSidecars::Eip4844(_)));
+
+    // inject second blob tx to the pool
+    let blob_tx_hash = node.rpc.inject_tx(second_blob).await?;
+    // fetch it from rpc
+    let envelope = node.rpc.envelope_by_hash(blob_tx_hash).await?;
+    // assert that it still has a legacy sidecar
+    assert!(envelope.as_eip4844().unwrap().tx().sidecar().unwrap().is_eip4844());
+    // validate sidecar
+    TransactionTestContext::validate_sidecar(envelope);
+
+    tokio::time::sleep(Duration::from_secs(11)).await;
+
+    // fetch second blob tx from rpc again
+    let envelope = node.rpc.envelope_by_hash(blob_tx_hash).await?;
+    // assert that it was converted to eip7594
+    assert!(envelope.as_eip4844().unwrap().tx().sidecar().unwrap().is_eip7594());
+    // validate sidecar
+    TransactionTestContext::validate_sidecar(envelope);
+
+    // submit the Prague payload
+    node.update_forkchoice(genesis_hash, node.submit_payload(prague_payload).await?).await?;
+
+    // Build first Osaka payload
+    node.payload.timestamp = osaka_timestamp - 1;
+    let osaka_payload = node.new_payload().await?;
+
+    // Assert that it includes the second blob tx with eip7594 sidecar
+    assert!(osaka_payload.block().body().transactions().any(|tx| *tx.hash() == blob_tx_hash));
+    assert!(matches!(osaka_payload.sidecars(), BlobSidecars::Eip7594(_)));
+
+    node.update_forkchoice(genesis_hash, node.submit_payload(osaka_payload).await?).await?;
+
+    Ok(())
+}