feat: ✨ add support for EIP-7702

Author: manuelmauro

client/rpc-core/src/types/pubsub.rs

@@ -126,7 +126,8 @@ impl PubSubResult {
 			let receipt_logs = match receipt {
 				EthereumReceipt::Legacy(d)
 				| EthereumReceipt::EIP2930(d)
-				| EthereumReceipt::EIP1559(d) => d.logs,
+				| EthereumReceipt::EIP1559(d)
+				| EthereumReceipt::EIP7702(d) => d.logs,
 			};
 
 			let transaction_hash: Option<H256> = if !receipt_logs.is_empty() {

frame/ethereum/src/lib.rs

@@ -36,7 +36,7 @@ use alloc::{vec, vec::Vec};
 use core::marker::PhantomData;
 pub use ethereum::{
 	AccessListItem, BlockV2 as Block, LegacyTransactionMessage, Log, ReceiptV3 as Receipt,
-	TransactionAction, TransactionV2 as Transaction,
+	TransactionAction, TransactionV3 as Transaction,
 };
 use ethereum_types::{Bloom, BloomInput, H160, H256, H64, U256};
 use evm::ExitReason;
@@ -432,6 +432,14 @@ impl<T: Config> Pallet<T> {
 					&ethereum::EIP1559TransactionMessage::from(t.clone()).hash()[..],
 				);
 			}
+			Transaction::EIP7702(t) => {
+				sig[0..32].copy_from_slice(&t.r[..]);
+				sig[32..64].copy_from_slice(&t.s[..]);
+				sig[64] = t.odd_y_parity as u8;
+				msg.copy_from_slice(
+					&ethereum::EIP7702TransactionMessage::from(t.clone()).hash()[..],
+				);
+			}
 		}
 		let pubkey = sp_io::crypto::secp256k1_ecdsa_recover(&sig, &msg).ok()?;
 		Some(H160::from(H256::from(sp_io::hashing::keccak_256(&pubkey))))
@@ -710,6 +718,12 @@ impl<T: Config> Pallet<T> {
 					logs_bloom,
 					logs,
 				}),
+				Transaction::EIP7702(_) => Receipt::EIP7702(ethereum::EIP7702ReceiptData {
+					status_code,
+					used_gas: cumulative_gas_used,
+					logs_bloom,
+					logs,
+				}),
 			}
 		};
 
@@ -819,9 +833,63 @@ impl<T: Config> Pallet<T> {
 						access_list,
 					)
 				}
+				Transaction::EIP7702(t) => {
+					let access_list: Vec<(H160, Vec<H256>)> = t
+						.access_list
+						.iter()
+						.map(|item| (item.address, item.storage_keys.clone()))
+						.collect();
+					(
+						t.data.clone(),
+						t.value,
+						t.gas_limit,
+						Some(t.max_fee_per_gas),
+						Some(t.max_priority_fee_per_gas),
+						Some(t.nonce),
+						t.destination,
+						access_list,
+					)
+				}
 			}
 		};
 
+		// Process EIP-7702 authorizations before execution
+		if let Transaction::EIP7702(ref eip7702_tx) = transaction {
+			// Convert authorization list to our format
+			let authorizations: Vec<fp_ethereum::Authorization> = eip7702_tx
+				.authorization_list
+				.iter()
+				.map(|item| fp_ethereum::Authorization::from(item.clone()))
+				.collect();
+
+			// Apply authorizations to EVM state
+			let current_chain_id = T::ChainId::get();
+			fp_ethereum::Authorization::apply_authorization_list(
+				&authorizations,
+				current_chain_id,
+				|address, code| {
+					// Set the delegation designator code directly in EVM storage
+					pallet_evm::AccountCodes::<T>::insert(address, &code);
+					
+					// Update code metadata for the new code (create manually since from_code is private)
+					let code_metadata = pallet_evm::CodeMetadata {
+						size: code.len() as u64,
+						hash: H256::from(sp_io::hashing::keccak_256(&code)),
+					};
+					pallet_evm::AccountCodesMetadata::<T>::insert(address, code_metadata);
+					
+					Ok(())
+				},
+			)
+			.map_err(|e| DispatchErrorWithPostInfo {
+				post_info: PostDispatchInfo {
+					actual_weight: None,
+					pays_fee: Pays::Yes,
+				},
+				error: sp_runtime::DispatchError::Other(e),
+			})?;
+		}
+
 		match action {
 			ethereum::TransactionAction::Call(target) => {
 				let res = match T::Runner::call(

frame/ethereum/src/mock.rs

@@ -414,3 +414,59 @@ impl EIP1559UnsignedTransaction {
 		})
 	}
 }
+
+pub struct EIP7702UnsignedTransaction {
+	pub nonce: U256,
+	pub max_priority_fee_per_gas: U256,
+	pub max_fee_per_gas: U256,
+	pub gas_limit: U256,
+	pub destination: TransactionAction,
+	pub value: U256,
+	pub data: Vec<u8>,
+	pub authorization_list: Vec<ethereum::AuthorizationListItem>,
+}
+
+impl EIP7702UnsignedTransaction {
+	pub fn sign(&self, secret: &H256, chain_id: Option<u64>) -> Transaction {
+		let secret = {
+			let mut sk: [u8; 32] = [0u8; 32];
+			sk.copy_from_slice(&secret[0..]);
+			libsecp256k1::SecretKey::parse(&sk).unwrap()
+		};
+		let chain_id = chain_id.unwrap_or(ChainId::get());
+		let msg = ethereum::EIP7702TransactionMessage {
+			chain_id,
+			nonce: self.nonce,
+			max_priority_fee_per_gas: self.max_priority_fee_per_gas,
+			max_fee_per_gas: self.max_fee_per_gas,
+			gas_limit: self.gas_limit,
+			destination: self.destination,
+			value: self.value,
+			data: self.data.clone(),
+			access_list: vec![],
+			authorization_list: self.authorization_list.clone(),
+		};
+		let signing_message = libsecp256k1::Message::parse_slice(&msg.hash()[..]).unwrap();
+
+		let (signature, recid) = libsecp256k1::sign(&signing_message, &secret);
+		let rs = signature.serialize();
+		let r = H256::from_slice(&rs[0..32]);
+		let s = H256::from_slice(&rs[32..64]);
+		Transaction::EIP7702(ethereum::EIP7702Transaction {
+			chain_id: msg.chain_id,
+			nonce: msg.nonce,
+			max_priority_fee_per_gas: msg.max_priority_fee_per_gas,
+			max_fee_per_gas: msg.max_fee_per_gas,
+			gas_limit: msg.gas_limit,
+			destination: msg.destination,
+			value: msg.value,
+			data: msg.data.clone(),
+			access_list: msg.access_list,
+			authorization_list: msg.authorization_list,
+			odd_y_parity: recid.serialize() != 0,
+			r,
+			s,
+		})
+	}
+}
+

frame/ethereum/src/tests/eip1559.rs

@@ -614,6 +614,7 @@ fn proof_size_base_cost_should_keep_the_same_in_execution_and_estimate() {
 			raw_tx.value,
 			Some(100),
 			vec![],
+			vec![],
 		);
 		assert_eq!(
 			estimate_tx_data.proof_size_base_cost(),

frame/ethereum/src/tests/eip2930.rs

@@ -539,6 +539,7 @@ fn proof_size_base_cost_should_keep_the_same_in_execution_and_estimate() {
 			raw_tx.value,
 			Some(100),
 			vec![],
+			vec![],
 		);
 		assert_eq!(
 			estimate_tx_data.proof_size_base_cost(),