Add comprehensive test data for Ethereum trie root validation

prdoc/pr_9452.prdoc

@@ -0,0 +1,35 @@
+title: Add comprehensive test data for Ethereum trie root validation
+doc:
+- audience: Runtime Dev
+  description: "### Summary\n\nThis PR adds comprehensive test data for validating\
+    \ Ethereum transaction and receipt trie root calculations in the `revive` crate.\
+    \ It includes real-world Ethereum blocks covering all supported transaction types.\n\
+    \n---\n\n### Details\n\n#### \U0001F9EA Test Data\n\n- **Expanded Test Fixtures**:\n\
+    \  - Added 3 Ethereum blocks with their receipts (2 from mainnet, 1 from Sepolia\
+    \ testnet)\n  - Blocks include all supported transaction types (Legacy, EIP-2930,\
+    \ EIP-1559, EIP-4844)\n  - Test data validates `transactions_root` and `receipts_root`\
+    \ calculations against real Ethereum data\n  - Organized naming: `block_{block_number}_{network}.json`\
+    \ and `receipts_{block_number}_{network}.json`\n\n#### \U0001F6E0\uFE0F Tooling\n\
+    \n- **Test Data Collection Script**:\n  - Added `get_test_data.sh` for fetching\
+    \ test data from live Ethereum networks\n  - Simple curl-based script that can\
+    \ be extended with additional blocks\n\nBuilds on top of: https://github.com/paritytech/polkadot-sdk/pull/9418\n\
+    \nPart of: https://github.com/paritytech/contract-issues/issues/139"
+crates:
+- name: pallet-revive
+  bump: minor
+- name: sp-core
+  bump: minor
+- name: asset-hub-westend-runtime
+  bump: minor
+- name: penpal-runtime
+  bump: minor
+- name: pallet-revive-eth-rpc
+  bump: minor
+- name: pallet-xcm
+  bump: minor
+- name: pallet-assets
+  bump: minor
+- name: revive-dev-runtime
+  bump: minor
+- name: pallet-assets-precompiles
+  bump: minor

substrate/frame/revive/rpc/examples/tx-types.rs

@@ -0,0 +1,50 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+use jsonrpsee::http_client::HttpClientBuilder;
+use pallet_revive::evm::Account;
+use pallet_revive_eth_rpc::example::{TransactionBuilder, TransactionType};
+use std::sync::Arc;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+	let client = Arc::new(HttpClientBuilder::default().build("http://localhost:8545")?);
+
+	let alith = Account::default();
+	let ethan = Account::from(subxt_signer::eth::dev::ethan());
+	let value = 1_000_000_000_000_000_000_000u128.into();
+
+	for tx_type in [
+		TransactionType::Legacy,
+		TransactionType::Eip2930,
+		TransactionType::Eip1559,
+		TransactionType::Eip4844,
+	] {
+		println!("\n\n=== TransactionType {tx_type:?}  ===\n\n",);
+
+		let tx = TransactionBuilder::new(&client)
+			.signer(alith.clone())
+			.value(value)
+			.to(ethan.address())
+			.send_with_type(tx_type)
+			.await?;
+		println!("Transaction hash: {:?}", tx.hash());
+
+		let receipt = tx.wait_for_receipt().await?;
+		println!("Receipt: {receipt:#?}");
+	}
+	Ok(())
+}

substrate/frame/revive/rpc/src/example.rs

@@ -20,6 +20,15 @@ use anyhow::Context;
 use pallet_revive::evm::*;
 use std::sync::Arc;
 
