Add methods to set/remove delegations to StackState (#367)

* feat: ✨ add set_delegation and remove_delegation methods to StackState

* feat: ✨ add DelegationDesignator struct

* refactor: ♻️ make delegation designator more rusty

* refactor: 🚨 clippy

* refactor: 🔥 remove unused trait impls

* test: ✅ add missing assertions

* refactor: 🎨 rename authorizer to authority

* refactor: 🎨 rename remove_delegation to reset_delegation

Author: manuelmauro

core/src/delegation.rs

@@ -0,0 +1,112 @@
+extern crate alloc;
+
+use alloc::vec::Vec;
+use core::convert::TryFrom;
+use primitive_types::H160;
+
+/// EIP-7702 delegation designator prefix
+pub const EIP_7702_DELEGATION_PREFIX: &[u8] = &[0xef, 0x01, 0x00];
+
+/// EIP-7702 delegation designator full length (prefix + address)
+pub const EIP_7702_DELEGATION_SIZE: usize = 23;
+
+/// EIP-7702 delegation designator struct for managing delegation addresses
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Delegation {
+	address: H160,
+}
+
+impl Delegation {
+	/// Create a new delegation designator from an address
+	pub fn new(address: H160) -> Self {
+		Self { address }
+	}
+
+	/// Convert the delegation designator to its bytecode representation
+	pub fn to_bytes(&self) -> Vec<u8> {
+		let mut designator = Vec::with_capacity(EIP_7702_DELEGATION_SIZE);
+		designator.extend_from_slice(EIP_7702_DELEGATION_PREFIX);
+		designator.extend_from_slice(self.address.as_bytes());
+		designator
+	}
+
+	/// Get the delegated address
+	pub fn address(&self) -> &H160 {
+		&self.address
+	}
+
+	/// Consume the designator and return the address
+	pub fn into_address(self) -> H160 {
+		self.address
+	}
+}
+
+/// Check if code is an EIP-7702 delegation designator
+pub fn is_delegation_designator(code: &[u8]) -> bool {
+	code.len() == EIP_7702_DELEGATION_SIZE && code.starts_with(EIP_7702_DELEGATION_PREFIX)
+}
+
+impl From<H160> for Delegation {
+	fn from(address: H160) -> Self {
+		Self::new(address)
+	}
+}
+
+impl TryFrom<&[u8]> for Delegation {
+	type Error = DelegationError;
+
+	fn try_from(code: &[u8]) -> Result<Self, Self::Error> {
+		if !is_delegation_designator(code) {
+			return Err(DelegationError::InvalidFormat);
+		}
+
+		let mut address_bytes = [0u8; 20];
+		address_bytes.copy_from_slice(&code[3..23]);
+		Ok(Self {
+			address: H160::from(address_bytes),
+		})
+	}
+}
+
+/// Error type for delegation operations
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum DelegationError {
+	/// The provided bytes do not represent a valid delegation designator
+	InvalidFormat,
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn test_delegation_designator_creation() {
+		let address = H160::from_slice(&[1u8; 20]);
+		let designator = Delegation::new(address);
+		let bytes = designator.to_bytes();
+
+		assert_eq!(bytes.len(), EIP_7702_DELEGATION_SIZE);
+		assert_eq!(&bytes[0..3], EIP_7702_DELEGATION_PREFIX);
+		assert_eq!(&bytes[3..23], address.as_bytes());
+		assert_eq!(*designator.address(), address);
+	}
+
+	#[test]
+	fn test_delegation_designator_detection() {
+		let address = H160::from_slice(&[1u8; 20]);
+		let designator = Delegation::new(address);
+		let bytes = designator.to_bytes();
+
+		assert!(is_delegation_designator(&bytes));
+		let extracted = Delegation::try_from(&bytes);
+		assert_eq!(extracted, Some(designator));
+		assert_eq!(*extracted.unwrap().address(), address);
+	}
+
+	#[test]
+	fn test_non_delegation_code() {
+		let regular_code = vec![0x60, 0x00]; // PUSH1 0
+		assert!(!is_delegation_designator(&regular_code));
+		assert_eq!(Delegation::try_from(&regular_code), None);
+	}
+}

core/src/lib.rs

@@ -6,6 +6,7 @@
 
 extern crate alloc;
 
+pub mod delegation;
 mod error;
 mod eval;
 mod external;
@@ -26,13 +27,7 @@ use crate::eval::{eval, Control};
 use alloc::rc::Rc;
 use alloc::vec::Vec;
 use core::ops::Range;
-use primitive_types::{H160, U256};
-
-/// EIP-7702 delegation designator prefix
-pub const EIP_7702_DELEGATION_PREFIX: &[u8] = &[0xef, 0x01, 0x00];
-
-/// EIP-7702 delegation designator full length (prefix + address)
-pub const EIP_7702_DELEGATION_SIZE: usize = 23; // 3 bytes prefix + 20 bytes address
+use primitive_types::U256;
 
 /// Core execution layer for EVM.
 pub struct Machine {
@@ -184,58 +179,3 @@ impl Machine {
 		}
 	}
 }
