PARTIAL: Support for full transaction fields

carver · carver · commit 83c70044d46c · 2023-10-11T13:07:35.000-07:00
diff --git a/ethportal-api/src/utils/rethtypes.rs b/ethportal-api/src/utils/rethtypes.rs
@@ -1,4 +1,4 @@
-use ethereum_types::U256;
+use ethereum_types::{U256, U64};
 use ruint::Uint;
 
 pub fn u256_to_uint256(u256: U256) -> Uint<256, 4> {
@@ -16,3 +16,9 @@ pub fn u64_to_uint256(val: u64) -> Uint<256, 4> {
         .expect("8 bytes + 24 bytes should be 32 bytes");
     Uint::from_be_bytes(bytes)
 }
+
+pub fn ethtype_u64_to_uint256(val: U64) -> Uint<256, 4> {
+    let mut bytes = [0u8; 32];
+    val.to_big_endian(&mut bytes);
+    Uint::from_be_bytes(bytes)
+}
diff --git a/rpc/src/eth_rpc.rs b/rpc/src/eth_rpc.rs
@@ -1,13 +1,14 @@
-use ethereum_types::{H256, U256};
-use reth_rpc_types::{Block, BlockTransactions};
+use ethereum_types::{H256, U256, U64};
+use reth_rpc_types::{Block, BlockTransactions, Parity, Signature, Transaction as RethTransaction};
 use tokio::sync::mpsc;
 
 use ethportal_api::types::execution::block_body::BlockBody;
+use ethportal_api::types::execution::transaction::Transaction;
 use ethportal_api::types::jsonrpc::request::HistoryJsonRpcRequest;
+use ethportal_api::utils::rethtypes::{ethtype_u64_to_uint256, u256_to_uint256};
 use ethportal_api::EthApiServer;
 use trin_validation::constants::CHAIN_ID;
 
-use crate::errors::RpcServeError;
 use crate::fetch::{find_block_body_by_hash, find_header_by_hash};
 use crate::jsonrpsee::core::{async_trait, RpcResult};
 
@@ -21,6 +22,126 @@ impl EthApi {
     }
 }
 
