[pallet-revive] EIP-7702 (continued)

prdoc/pr_12229.prdoc

@@ -0,0 +1,94 @@
+title: '[pallet-revive] EIP-7702 (continued)'
+doc:
+- audience: Runtime Dev
+  description: "Continuation of #10851.\nevm-test-suite PR: https://github.com/paritytech/evm-test-suite/pull/141\n\
+    \nThis PR implements [EIP-7702](https://eips.ethereum.org/EIPS/eip-7702) (\"Set\
+    \ EOA Account Code\") for `pallet-revive`, enabling Externally Owned Accounts\
+    \ (EOAs) to designate a contract whose code will be executed on their behalf when\
+    \ they are called.\n\n## What is EIP-7702?\n\nEIP-7702 lets an EOA sign an authorization\
+    \ that says \"when someone calls me, execute contract X's code\". When a transaction\
+    \ includes these authorizations, any subsequent calls to the delegated EOA will\
+    \ execute the target contract's code \u2014 but using the EOA's own storage and\
+    \ balance. This enables smart account patterns (batching, gas sponsorship, etc.)\
+    \ without requiring [account abstraction (ERC-4337)](https://eips.ethereum.org/EIPS/eip-4337)\
+    \ or proxy contracts.\n\nFor background:\n- [EIP-7702 spec](https://eips.ethereum.org/EIPS/eip-7702)\n\
+    - [Vitalik's \"Why we need wide adoption of account abstraction\"](https://vitalik.eth.limo/general/2023/06/09/three_transitions.html)\n\
+    - [EIP-7702 overview (ethereum.org)](https://ethereum.org/en/roadmap/account-abstraction/#eip-7702)\n\
+    \n## Changes\n\n### Pallet integration\n\nThe `eth_call` dispatchable now accepts\
+    \ and processes an authorization list before executing the call.\n\nThe `authorization_list`\
+    \ parameter is a `BoundedVec` capped at `limits::AUTHORIZATION_LIST_MAX` (256).\
+    \ In normal operation the size is already constrained by the gas-validation logic\
+    \ in `eth_transact` (each entry costs at least `worst_case_delegation_deposit`),\
+    \ but the `BoundedVec` is a defense-in-depth bound for any future call path that\
+    \ might bypass that check. Oversized lists are rejected in `into_call` with `InvalidTransaction::Call`.\n\
+    \n> **Note**: Updating the `eth_call` signature is safe \u2014 it is not dispatched\
+    \ directly by users but is the inner call of `eth_transact`, which is signed by\
+    \ an Ethereum wallet and submitted via `eth-rpc`.\n\n### Authorization processing\n\
+    \nThe `Transaction7702` type (with its `authorization_list`) was already defined\
+    \ and parsed; this PR adds the actual processing logic.\n\n`process_authorizations`\
+    \ validates each entry (chain ID, signature, nonce, account type), creates the\
+    \ authority account if needed, and sets or clears the delegation. Invalid authorizations\
+    \ are silently skipped per spec.\n\n**Key semantics:**\n- **Authorizations always\
+    \ succeed.** A type-4 transaction is only valid if the origin has enough gas to\
+    \ cover the worst case for every authorization entry. Processing itself cannot\
+    \ fail.\n- **Authorizations are not reverted.** If the transaction's call fails\
+    \ and its state changes revert, the delegation changes from authorization processing\
+    \ persist.\n\n**Revive-specific complexity.** In Revive the per-authorization\
+    \ pre-dispatch weight/gas is higher than in EVM because:\n- An authorization can\
+    \ touch a **new account**, so the gas must cover the existential deposit (ED)\
+    \ for account creation.\n- Code is shared across contracts (same blob for init\
+    \ and runtime), so delegating to a contract requires a **code lockup deposit**\
+    \ and increments a **refcount** on the code hash to prevent deletion while delegated.\n\
+    \n### Storage changes\n\nA new **`AccountType::DelegatedEOA`** variant is introduced:\n\
+    - `delegate_target: Option<H160>` \u2014 the contract address this EOA delegates\
+    \ to.\n- `contract_info: ContractInfo` \u2014 storage accounting (child trie,\
+    \ base deposit) for delegated EOAs.\n\n**Key behaviors:**\n- Once delegated, an\
+    \ account transitions from `EOA` to `DelegatedEOA` permanently.\n- Clearing delegation\
+    \ sets `delegate_target = None` but the account stays `DelegatedEOA`.\n- Delegated\
+    \ EOAs get their own child trie for storage, keyed by the EOA's address (not the\
+    \ target).\n- Re-delegating to a different target preserves the child trie \u2014\
+    \ storage survives across target changes.\n- Code refcounts are managed: setting\
+    \ delegation increments the target's code refcount, clearing it decrements.\n\n\
+    **Deposit lifecycle.** Clearing a delegation refunds the `storage_base_deposit`\
+    \ (the code-lockup portion) but preserves the child trie and per-item storage\
+    \ accounting. To recover the per-item deposit, the user must re-delegate to a\
+    \ contract that lets them clear the stored items through the normal storage path.\n\
+    \n### Execution changes\n\nDuring a call, the runtime resolves delegation:\n-\
+    \ If the callee is an EOA with a `delegate_target`, code is loaded from the target\
+    \ contract but execution uses the EOA's storage.\n- Constructors skip delegation\
+    \ lookup (cannot deploy via delegation).\n- **No chain following.** Delegation\
+    \ is resolved at most once. If A delegates to B and B delegates to C, calling\
+    \ A looks up code at B directly (without following B's delegation to C). If B\
+    \ is an EOA, calling A behaves like calling a plain EOA.\n\n### Benchmarks\n\n\
+    - `process_new_account_authorization(n)` \u2014 worst case: creates `n` new accounts\
+    \ with delegations.\n- `process_existing_account_authorization(n)` \u2014 best\
+    \ case: processes `n` authorizations for existing accounts (used for weight-refund\
+    \ calculation).\n\n### RPC integration\n\n- `eth-rpc` supports submitting and\
+    \ dry-running EIP-7702 transactions.\n- `eth_getCode` returns the `0xef0100 ||\
+    \ address` prefix for delegated EOAs (per EIP-7702 spec).\n\n## Tests\n\nTest\
+    \ coverage includes:\n- **Validation**: invalid chain_id, nonce mismatch, duplicate\
+    \ signers, chain_id 0 wildcard, contract accounts rejected.\n- **Delegation lifecycle**:\
+    \ set, clear, re-delegate, delegation resolution during calls.\n- **Storage persistence**:\
+    \ re-delegation preserves storage across different targets; clear-then-redelegate\
+    \ preserves the trie and recovers read/write access to previously written state\
+    \ (`storage_persists_across_clear_and_redelegate`).\n- **Deposit accounting**:\
+    \ delegation charges, clearing refunds, re-delegation adjustments, code-refcount\
+    \ tracking, EOA \u2192 EOA delegations charge no deposit, multiple authorities\
+    \ to the same target each get their own deposit.\n- **Edge cases**: delegation\
+    \ chains not followed, SELFDESTRUCT preserves delegation, constructors skip delegation,\
+    \ delegation to nonexistent addresses is a no-op."
+crates:
+- name: pallet-revive-eth-rpc
+  bump: major
+- name: pallet-revive
+  bump: major
+- name: assets-common
+  bump: major
+- name: pallet-xcm-precompiles
+  bump: major
+- name: pallet-assets-precompiles
+  bump: major
+- name: pallet-revive-fixtures
+  bump: major
+- name: asset-hub-westend-runtime
+  bump: major