+/// Transaction type enum for specifying which type of transaction to send
+#[derive(Debug, Clone, Copy)]
+pub enum TransactionType {
+	Legacy,
+	Eip2930,
+	Eip1559,
+	Eip4844,
+}
+
 /// Transaction builder.
 pub struct TransactionBuilder<Client: EthRpcClient + Sync + Send> {
 	client: Arc<Client>,
@@ -28,7 +37,7 @@ pub struct TransactionBuilder<Client: EthRpcClient + Sync + Send> {
 	input: Bytes,
 	to: Option<H160>,
 	nonce: Option<U256>,
-	mutate: Box<dyn FnOnce(&mut TransactionLegacyUnsigned)>,
+	mutate: Box<dyn FnOnce(&mut TransactionUnsigned)>,
 }
 
 #[derive(Debug)]
@@ -63,7 +72,9 @@ impl<Client: EthRpcClient + Sync + Send> SubmittedTransaction<Client> {
 				if receipt.is_success() {
 					assert!(
 						self.gas() > receipt.gas_used,
-						"Gas used should be less than gas estimated."
+						"Gas used {:?} should be less than gas estimated {:?}",
+						receipt.gas_used,
+						self.gas()
 					);
 					return Ok(receipt)
 				} else {
@@ -119,7 +130,7 @@ impl<Client: EthRpcClient + Send + Sync> TransactionBuilder<Client> {
 	}
 
 	/// Set a mutation function, that mutates the transaction before sending.
-	pub fn mutate(mut self, mutate: impl FnOnce(&mut TransactionLegacyUnsigned) + 'static) -> Self {
+	pub fn mutate(mut self, mutate: impl FnOnce(&mut TransactionUnsigned) + 'static) -> Self {
 		self.mutate = Box::new(mutate);
 		self
 	}
@@ -147,10 +158,18 @@ impl<Client: EthRpcClient + Send + Sync> TransactionBuilder<Client> {
 
 	/// Send the transaction.
 	pub async fn send(self) -> anyhow::Result<SubmittedTransaction<Client>> {
+		self.send_with_type(TransactionType::Legacy).await
+	}
+
+	/// Send the transaction with a specific transaction type.
+	pub async fn send_with_type(
+		self,
+		tx_type: TransactionType,
+	) -> anyhow::Result<SubmittedTransaction<Client>> {
 		let TransactionBuilder { client, signer, value, input, to, nonce, mutate } = self;
 
 		let from = signer.address();
-		let chain_id = Some(client.chain_id().await?);
+		let chain_id = client.chain_id().await?;
 		let gas_price = client.gas_price().await?;
 		let nonce = if let Some(nonce) = nonce {
 			nonce
@@ -176,20 +195,73 @@ impl<Client: EthRpcClient + Send + Sync> TransactionBuilder<Client> {
 			.await
 			.with_context(|| "Failed to fetch gas estimate")?;
 
-		let mut unsigned_tx = TransactionLegacyUnsigned {
-			gas,
-			nonce,
-			to,
-			value,
-			input,
-			gas_price,
-			chain_id,
-			..Default::default()
-		};
+		println!("Gas estimate: {gas:?}");
 
+		let mut unsigned_tx: TransactionUnsigned = match tx_type {
+			TransactionType::Legacy => TransactionLegacyUnsigned {
+				gas,
+				nonce,
+				to,
+				value,
+				input,
+				gas_price,
+				chain_id: Some(chain_id),
+				..Default::default()
+			}
+			.into(),
+			TransactionType::Eip2930 => Transaction2930Unsigned {
+				gas,
+				nonce,
+				to,
+				value,
+				input,
+				gas_price,
+				chain_id,
+				access_list: vec![],
+				r#type: TypeEip2930,
+			}
+			.into(),
+			TransactionType::Eip1559 => Transaction1559Unsigned {
+				gas,
+				nonce,
+				to,
+				value,
+				input,
+				gas_price,
+				max_fee_per_gas: gas_price,
+				max_priority_fee_per_gas: U256::zero(),
+				chain_id,
+				access_list: vec![],
+				r#type: TypeEip1559,
+			}
+			.into(),
+			TransactionType::Eip4844 => {
+				// For EIP-4844, we need a destination address (cannot be None for blob
+				// transactions)
+				let to = to.ok_or_else(|| {
+					anyhow::anyhow!("EIP-4844 transactions require a destination address")
+				})?;
+				let max_priority_fee_per_gas = gas_price / 10; // 10% of gas price as priority fee
+				Transaction4844Unsigned {
+					gas,
+					nonce,
+					to,
+					value,
+					input,
+					max_fee_per_gas: gas_price,
+					max_priority_fee_per_gas,
+					max_fee_per_blob_gas: gas_price, // Use gas_price as blob gas fee
+					chain_id,
+					access_list: vec![],
+					blob_versioned_hashes: vec![],
+					r#type: TypeEip4844,
+				}
+				.into()
+			},
+		};
 		mutate(&mut unsigned_tx);
 
-		let signed_tx = signer.sign_transaction(unsigned_tx.into());
+		let signed_tx = signer.sign_transaction(unsigned_tx);
 		let bytes = signed_tx.signed_payload();
 
 		let hash = client

substrate/frame/revive/rpc/src/tests.rs

@@ -34,7 +34,7 @@ use pallet_revive::{
 	create1,
 	evm::{
 		Account, Block, BlockNumberOrTag, BlockNumberOrTagOrHash, BlockTag,
-		HashesOrTransactionInfos, TransactionInfo, H256, U256,
+		HashesOrTransactionInfos, TransactionInfo, TransactionUnsigned, H256, U256,
 	},
 };
 use std::{sync::Arc, thread};
@@ -450,7 +450,13 @@ async fn test_invalid_transaction(client: Arc<WsClient>) -> anyhow::Result<()> {
 	let err = TransactionBuilder::new(&client)
 		.value(U256::from(1_000_000_000_000u128))
 		.to(ethan.address())
-		.mutate(|tx| tx.chain_id = Some(42u32.into()))
+		.mutate(|tx| match tx {
+			TransactionUnsigned::TransactionLegacyUnsigned(tx) => tx.chain_id = Some(42u32.into()),
+			TransactionUnsigned::Transaction1559Unsigned(tx) => tx.chain_id = 42u32.into(),
+			TransactionUnsigned::Transaction2930Unsigned(tx) => tx.chain_id = 42u32.into(),
+			TransactionUnsigned::Transaction4844Unsigned(tx) => tx.chain_id = 42u32.into(),
+			TransactionUnsigned::Transaction7702Unsigned(tx) => tx.chain_id = 42u32.into(),
+		})
 		.send()
 		.await
 		.unwrap_err();

substrate/frame/revive/src/evm/api/rlp_codec.rs

@@ -637,7 +637,6 @@ mod test {
 			),
 			// type 3: EIP4844
 			(
-
 				"03f8bf018002018301e24194095e7baea6a6c7c4c2dfeb977efac326af552d878080f838f7940000000000000000000000000000000000000001e1a0000000000000000000000000000000000000000000000000000000000000000080e1a0000000000000000000000000000000000000000000000000000000000000000080a0fe38ca4e44a30002ac54af7cf922a6ac2ba11b7d22f548e8ecb3f51f41cb31b0a06de6a5cbae13c0c856e33acf021b51819636cfc009d39eafb9f606d546e305a8",
 				r#"
 				{
@@ -662,7 +661,7 @@ mod test {
 					"s": "0x6de6a5cbae13c0c856e33acf021b51819636cfc009d39eafb9f606d546e305a8",
 					"yParity": "0x0"
 				}
-				"#
+				"#,
 			)
 		];
 
@@ -693,4 +692,32 @@ mod test {
 		let payload = Account::default().sign_transaction(tx).signed_payload();
 		assert_eq!(dummy_signed_payload.len(), payload.len());
 	}
+
+	#[test]
+	fn rlp_codec_is_compatible_with_ethereum() {
+		// RLP encoded transactions
+		let test_cases = [
+			// Legacy
+			"f86080808301e24194095e7baea6a6c7c4c2dfeb977efac326af552d87808025a0fe38ca4e44a30002ac54af7cf922a6ac2ba11b7d22f548e8ecb3f51f41cb31b0a06de6a5cbae13c0c856e33acf021b51819636cfc009d39eafb9f606d546e305a8",
+			// EIP-2930
+			"01f89b0180808301e24194095e7baea6a6c7c4c2dfeb977efac326af552d878080f838f7940000000000000000000000000000000000000001e1a0000000000000000000000000000000000000000000000000000000000000000080a0fe38ca4e44a30002ac54af7cf922a6ac2ba11b7d22f548e8ecb3f51f41cb31b0a06de6a5cbae13c0c856e33acf021b51819636cfc009d39eafb9f606d546e305a8",
+			// EIP-1559
+			"02f89c018080018301e24194095e7baea6a6c7c4c2dfeb977efac326af552d878080f838f7940000000000000000000000000000000000000001e1a0000000000000000000000000000000000000000000000000000000000000000080a0fe38ca4e44a30002ac54af7cf922a6ac2ba11b7d22f548e8ecb3f51f41cb31b0a06de6a5cbae13c0c856e33acf021b51819636cfc009d39eafb9f606d546e305a8",
+			// EIP4844
+      		"03f89783aa36a701832dc6c083fc546c8261a8947f8b1ca29f95274e06367b60fc4a539e4910fd0c865af3107a400080c0831e8480e1a0018fd423d1ad106395f04abac797217d4dece29da3ba649d9aa4da70e98fa6ff80a028d2350a1bfa5043de1533911143eb5c43815a58039121a0ccf124870620fca6a0157eca4963615cd3926538af88e529cfa3baf6c55787a33f79c25babe9f5db2b",
+		];
+
+		for hex_tx in test_cases {
+			let rlp_encoded_tx = alloy_core::hex::decode(hex_tx).unwrap();
+
+			// RLP decode using this implementation
+			let tx_revive = TransactionSigned::decode(&rlp_encoded_tx).unwrap();
+
+			// RLP encode using this implementation
+			let rlp_encoded_revive = tx_revive.signed_payload();
+
+			// Verify round-trip: our encoding should decode back to the same transaction
+			assert_eq!(rlp_encoded_tx, rlp_encoded_revive);
+		}
+	}
 }