-
-/// Check if code is an EIP-7702 delegation designator
-pub fn is_delegation_designator(code: &[u8]) -> bool {
-	code.len() == EIP_7702_DELEGATION_SIZE && code.starts_with(EIP_7702_DELEGATION_PREFIX)
-}
-
-/// Extract the delegated address from EIP-7702 delegation designator
-pub fn extract_delegation_address(code: &[u8]) -> Option<H160> {
-	if is_delegation_designator(code) {
-		let mut address_bytes = [0u8; 20];
-		address_bytes.copy_from_slice(&code[3..23]);
-		Some(H160::from(address_bytes))
-	} else {
-		None
-	}
-}
-
-/// Create EIP-7702 delegation designator
-pub fn create_delegation_designator(address: H160) -> Vec<u8> {
-	let mut designator = Vec::with_capacity(EIP_7702_DELEGATION_SIZE);
-	designator.extend_from_slice(EIP_7702_DELEGATION_PREFIX);
-	designator.extend_from_slice(address.as_bytes());
-	designator
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-
-	#[test]
-	fn test_delegation_designator_creation() {
-		let address = H160::from_slice(&[1u8; 20]);
-		let designator = create_delegation_designator(address);
-
-		assert_eq!(designator.len(), EIP_7702_DELEGATION_SIZE);
-		assert_eq!(&designator[0..3], EIP_7702_DELEGATION_PREFIX);
-		assert_eq!(&designator[3..23], address.as_bytes());
-	}
-
-	#[test]
-	fn test_delegation_designator_detection() {
-		let address = H160::from_slice(&[1u8; 20]);
-		let designator = create_delegation_designator(address);
-
-		assert!(is_delegation_designator(&designator));
-		assert_eq!(extract_delegation_address(&designator), Some(address));
-	}
-
-	#[test]
-	fn test_non_delegation_code() {
-		let regular_code = vec![0x60, 0x00]; // PUSH1 0
-		assert!(!is_delegation_designator(&regular_code));
-		assert_eq!(extract_delegation_address(&regular_code), None);
-	}
-}

runtime/src/handler.rs

@@ -1,5 +1,8 @@
+use core::convert::TryFrom;
+
 use crate::{Capture, Context, CreateScheme, ExitError, ExitReason, Machine, Opcode, Stack};
 use alloc::vec::Vec;
+use evm_core::delegation::Delegation;
 use primitive_types::{H160, H256, U256};
 
 /// Transfer from source to target, with given value.
@@ -36,8 +39,9 @@ pub trait Handler {
 	/// Get code of address, following EIP-7702 delegations if enabled.
 	fn delegated_code(&self, address: H160) -> Option<Vec<u8>> {
 		let code = self.code(address);
-		evm_core::extract_delegation_address(&code)
-			.map(|delegated_address| self.code(delegated_address))
+		Delegation::try_from(&code[..])
+			.map(|delegation| self.code(delegation.into_address()))
+			.ok()
 	}
 	/// Get storage value of address at index.
 	fn storage(&self, address: H160, index: H256) -> H256;

src/executor/stack/executor.rs

@@ -10,7 +10,9 @@ use crate::{
 	Transfer,
 };
 use alloc::{collections::BTreeSet, rc::Rc, vec::Vec};
-use core::{cmp::min, convert::Infallible};
+use core::cmp::min;
+use core::convert::{Infallible, TryFrom};
+use evm_core::delegation::Delegation;
 use evm_core::ExitFatal;
 use evm_runtime::Resolve;
 use primitive_types::{H160, H256, U256};
@@ -218,6 +220,8 @@ pub trait StackState<'config>: Backend {
 		code: Vec<u8>,
 		caller: Option<H160>,
 	) -> Result<(), ExitError>;