substrate/frame/revive/Cargo.toml

@@ -71,6 +71,7 @@ alloy-consensus = { workspace = true, default-features = true }
 array-bytes = { workspace = true, default-features = true }
 assert_matches = { workspace = true }
 itertools = { workspace = true }
+k256 = { features = ["alloc", "ecdsa"], workspace = true }
 pretty_assertions = { workspace = true }
 secp256k1 = { workspace = true, features = ["recovery"] }
 serde_json = { workspace = true }
@@ -104,6 +105,7 @@ std = [
 	"frame-support/std",
 	"frame-system/std",
 	"humantime-serde",
+	"k256",
 	"k256?/std",
 	"log/std",
 	"num-bigint/std",

substrate/frame/revive/rpc/Cargo.toml

@@ -65,6 +65,7 @@ alloy-rpc-types = { workspace = true, default-features = true, features = ["trac
 alloy-signer-local = { workspace = true, default-features = true }
 env_logger = { workspace = true }
 frame-system = { workspace = true, default-features = true }
+k256 = { features = ["alloc", "ecdsa"], workspace = true }
 pallet-revive-fixtures = { workspace = true, default-features = true }
 pretty_assertions = { workspace = true }
 revive-dev-node = { workspace = true }

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

@@ -27,6 +27,7 @@ pub enum TransactionType {
 	Eip2930,
 	Eip1559,
 	Eip4844,
+	Eip7702,
 }
 
 /// Transaction builder.
@@ -37,6 +38,7 @@ pub struct TransactionBuilder<Client: EthRpcClient + Sync + Send> {
 	input: Bytes,
 	to: Option<H160>,
 	nonce: Option<U256>,
+	authorization_list: Vec<AuthorizationListEntry>,
 	gas: Option<U256>,
 	mutate: Box<dyn FnOnce(&mut TransactionUnsigned)>,
 }
@@ -49,6 +51,11 @@ pub struct SubmittedTransaction<Client: EthRpcClient + Sync + Send> {
 }
 
 impl<Client: EthRpcClient + Sync + Send> SubmittedTransaction<Client> {
+	/// Create from a raw transaction hash and gas limit.
+	pub fn from_raw(client: Arc<Client>, hash: H256, gas: U256) -> Self {
+		Self { tx: GenericTransaction { gas: Some(gas), ..Default::default() }, hash, client }
+	}
+
 	/// Get the hash of the transaction.
 	pub fn hash(&self) -> H256 {
 		self.hash
@@ -101,6 +108,7 @@ impl<Client: EthRpcClient + Send + Sync> TransactionBuilder<Client> {
 			input: Bytes::default(),
 			to: None,
 			nonce: None,
+			authorization_list: vec![],
 			gas: None,
 			mutate: Box::new(|_| {}),
 		}
@@ -135,6 +143,12 @@ impl<Client: EthRpcClient + Send + Sync> TransactionBuilder<Client> {
 		self
 	}
 
+	/// Set the authorization list (EIP-7702).
+	pub fn authorization_list(mut self, list: Vec<AuthorizationListEntry>) -> Self {
+		self.authorization_list = list;
+		self
+	}
+
 	/// Set the gas limit explicitly, skipping eth_estimateGas.
 	pub fn gas(mut self, gas: U256) -> Self {
 		self.gas = Some(gas);
@@ -149,7 +163,7 @@ impl<Client: EthRpcClient + Send + Sync> TransactionBuilder<Client> {
 
 	/// Call eth_call to get the result of a view function
 	pub async fn eth_call(self) -> anyhow::Result<Vec<u8>> {
-		let TransactionBuilder { client, signer, value, input, to, .. } = self;
+		let TransactionBuilder { client, signer, value, input, to, authorization_list, .. } = self;
 
 		let from = signer.address();
 		let result = client
@@ -159,6 +173,7 @@ impl<Client: EthRpcClient + Send + Sync> TransactionBuilder<Client> {
 					input: input.into(),
 					value: Some(value),
 					to,
+					authorization_list,
 					..Default::default()
 				},
 				None,
@@ -179,7 +194,17 @@ impl<Client: EthRpcClient + Send + Sync> TransactionBuilder<Client> {
 		self,
 		tx_type: TransactionType,
 	) -> anyhow::Result<SubmittedTransaction<Client>> {
-		let TransactionBuilder { client, signer, value, input, to, nonce, gas, mutate } = self;
+		let TransactionBuilder {
+			client,
+			signer,
+			value,
+			input,
+			to,
+			nonce,
+			authorization_list,
+			gas,
+			mutate,
+		} = self;
 
 		let from = signer.address();
 		let chain_id = client.chain_id().await?;
@@ -193,6 +218,13 @@ impl<Client: EthRpcClient + Send + Sync> TransactionBuilder<Client> {
 				.with_context(|| "Failed to fetch account nonce")?
 		};
 
+		let r#type = match tx_type {
+			TransactionType::Legacy => None,
+			TransactionType::Eip2930 => Some(Byte(1)),
+			TransactionType::Eip1559 => Some(Byte(2)),
+			TransactionType::Eip4844 => Some(Byte(3)),
+			TransactionType::Eip7702 => Some(Byte(4)),
+		};
 		let gas = if let Some(gas) = gas {
 			gas
 		} else {
@@ -204,6 +236,8 @@ impl<Client: EthRpcClient + Send + Sync> TransactionBuilder<Client> {
 						value: Some(value),
 						gas_price: Some(gas_price),
 						to,
+						r#type,
+						authorization_list: authorization_list.clone(),
 						..Default::default()
 					},
 					None,
@@ -275,6 +309,23 @@ impl<Client: EthRpcClient + Send + Sync> TransactionBuilder<Client> {
 				}
 				.into()
 			},
+			TransactionType::Eip7702 => {
+				let to = to.ok_or_else(|| {
+					anyhow::anyhow!("EIP-7702 transactions require a destination address")
+				})?;
+				Transaction7702Unsigned {
+					gas,
+					nonce,
+					to,
+					value,
+					input,
+					max_fee_per_gas: gas_price,
+					chain_id,
+					authorization_list,
+					..Default::default()
+				}
+				.into()
+			},
 		};
 		mutate(&mut unsigned_tx);
 

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

@@ -359,6 +359,7 @@ async fn run_all_eth_rpc_tests_inner() -> anyhow::Result<()> {
 		test_multiple_transactions_in_block,
 		test_mixed_evm_substrate_transactions,
 		test_runtime_pallets_address_upload_code,
+		test_eip7702_delegation_flow,
 		test_subscribe_new_heads,
 		test_subscribe_new_heads_multiple_blocks,
 		test_subscribe_logs,
@@ -1126,6 +1127,123 @@ async fn test_runtime_pallets_address_upload_code() -> anyhow::Result<()> {
 	Ok(())
 }
 
+/// Full EIP-7702 integration test:
+/// 1. Deploy Counter contract
+/// 2. Delegate Alice → Counter via 7702 tx with authorization list
+/// 3. Call setNumber(42) on Alice (writes to Alice's storage via Counter code)
+/// 4. Read number() from Alice → returns 42
+/// 5. Clear delegation (authorization with zero address)
+/// 6. Read from Alice → returns empty (no code)
+async fn test_eip7702_delegation_flow() -> anyhow::Result<()> {
+	use crate::example::TransactionType;
+	use pallet_revive::{evm::Account, precompiles::alloy::sol_types::SolCall};
+	use pallet_revive_fixtures::Counter;
+
+	let client = Arc::new(SharedResources::client().await);
+	let alith = Account::default();
+
+	// Deploy Counter contract
+	let (counter_code, _) = pallet_revive_fixtures::compile_module_with_type(
+		"Counter",
+		pallet_revive_fixtures::FixtureType::Solc,
+	)?;
+	let nonce = client.get_transaction_count(alith.address(), BlockTag::Latest.into()).await?;
+	let tx = TransactionBuilder::new(client.clone())
+		.input(counter_code.to_vec())
+		.send()
+		.await?;
+	tx.wait_for_receipt().await?;
+	let counter_addr = create1(&alith.address(), nonce.try_into().unwrap());
+
+	// Create authority account with known seed
+	let seed = [0xAA; 32];
+	let authority = Account::from_secret_key(seed);
+	let authority_key = k256::ecdsa::SigningKey::from_bytes(&seed.into()).unwrap();
+
+	// Fund the authority
+	let tx = TransactionBuilder::new(client.clone())
+		.value(U256::from(10_000_000_000_000_000_000u128))
+		.to(authority.address())
+		.send()
+		.await?;
+	tx.wait_for_receipt().await?;
+
+	let chain_id = client.chain_id().await?;
+
+	// --- Step 1: Delegate authority → Counter via 7702 tx ---
+	let auth_nonce = client
+		.get_transaction_count(authority.address(), BlockTag::Latest.into())
+		.await?;
+	let auth = pallet_revive::evm::eip7702::sign_authorization(
+		&authority_key,
+		chain_id,
+		counter_addr,
+		auth_nonce,
+	);
+	TransactionBuilder::new(client.clone())
+		.to(alith.address())
+		.authorization_list(vec![auth])
+		.send_with_type(TransactionType::Eip7702)
+		.await?
+		.wait_for_receipt()
+		.await?;
+
+	// Verify delegation is active: eth_getCode should return the delegation indicator
+	let code = client.get_code(authority.address(), BlockTag::Latest.into()).await?;
+	let mut expected_prefix = vec![0xef, 0x01, 0x00];
+	expected_prefix.extend_from_slice(counter_addr.as_bytes());
+	assert_eq!(code.0, expected_prefix, "authority should have delegation indicator code");
+
+	// --- Step 2: Call setNumber(42) on the authority address ---
+	let tx = TransactionBuilder::new(client.clone())
+		.to(authority.address())
+		.input(Counter::setNumberCall { newNumber: 42u64 }.abi_encode())
+		.send()
+		.await?;
+	tx.wait_for_receipt().await?;
+
+	// --- Step 3: Read number() from authority → should return 42 ---
+	let result = TransactionBuilder::new(client.clone())
+		.to(authority.address())
+		.input(Counter::numberCall {}.abi_encode())
+		.eth_call()
+		.await?;
+	let number = Counter::numberCall::abi_decode_returns(&result).unwrap();
+	assert_eq!(number, 42u64, "number() should return 42 after setNumber");
+
+	// --- Step 4: Clear delegation via 7702 tx with zero address ---
+	let auth_nonce = client
+		.get_transaction_count(authority.address(), BlockTag::Latest.into())
+		.await?;
+	let clear_auth = pallet_revive::evm::eip7702::sign_authorization(
+		&authority_key,
+		chain_id,
+		pallet_revive::evm::Address::zero(),
+		auth_nonce,
+	);
+	TransactionBuilder::new(client.clone())
+		.to(alith.address())
+		.authorization_list(vec![clear_auth])
+		.send_with_type(TransactionType::Eip7702)
+		.await?
+		.wait_for_receipt()
+		.await?;
+
+	// --- Step 5: Verify delegation is cleared ---
+	let code = client.get_code(authority.address(), BlockTag::Latest.into()).await?;
+	assert!(code.0.is_empty(), "authority should have no code after clearing delegation");
+
+	// Calling number() should return empty (no contract code)
+	let result = TransactionBuilder::new(client.clone())
+		.to(authority.address())
+		.input(Counter::numberCall {}.abi_encode())
+		.eth_call()
+		.await?;
+	assert!(result.is_empty(), "call to cleared delegation should return empty data");
+
+	Ok(())
+}
+
 /// Verify that subscribing to `newHeads` delivers a block header matching the
 /// corresponding block fetched via `eth_getBlockByNumber` after a transaction
 /// triggers a new block.