Feat: EIP-7702 implementation

.github/workflows/rust.yml

@@ -83,12 +83,21 @@ jobs:
           submodules: recursive
           fetch-depth: 1
 
+      - name: Download Ethereum spec tests fixtures
+        run: |
+          wget https://github.com/ethereum/execution-spec-tests/releases/download/pectra-devnet-3%40v1.5.0/fixtures_pectra-devnet-3.tar.gz
+          mkdir ethereum-spec-tests
+          tar -xzf fixtures_pectra-devnet-3.tar.gz -C ethereum-spec-tests
+          tree ethereum-spec-tests/fixtures/state_tests/prague/eip7702_set_code_tx
+
       - name: Run Ethereum state tests
         run: |
           cargo run -r -p evm-jsontests -F enable-slow-tests -- state -f \
           ethtests/GeneralStateTests/ \
           ethtests/LegacyTests/Cancun/GeneralStateTests/ \
-          ethtests/EIPTests/StateTests/
+          ethereum-spec-tests/fixtures/state_tests/prague/eip7702_set_code_tx/
+          # Temporally disable as EOFv1 not implemented
+          # ethtests/EIPTests/StateTests/
 
       - name: Run Ethereum vm tests
         run: |
@@ -134,8 +143,9 @@ jobs:
             export PATH="$PATH:$HOME/.cargo/bin"
             cargo run -r -p evm-jsontests -F enable-slow-tests -- state -f \
               ethtests/GeneralStateTests/ \
-              ethtests/LegacyTests/Cancun/GeneralStateTests/ \
-              ethtests/EIPTests/StateTests/
+              ethtests/LegacyTests/Cancun/GeneralStateTests/
+              # Temporally disable as EOFv1 not implemented
+              # ethtests/EIPTests/StateTests/
             cargo run -r -p evm-jsontests -F enable-slow-tests -- vm -f \
               ethtests/LegacyTests/Constantinople/VMTests/vmArithmeticTest \
               ethtests/LegacyTests/Constantinople/VMTests/vmBitwiseLogicOperation \

benches/loop.rs

@@ -60,6 +60,7 @@ fn run_loop_contract() {
 		// hex::decode("0f14a4060000000000000000000000000000000000000000000000000000000000002ee0").unwrap(),
 		u64::MAX,
 		Vec::new(),
+		Vec::new(),
 	);
 }
 

core/src/memory.rs

@@ -5,12 +5,15 @@ use core::cmp::min;
 use core::ops::{BitAnd, Not};
 use primitive_types::{H256, U256};
 
-/// A sequencial memory. It uses Rust's `Vec` for internal
+/// A sequential memory. It uses Rust's `Vec` for internal
 /// representation.
 #[derive(Clone, Debug)]
 pub struct Memory {
+	/// Memory data
 	data: Vec<u8>,
+	/// Memory effective length, that changed after resize operations.
 	effective_len: usize,
+	/// Memory limit
 	limit: usize,
 }
 