+	fn set_delegation(&mut self, authority: H160, delegation: Delegation) -> Result<(), ExitError>;
+	fn reset_delegation(&mut self, authority: H160) -> Result<(), ExitError>;
 	fn transfer(&mut self, transfer: Transfer) -> Result<(), ExitError>;
 	fn reset_balance(&mut self, address: H160);
 	fn touch(&mut self, address: H160);
@@ -823,7 +827,9 @@ impl<'config, 'precompiles, S: StackState<'config>, P: PrecompileSet>
 
 			// Skip if account has existing non-delegation code
 			let existing_code = self.state.code(authorizing_address);
-			if !existing_code.is_empty() && !evm_core::is_delegation_designator(&existing_code) {
+			if !existing_code.is_empty()
+				&& !evm_core::delegation::is_delegation_designator(&existing_code)
+			{
 				// Skip if account has non-delegation code
 				continue;
 			}
@@ -855,12 +861,12 @@ impl<'config, 'precompiles, S: StackState<'config>, P: PrecompileSet>
 			}
 
 			// Set account code: clear if delegating to zero address, otherwise set delegation designator
-			let code = if delegation_address == H160::zero() {
-				Vec::new()
+			if delegation_address == H160::zero() {
+				self.state.reset_delegation(authorizing_address)?;
 			} else {
-				evm_core::create_delegation_designator(delegation_address)
+				self.state
+					.set_delegation(authorizing_address, Delegation::new(delegation_address))?;
 			};
-			self.state.set_code(authorizing_address, code, None)?;
 
 			// Increment the nonce of the authorizing account
 			self.state.inc_nonce(authorizing_address)?;
@@ -1081,15 +1087,15 @@ impl<'config, 'precompiles, S: StackState<'config>, P: PrecompileSet>
 		let code = if self.config.has_eip_7702 {
 			// Check for delegation and record external operation if needed
 			let original_code = self.code(code_address);
-			if let Some(delegated_address) = evm_core::extract_delegation_address(&original_code) {
+			if let Ok(delegation) = Delegation::try_from(&original_code[..]) {
 				if let Err(e) = self.record_external_operation(
-					crate::ExternalOperation::DelegationResolution(delegated_address),
+					crate::ExternalOperation::DelegationResolution(*delegation.address()),
 				) {
 					let _ = self.exit_substate(StackExitKind::Failed);
 					return Capture::Exit((ExitReason::Error(e), Vec::new()));
 				}
 
-				self.code(delegated_address)
+				self.code(*delegation.address())
 			} else {
 				original_code
 			}

src/executor/stack/memory.rs

@@ -7,6 +7,7 @@ use alloc::{
 	vec::Vec,
 };
 use core::mem;
+use evm_core::delegation::Delegation;
 use primitive_types::{H160, H256, U256};
 
 #[derive(Clone, Debug)]
@@ -383,6 +384,19 @@ impl<'config> MemoryStackSubstate<'config> {
 		self.account_mut(address, backend).code = Some(code);
 	}
 
+	pub fn set_delegation<B: Backend>(
+		&mut self,
+		authority: H160,
+		delegation: Delegation,
+		backend: &B,
+	) {
+		self.account_mut(authority, backend).code = Some(delegation.to_bytes());
+	}
+
+	pub fn reset_delegation<B: Backend>(&mut self, authority: H160, backend: &B) {
+		self.account_mut(authority, backend).code = Some(Vec::new());
+	}
+
 	pub fn transfer<B: Backend>(
 		&mut self,
 		transfer: Transfer,
@@ -604,6 +618,21 @@ impl<'config, B: Backend> StackState<'config> for MemoryStackState<'_, 'config,
 		Ok(())
 	}
 
+	fn set_delegation(
+		&mut self,
+		authorizing: H160,
+		delegation: Delegation,
+	) -> Result<(), ExitError> {
+		self.substate
+			.set_delegation(authorizing, delegation, self.backend);
+		Ok(())
+	}
+
+	fn reset_delegation(&mut self, authority: H160) -> Result<(), ExitError> {
+		self.substate.reset_delegation(authority, self.backend);
+		Ok(())
+	}
+
 	fn transfer(&mut self, transfer: Transfer) -> Result<(), ExitError> {
 		self.substate.transfer(transfer, self.backend)
 	}