Eip7702 format starts with 0xEF0100

bins/revme/src/cmd/evmrunner.rs

@@ -2,7 +2,7 @@ use revm::{
     db::BenchmarkDB,
     inspector_handle_register,
     inspectors::TracerEip3155,
-    primitives::{eof::EofDecodeError, Address, Bytecode, TxKind},
+    primitives::{Address, Bytecode, BytecodeDecodeError, TxKind},
     Evm,
 };
 use std::io::Error as IoError;
@@ -26,7 +26,7 @@ pub enum Errors {
     #[error(transparent)]
     Io(#[from] IoError),
     #[error(transparent)]
-    EofError(#[from] EofDecodeError),
+    BytecodeDecodeError(#[from] BytecodeDecodeError),
 }
 
 /// Evm runner command allows running arbitrary evm bytecode.

crates/primitives/src/bytecode.rs

@@ -4,11 +4,11 @@ pub mod legacy;
 pub use eof::{Eof, EOF_MAGIC, EOF_MAGIC_BYTES, EOF_MAGIC_HASH};
 pub use legacy::{JumpTable, LegacyAnalyzedBytecode};
 
-use crate::{keccak256, Bytes, Eip7702Bytecode, B256, KECCAK_EMPTY};
+use crate::{keccak256, Bytes, Eip7702Bytecode, B256, EIP7702_MAGIC_BYTES, KECCAK_EMPTY};
 use alloy_primitives::Address;
-use core::panic;
+use core::{fmt::Debug, panic};
 use eof::EofDecodeError;
-use std::sync::Arc;
+use std::{fmt, sync::Arc};
 
 /// State of the [`Bytecode`] analysis.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -102,12 +102,18 @@ impl Bytecode {
     ///
     /// Returns an error on incorrect EOF format.
     #[inline]
-    pub fn new_raw_checked(bytecode: Bytes) -> Result<Self, EofDecodeError> {
-        // TODO include EIP-7702 check
-        if bytecode.starts_with(&EOF_MAGIC_BYTES) {
-            Ok(Self::Eof(Arc::new(Eof::decode(bytecode)?)))
-        } else {
-            Ok(Self::LegacyRaw(bytecode))
+    pub fn new_raw_checked(bytecode: Bytes) -> Result<Self, BytecodeDecodeError> {
+        let prefix = bytecode.get(..2);
+        match prefix {
+            Some(prefix) if prefix == &EOF_MAGIC_BYTES => {
+                let eof = Eof::decode(bytecode)?;
+                Ok(Self::Eof(Arc::new(eof)))
+            }
+            Some(prefix) if prefix == &EIP7702_MAGIC_BYTES => {
+                let eip7702 = Eip7702Bytecode::new(bytecode).ok_or(BytecodeDecodeError::Eip7702)?;
+                Ok(Self::Eip7702s(eip7702))
+            }
+            _ => Ok(Self::LegacyRaw(bytecode)),
         }
     }
 
@@ -207,6 +213,33 @@ impl Bytecode {
     }
 }
 
+/// EOF decode errors.
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum BytecodeDecodeError {
+    Eof(EofDecodeError),
+    // TODO EIP-7702 add errors
+    Eip7702,
+}
+
+impl From<EofDecodeError> for BytecodeDecodeError {
+    fn from(error: EofDecodeError) -> Self {
+        Self::Eof(error)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for BytecodeDecodeError {}
+
+impl fmt::Display for BytecodeDecodeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Eof(e) => fmt::Display::fmt(e, f),
+            Self::Eip7702 => f.write_str("EIP-7702 decode error"),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::{Bytecode, Eof};

crates/primitives/src/bytecode/eof.rs

@@ -110,6 +110,7 @@ impl Eof {
 
 /// EOF decode errors.
 #[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum EofDecodeError {
     /// Short input while processing EOF.
     MissingInput,

crates/primitives/src/eip7702.rs

@@ -4,7 +4,7 @@ pub mod bytecode;
 pub use authorization_list::{
     Authorization, AuthorizationList, RecoveredAuthorization, Signature, SignedAuthorization,
 };
-pub use bytecode::{Eip7702Bytecode, EIP7702_MAGIC, EIP7702_MAGIC_BYTES};
+pub use bytecode::{Eip7702Bytecode, EIP7702_MAGIC, EIP7702_MAGIC_BYTES, EIP7702_VERSION};
 
 // Base cost of updating authorized account.
 pub const PER_AUTH_BASE_COST: u64 = 2500;

crates/primitives/src/eip7702/authorization_list.rs

@@ -34,6 +34,18 @@ impl AuthorizationList {
         }
     }
 
+    /// Returns true if the authorization list is valid.
+    /// TODO EIP-7702 switch to error type.
+    pub fn is_valid(&self) -> bool {
+        true
+        /*
+        match self {
+            Self::Signed(signed) => signed.iter().all(|signed| signed.is_valid()),
+            Self::Recovered(recovered) => recovered.iter().all(|recovered| recovered.is_valid()),
+        }
+        */
+    }
+
     /// Return empty authorization list.
     pub fn empty() -> Self {
         Self::Recovered(Vec::new())

crates/primitives/src/eip7702/bytecode.rs

@@ -1,40 +1,57 @@
 use crate::{bytes, Address, Bytes};
 
-/// EIP Version Magic in u16 form.
+/// EIP-7702 Version Magic in u16 form.
 pub const EIP7702_MAGIC: u16 = 0xEF01;
 
-/// EOF magic number in array form.
+/// EIP-7702 magic number in array form.
 pub static EIP7702_MAGIC_BYTES: Bytes = bytes!("ef01");
 
+/// EIP-7702 first version of bytecode.
+pub const EIP7702_VERSION: u8 = 0;
+
+/// Bytecode of delegated account, specified in EIP-7702
+///
+/// Format of EIP-7702 bytecode consist of:
+/// 0xEF00 (MAGIC) + 0x00 (VERSION) + 20 bytes of address.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Eip7702Bytecode {
     pub delegated_address: Address,
+    pub version: u8,
     pub raw: Bytes,
 }
 
 impl Eip7702Bytecode {
     /// Creates a new EIP-7702 bytecode or returns None if the raw bytecode is invalid.
     #[inline]
     pub fn new(raw: Bytes) -> Option<Self> {
-        if raw.len() != 22 {
+        if raw.len() != 23 {
             return None;
         }
         if !raw.starts_with(&EIP7702_MAGIC_BYTES) {
             return None;
         }
+
+        // Only suported version is version 0.
+        if raw[2] != EIP7702_VERSION {
+            return None;
+        }
+
         Some(Self {
-            delegated_address: Address::new(raw[2..].try_into().unwrap()),
+            delegated_address: Address::new(raw[3..].try_into().unwrap()),
+            version: EIP7702_VERSION,
             raw,
         })
     }
 
     /// Creates a new EIP-7702 bytecode with the given address.
     pub fn new_address(address: Address) -> Self {
         let mut raw = EIP7702_MAGIC_BYTES.to_vec();
+        raw.push(EIP7702_VERSION);
         raw.extend(&address);
         Self {
             delegated_address: address,
+            version: EIP7702_VERSION,
             raw: raw.into(),
         }
     }
@@ -60,12 +77,13 @@ mod tests {
     fn sanity_decode() {
         let raw = bytes!("ef01deadbeef");
         assert_eq!(Eip7702Bytecode::new(raw), None);
-        let raw = bytes!("ef01deadbeef00000000000000000000000000000000");
-        let address = raw[2..].try_into().unwrap();
+        let raw = bytes!("ef0100deadbeef00000000000000000000000000000000");
+        let address = raw[3..].try_into().unwrap();
         assert_eq!(
             Eip7702Bytecode::new(raw.clone()),
             Some(Eip7702Bytecode {
                 delegated_address: address,
+                version: 0,
                 raw,
             })
         );
@@ -78,7 +96,7 @@ mod tests {
         assert_eq!(bytecode.delegated_address, address);
         assert_eq!(
             bytecode.raw,
-            bytes!("ef010101010101010101010101010101010101010101")
+            bytes!("ef01000101010101010101010101010101010101010101")
         );
     }
 }

crates/primitives/src/env.rs

@@ -202,6 +202,11 @@ impl Env {
                 return Err(InvalidTransaction::EmptyAuthorizationList);
             }
 
+            // Check validity of authorization_list
+            if !auth_list.is_valid() {
+                return Err(InvalidTransaction::InvalidAuthorizationList);
+            }
+
             // Check if other fields are unset.
             if self.tx.max_fee_per_blob_gas.is_some() || !self.tx.blob_hashes.is_empty() {
                 return Err(InvalidTransaction::AuthorizationListInvalidFields);

crates/primitives/src/result.rs

@@ -313,6 +313,8 @@ pub enum InvalidTransaction {
     AuthorizationListInvalidFields,
     /// Empty Authorization List is not allowed.
     EmptyAuthorizationList,
+    /// Invalid EIP-7702 Authorization List
+    InvalidAuthorizationList,
     /// Optimism-specific transaction validation error.
     #[cfg(feature = "optimism")]
     OptimismError(OptimismInvalidTransaction),
@@ -396,6 +398,7 @@ impl fmt::Display for InvalidTransaction {
                 write!(f, "authorization list tx has invalid fields")
             }
             Self::EmptyAuthorizationList => write!(f, "empty authorization list"),
+            Self::InvalidAuthorizationList => write!(f, "invalid authorization list"),
             #[cfg(feature = "optimism")]
             Self::OptimismError(op_error) => op_error.fmt(f),
         }