feat(levm): implement EIP7702 - Set EOA account code

cmd/ef_tests/levm/runner/levm_runner.rs

@@ -98,8 +98,6 @@ pub fn prepare_vm_for_tx(vector: &TestVector, test: &EFTest) -> Result<VM, EFTes
                 v: auth_tuple.v,
                 r_signature: auth_tuple.r,
                 s_signature: auth_tuple.s,
-                // If the signer is not present, set it to Address::zero()
-                signer: auth_tuple.signer.unwrap_or_default(),
             })
             .collect::<Vec<AuthorizationTuple>>()
     });
@@ -242,6 +240,9 @@ fn exception_is_expected(
             ) | (
                 TransactionExpectedException::InitcodeSizeExceeded,
                 VMError::TxValidation(TxValidationError::InitcodeSizeExceeded)
+            ) | (
+                TransactionExpectedException::Type4TxContractCreation,
+                VMError::TxValidation(TxValidationError::Type4TxContractCreation)
             )
         )
     })

cmd/ef_tests/levm/runner/revm_runner.rs

@@ -137,32 +137,33 @@ pub fn prepare_revm_for_tx<'state>(
         .collect();
 
     let authorization_list = None;
+
+    // WARNING: Do not delete the following.
     // The latest version of revm(19.3.0) is needed.
     // Update it in every Cargo.toml.
     // revm-inspectors and revm-primitives have to be bumped too.
+    // NOTE:
+    // - rust 1.82.X is needed
+    // - rust-toolchain 1.82.X is needed (this can be found in ethrex/crates/vm/levm/rust-toolchain.toml)
     /*
-    let revm_authorization_list: Vec<SignedAuthorization> = tx
-        .authorization_list
-        .clone()
-        .unwrap_or_default()
-        .iter()
-        .map(|auth_t| {
-            SignedAuthorization::new_unchecked(
-                Authorization {
-                    chain_id: RevmU256::from_le_bytes(auth_t.chain_id.to_little_endian()),
-                    address: RevmAddress(auth_t.address.0.into()),
-                    nonce: auth_t.nonce,
-                },
-                auth_t.v.as_u32() as u8,
-                RevmU256::from_le_bytes(auth_t.r.to_little_endian()),
-                RevmU256::from_le_bytes(auth_t.s.to_little_endian()),
-            )
-        })
-        .collect();
-
-    let authorization_list = Some(revm_authorization_list.into());
+    let authorization_list = tx.authorization_list.clone().map(|list| {
+        list.iter()
+            .map(|auth_t| {
+                SignedAuthorization::new_unchecked(
+                    Authorization {
+                        chain_id: RevmU256::from_le_bytes(auth_t.chain_id.to_little_endian()),
+                        address: RevmAddress(auth_t.address.0.into()),
+                        nonce: auth_t.nonce,
+                    },
+                    auth_t.v.as_u32() as u8,
+                    RevmU256::from_le_bytes(auth_t.r.to_little_endian()),
+                    RevmU256::from_le_bytes(auth_t.s.to_little_endian()),
+                )
+            })
+            .collect::<Vec<SignedAuthorization>>()
+            .into()
+    });
     */
-
     let tx_env = RevmTxEnv {
         caller: tx.sender.0.into(),
         gas_limit: tx.gas_limit,

crates/vm/db.rs

@@ -36,6 +36,15 @@ cfg_if::cfg_if! {
                 }
             }
 