@@ -59,7 +62,7 @@ impl Memory {
 	/// with 32 bytes as the step. If the length is zero, this function does nothing.
 	///
 	/// # Errors
-	/// Return `ExitError`
+	/// Return `ExitError::InvalidRange` if `offset + len` is overflow.
 	pub fn resize_offset(&mut self, offset: usize, len: usize) -> Result<(), ExitError> {
 		if len == 0 {
 			return Ok(());
@@ -73,7 +76,7 @@ impl Memory {
 	/// Resize the memory, making it cover to `end`, with 32 bytes as the step.
 	///
 	/// # Errors
-	/// Return `ExitError`
+	/// Return `ExitError::InvalidRange` if `end` value is overflow in `next_multiple_of_32` call.
 	pub fn resize_end(&mut self, end: usize) -> Result<(), ExitError> {
 		if end > self.effective_len {
 			let new_end = next_multiple_of_32(end).ok_or(ExitError::InvalidRange)?;
@@ -105,7 +108,7 @@ impl Memory {
 		ret
 	}
 
-	/// Get `H256` from a specific offset in memory.
+	/// Get `H256` value from a specific offset in memory.
 	#[must_use]
 	pub fn get_h256(&self, offset: usize) -> H256 {
 		let mut ret = [0; 32];
@@ -127,7 +130,7 @@ impl Memory {
 	/// untrusted.
 	///
 	/// # Errors
-	/// Return `ExitFatal`
+	/// Return `ExitFatal::NotSupported` if `offset + target_size` is out of memory limit or overflow.
 	pub fn set(
 		&mut self,
 		offset: usize,
@@ -166,7 +169,9 @@ impl Memory {
 	/// `copy_within` uses `memmove` to avoid `DoS` attacks.
 	///
 	/// # Errors
-	/// Return `ExitFatal`
+	/// Return `ExitFatal::Other`:
+	/// - `OverflowOnCopy` if `offset + length` is overflow
+	/// - `OutOfGasOnCopy` if `offst_length` out of memory limit
 	pub fn copy(
 		&mut self,
 		src_offset: usize,
@@ -200,7 +205,7 @@ impl Memory {
 	/// Copy `data` into the memory, of given `len`.
 	///
 	/// # Errors
-	/// Return `ExitFatal`
+	/// Return `ExitFatal::NotSupported` if `set()` call return out of memory limit.
 	pub fn copy_large(
 		&mut self,
 		memory_offset: usize,

core/src/stack.rs

@@ -1,4 +1,4 @@
-use crate::prelude::*;
+use crate::prelude::Vec;
 use crate::utils::USIZE_MAX;
 use crate::ExitError;
 use primitive_types::{H256, U256};

evm-tests/ethjson/src/authentication_list.rs

@@ -0,0 +1 @@
+

evm-tests/ethjson/src/lib.rs

@@ -27,5 +27,6 @@ pub mod transaction;
 pub mod uint;
 pub mod vm;
 
+mod authentication_list;
 #[cfg(any(test, feature = "test-helpers"))]
 pub mod test_helpers;

evm-tests/ethjson/src/spec/spec.rs

@@ -64,9 +64,9 @@ pub enum ForkSpec {
 	Paris,
 	/// Shanghai (#17,034,870, 2023-04-12)
 	Shanghai,
-	/// Cancun (2024-03-13)
+	/// Cancun (28,750,000, 2024-03-13)
 	Cancun,
-	/// Prague-Electra—aka Pectra
+	/// Prague (future)
 	Prague,
 }
 
@@ -118,6 +118,7 @@ impl TryFrom<String> for ForkSpec {
 			"paris" => Self::Paris,
 			"shanghai" => Self::Shanghai,
 			"cancun" => Self::Cancun,
+			"prague" => Self::Prague,
 			other => return Err(format!("Unknown hard fork spec {other}")),
 		};
 		Ok(res)

evm-tests/ethjson/src/test_helpers/state.rs

@@ -79,6 +79,10 @@ pub struct MultiTransaction {
 	pub blob_versioned_hashes: Vec<U256>,
 	/// EIP-4844
 	pub max_fee_per_blob_gas: Option<Uint>,
+
+	/// EIP-7702
+	#[serde(default)]
+	pub authorization_list: AuthorizationList,
 }
 
 impl MultiTransaction {
@@ -109,6 +113,7 @@ impl MultiTransaction {
 			v: Default::default(),
 			secret: self.secret,
 			access_list,
+			authorization_list: self.authorization_list.clone(),
 		}
 	}
 }
@@ -127,6 +132,28 @@ pub struct AccessListTuple {
 	pub storage_keys: Vec<H256>,
 }
 
+/// EIP-7702 Authorization List
+pub type AuthorizationList = Vec<AuthorizationItem>;
+/// EIP-7702 Authorization item
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AuthorizationItem {
+	/// Chain ID
+	pub chain_id: Uint,
+	/// Address to access
+	pub address: Address,
+	/// Keys (slots) to access at that address
+	pub nonce: Uint,
+	/// r signature
+	pub r: Uint,
+	/// s signature
+	pub s: Uint,
+	/// Parity
+	pub v: Uint,
+	/// Signer address
+	pub signer: Option<Address>,
+}
+
 /// State test indexes deserialization.
 #[derive(Debug, PartialEq, Eq, Deserialize)]
 pub struct PostStateIndexes {

evm-tests/ethjson/src/transaction.rs

@@ -16,6 +16,7 @@
 
 //! Transaction deserialization.
 
+use crate::test_helpers::state::AuthorizationList;
 use crate::{
 	bytes::Bytes,
 	hash::{Address, H256},
@@ -33,6 +34,9 @@ pub struct Transaction {
 	/// Transaction access list (see EIP-2930).
 	#[serde(default)]
 	pub access_list: Vec<(Address, Vec<H256>)>,
+	/// Transaction authorization list (see EIP-7702`s).
+	#[serde(default)]
+	pub authorization_list: AuthorizationList,
 	/// Gas limit.
 	pub gas_limit: Uint,
 	/// To.

evm-tests/jsontests/src/main.rs

@@ -235,7 +235,6 @@ fn run_test_for_file(
 		);
 	}
 	let file = File::open(file_name).expect("Open file failed");
-
 	let reader = BufReader::new(file);
 	let test_suite = serde_json::from_reader::<_, HashMap<String, statetests::Test>>(reader)
 		.expect("Parse test cases failed");