+fn rpc_transaction(
+    transaction: Transaction,
+    block_hash: H256,
+    block_number: u64,
+    transaction_index: usize,
+) -> RethTransaction {
+    // Fields not extractable from the transaction itself
+    let block_hash = block_hash.as_fixed_bytes().into();
+    let block_number = U256::from(block_number);
+    let transaction_index = Some(U256::from(transaction_index));
+
+    // Fields calculated on the full transaction envelope
+    let hash = transaction.hash().as_fixed_bytes().into();
+    let type_id = match transaction.type_id() {
+        0 => None,
+        n => Some(U64::from(n)),
+    };
+    // TODO: generate 'from' address from signature
+    let from = None;
+
+    // Fields internal to the transaction, sometimes varying by transaction type
+    let (
+        nonce,
+        gas_price,
+        gas,
+        to,
+        value,
+        input,
+        v,
+        r,
+        s,
+        max_fee_per_gas,
+        max_priority_fee_per_gas,
+        access_list,
+        y_parity,
+    ) = match transaction {
+        Transaction::Legacy(tx) => (
+            tx.nonce,
+            Some(tx.gas_price),
+            tx.gas,
+            tx.to,
+            tx.value,
+            tx.data,
+            tx.v,
+            tx.r,
+            tx.s,
+            None,
+            None,
+            None,
+            None,
+        ),
+        Transaction::AccessList(tx) => (
+            tx.nonce,
+            Some(tx.gas_price),
+            tx.gas,
+            tx.to,
+            tx.value,
+            tx.data,
+            tx.y_parity,
+            tx.r,
+            tx.s,
+            None,
+            None,
+            Some(tx.access_list),
+            Some(tx.y_parity),
+        ),
+        Transaction::EIP1559(tx) => (
+            tx.nonce,
+            None,
+            tx.gas,
+            tx.to,
+            tx.value,
+            tx.data,
+            tx.y_parity,
+            tx.r,
+            tx.s,
+            Some(tx.max_fee_per_gas),
+            Some(tx.max_priority_fee_per_gas),
+            Some(tx.access_list),
+            Some(tx.y_parity),
+        ),
+    };
+
+    // Convert types
+    let (gas, value) = (u256_to_uint256(gas), u256_to_uint256(value));
+    let signature = Some(Signature {
+        r: u256_to_uint256(r),
+        s: u256_to_uint256(s),
+        v: ethtype_u64_to_uint256(v),
+        y_parity: y_parity.map(|y| Parity(!y.is_zero())),
+    });
+
+    // Fields that are hardcoded, for now
+    let max_fee_per_blob_gas = None;
+    let chain_id = Some(CHAIN_ID.into());
+    let blob_versioned_hashes = vec![];
+
+    RethTransaction {
+        hash,
+        nonce,
+        block_hash,
+        block_number,
+        transaction_index,
+        from,
+        to,
+        value,
+        gas_price,
+        gas,
+        max_fee_per_gas,
+        max_priority_fee_per_gas,
+        max_fee_per_blob_gas,
+        input,
+        signature,
+        chain_id,
+        blob_versioned_hashes,
+        access_list,
+        transaction_type,
+    }
+}
+
 #[async_trait]
 impl EthApiServer for EthApi {
     async fn chain_id(&self) -> RpcResult<U256> {
@@ -32,26 +153,29 @@ impl EthApiServer for EthApi {
         block_hash: H256,
         hydrated_transactions: bool,
     ) -> RpcResult<Block> {
-        if hydrated_transactions {
-            return Err(RpcServeError::Message(
-                "replying with all transaction bodies is not supported yet".into(),
-            )
-            .into());
-        }
-
         let header = find_header_by_hash(&self.network, block_hash).await?;
         let body = find_block_body_by_hash(&self.network, block_hash).await?;
         let transactions = match body {
             BlockBody::Legacy(body) => body.txs,
             BlockBody::Merge(body) => body.txs,
             BlockBody::Shanghai(body) => body.txs,
         };
-        let transactions = BlockTransactions::Hashes(
-            transactions
-                .into_iter()
-                .map(|tx| tx.hash().as_fixed_bytes().into())
-                .collect(),
-        );
+        let transactions = if hydrated_transactions {
+            BlockTransactions::Full(
+                transactions
+                    .into_iter()
+                    .enumerate()
+                    .map(|(idx, tx)| rpc_transaction(tx, block_hash, header.number, idx))
+                    .collect(),
+            )
+        } else {
+            BlockTransactions::Hashes(
+                transactions
+                    .into_iter()
+                    .map(|tx| tx.hash().as_fixed_bytes().into())
+                    .collect(),
+            )
+        };
 
         // Combine header and block body into the single json representation of the block.
         let block = Block {
diff --git a/tests/rpc_server.rs b/tests/rpc_server.rs
@@ -70,7 +70,10 @@ async fn test_eth_chain_id() {
 
 #[tokio::test(flavor = "multi_thread")]
 #[serial]
-async fn test_eth_get_block_by_hash() {
+/// Test that a 3rd-party web3 client can understand our JSON-RPC API
+/// for eth_getBlockByHash
+/// Return the transactions as hashes, aka not "hydrated"
+async fn test_eth_get_block_by_hash_dehydrated() {
     let (web3_server, web3_client, native_client) = setup_web3_server().await;
 
     let (hwp, body) = get_full_block();
@@ -183,6 +186,72 @@ async fn test_eth_get_block_by_hash() {
     );
 }
 
+#[tokio::test(flavor = "multi_thread")]
+#[serial]
+/// Test that a 3rd-party web3 client can understand our JSON-RPC API
+/// for eth_getBlockByHash
+/// Return the transactions as fully formed, aka "hydrated"
+async fn test_eth_get_block_by_hash_hydrated() {
+    let (web3_server, web3_client, native_client) = setup_web3_server().await;
+
+    let (hwp, body) = get_full_block();
+    // Save values for later comparison
+    let (block_number, block_hash) = (hwp.header.number.into(), hwp.header.hash());
+
+    let BlockBody::Shanghai(shanghai_body) = body.clone() else { panic!("expected shanghai body") };
+
+    // Store header with proof in server
+    let content_key = HistoryContentKey::BlockHeaderWithProof(block_hash.into());
+    let content_value = HistoryContentValue::BlockHeaderWithProof(hwp);
+    let result = native_client
+        .store(content_key, content_value)
+        .await
+        .unwrap();
+    assert!(result);
+
+    // Store block in server
+    let content_key = HistoryContentKey::BlockBody(block_hash.into());
+    let content_value = HistoryContentValue::BlockBody(body);
+    let result = native_client
+        .store(content_key, content_value)
+        .await
+        .unwrap();
+    assert!(result);
+
+    // The meat of the test is here:
+    // Retrieve block over json-rpc
+    let block_id = ethers_core::types::H256::from(&block_hash.0);
+    let block = web3_client
+        .get_block_with_txs(block_id)
+        .await
+        .expect("request to get block failed")
+        .expect("specified block not found");
+    web3_server.stop().unwrap();
+
+    let block_hash = block_hash.as_fixed_bytes().into();
+    assert_eq!(block.number.expect("number must be present"), block_number);
+    assert_eq!(block.hash.expect("hash must be present"), block_hash);
+    assert_eq!(block.transactions.len(), shanghai_body.txs.len());
+
+    // Spot check the fields of a few transactions:
+    // First tx
+    assert_eq!(
+        hex_encode(block.transactions[0].hash),
+        "0xd06a110de42d674a84b2091cbd85ef514fb4e903f9a80dd7b640c48365a1a832"
+    );
+    // Last tx
+    assert_eq!(
+        hex_encode(block.transactions[84].hash),
+        "0x27e9e8fb3745d990c7d775268539fa17bbf06255e24a882c3153bf3b513ced9e"
+    );
+    // Legacy block
+    assert_eq!(
+        hex_encode(block.transactions[5].hash),
+        "0x2f678341f550f7073a514c4b34f09824119f31dfbe7cc73ffccb21b7a2ba5710"
+    );
+    panic!("TODO: Test more fields");
+}
+
 fn get_full_block() -> (HeaderWithProof, BlockBody) {
     let file = fs::read_to_string("trin-validation/src/assets/hive/blocks.yaml").unwrap();
     let value: Value = serde_yaml::from_str(&file).unwrap();