+            fn account_exists(&self, address: CoreAddress) -> bool {
+                let acc_info = self
+                .store
+                .get_account_info_by_hash(self.block_hash, address)
+                .unwrap();
+
+                acc_info.is_some()
+            }
+
             fn get_storage_slot(&self, address: CoreAddress, key: CoreH256) -> CoreU256 {
                 self.store
                     .get_storage_at_hash(self.block_hash, address, key)

crates/vm/levm/src/constants.rs

@@ -1,4 +1,9 @@
 use ethrex_core::{H256, U256};
+use k256::{
+    elliptic_curve::{bigint::Encoding, Curve},
+    Secp256k1,
+};
+use std::sync::LazyLock;
 
 pub const WORD_SIZE_IN_BYTES: U256 = U256([32, 0, 0, 0]);
 pub const WORD_SIZE_IN_BYTES_USIZE: usize = 32;
@@ -50,3 +55,16 @@ pub const VALID_BLOB_PREFIXES: [u8; 2] = [0x01, 0x02];
 // Block constants
 pub const LAST_AVAILABLE_BLOCK_LIMIT: U256 = U256([256, 0, 0, 0]);
 pub const MAX_BLOCK_GAS_LIMIT: U256 = U256([30_000_000, 0, 0, 0]);
+
+// EIP7702 - EOA Load Code
+pub static SECP256K1_ORDER: LazyLock<U256> =
+    LazyLock::new(|| U256::from_big_endian(&Secp256k1::ORDER.to_be_bytes()));
+pub static SECP256K1_ORDER_OVER2: LazyLock<U256> =
+    LazyLock::new(|| *SECP256K1_ORDER / U256::from(2));
+pub const MAGIC: u8 = 0x05;
+pub const SET_CODE_DELEGATION_BYTES: [u8; 3] = [0xef, 0x01, 0x00];
+// Set the code of authority to be 0xef0100 || address. This is a delegation designation.
+// len(SET_CODE_DELEGATION_BYTES) == 3 + len(Address) == 20 -> 23
+pub const EIP7702_DELEGATED_CODE_LEN: usize = 23;
+pub const PER_AUTH_BASE_COST: u64 = 12500;
+pub const PER_EMPTY_ACCOUNT_COST: u64 = 25000;

crates/vm/levm/src/db/mod.rs

@@ -9,6 +9,7 @@ pub trait Database {
     fn get_account_info(&self, address: Address) -> AccountInfo;
     fn get_storage_slot(&self, address: Address, key: H256) -> U256;
     fn get_block_hash(&self, block_number: u64) -> Option<H256>;
+    fn account_exists(&self, address: Address) -> bool;
 }
 
 #[derive(Debug, Default)]
@@ -58,6 +59,10 @@ impl Database for Db {
             .clone()
     }
 
+    fn account_exists(&self, address: Address) -> bool {
+        self.accounts.contains_key(&address)
+    }
+
     fn get_storage_slot(&self, address: Address, key: H256) -> U256 {
         // both `original_value` and `current_value` should work here because they have the same values on Db
         self.accounts

crates/vm/levm/src/errors.rs

@@ -190,6 +190,8 @@ pub enum InternalError {
     InvalidPrecompileAddress,
     #[error("Spec Id doesn't match to any fork")]
     InvalidSpecId,
+    #[error("Account should had been delegated")]
+    AccountNotDelegated,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, thiserror::Error, Serialize, Deserialize)]

crates/vm/levm/src/opcode_handlers/environment.rs

@@ -1,9 +1,10 @@
 use crate::{
     call_frame::CallFrame,
+    constants::SET_CODE_DELEGATION_BYTES,
     errors::{InternalError, OpcodeSuccess, VMError},
     gas_cost::{self},
     memory::{self, calculate_memory_size},
-    vm::{word_to_address, VM},
+    vm::{has_delegation, word_to_address, VM},
 };
 use ethrex_core::U256;
 use keccak_hash::keccak;
@@ -279,11 +280,16 @@ impl VM {
 
         let (account_info, address_was_cold) = self.access_account(address);
 
+        // https://eips.ethereum.org/EIPS/eip-7702#delegation-designation
+        let is_delegation = has_delegation(&account_info)?;
+
         self.increase_consumed_gas(current_call_frame, gas_cost::extcodesize(address_was_cold)?)?;
 
-        current_call_frame
-            .stack
-            .push(account_info.bytecode.len().into())?;
+        current_call_frame.stack.push(if is_delegation {
+            SET_CODE_DELEGATION_BYTES[..2].len().into()
+        } else {
+            account_info.bytecode.len().into()
+        })?;
 
         Ok(OpcodeSuccess::Continue)
     }
@@ -306,6 +312,9 @@ impl VM {
 
         let new_memory_size = calculate_memory_size(dest_offset, size)?;
 
+        // https://eips.ethereum.org/EIPS/eip-7702#delegation-designation
+        let is_delegation = has_delegation(&account_info)?;
+
         self.increase_consumed_gas(
             current_call_frame,
             gas_cost::extcodecopy(
@@ -320,18 +329,18 @@ impl VM {
             return Ok(OpcodeSuccess::Continue);
         }
 
+        let bytecode = if is_delegation {
+            SET_CODE_DELEGATION_BYTES[..2].into()
+        } else {
+            account_info.bytecode
+        };
+
         let mut data = vec![0u8; size];
-        if offset < account_info.bytecode.len().into() {
+        if offset < bytecode.len().into() {
             let offset: usize = offset
                 .try_into()
                 .map_err(|_| VMError::Internal(InternalError::ConversionError))?;
-            for (i, byte) in account_info
-                .bytecode
-                .iter()
-                .skip(offset)
-                .take(size)
-                .enumerate()
-            {
+            for (i, byte) in bytecode.iter().skip(offset).take(size).enumerate() {
                 if let Some(data_byte) = data.get_mut(i) {
                     *data_byte = *byte;
                 }
@@ -424,16 +433,26 @@ impl VM {
 
         let (account_info, address_was_cold) = self.access_account(address);
 
+        // https://eips.ethereum.org/EIPS/eip-7702#delegation-designation
+        let is_delegation = has_delegation(&account_info)?;
+
         self.increase_consumed_gas(current_call_frame, gas_cost::extcodehash(address_was_cold)?)?;
 
-        // An account is considered empty when it has no code and zero nonce and zero balance. [EIP-161]
-        if account_info.is_empty() {
-            current_call_frame.stack.push(U256::zero())?;
-            return Ok(OpcodeSuccess::Continue);
+        if is_delegation {
+            let hash =
+                U256::from_big_endian(keccak(&SET_CODE_DELEGATION_BYTES[..2]).as_fixed_bytes());
+            current_call_frame.stack.push(hash)?;
+        } else {
+            // An account is considered empty when it has no code and zero nonce and zero balance. [EIP-161]
+            if account_info.is_empty() {
+                current_call_frame.stack.push(U256::zero())?;
+                return Ok(OpcodeSuccess::Continue);
+            }
+
+            let hash = U256::from_big_endian(keccak(account_info.bytecode).as_fixed_bytes());
+            current_call_frame.stack.push(hash)?;
         }
 
-        let hash = U256::from_big_endian(keccak(account_info.bytecode).as_fixed_bytes());
-        current_call_frame.stack.push(hash)?;
         Ok(OpcodeSuccess::Continue)
     }
 }