7702 execution session keys (#21)

* Add engine-eip7702-core package and update dependencies

- Introduced the `engine-eip7702-core` package with its dependencies in `Cargo.lock` and `Cargo.toml`.
- Updated the `executors` module to include `engine-eip7702-core` as a dependency.
- Refactored execution options in `eip7702.rs` to support new execution models for EIP-7702.
- Enhanced transaction handling in the `eip7702_executor` to accommodate new sender details and improve compatibility with existing job structures.
- Updated webhook and job data structures to reflect changes in sender details and execution options.
- Improved error handling and retry logic in job processing to enhance robustness.

* clippy

Author: d4mr

Cargo.lock

@@ -3,6 +3,7 @@ members = [
   "aa-types",
   "aa-core",
   "core",
+  "eip7702-core",
   "executors",
   "server",
   "thirdweb-core",

Cargo.toml

@@ -1,15 +1,36 @@
 use alloy::primitives::Address;
-use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use crate::defs::AddressDef;
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, utoipa::ToSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
 #[schema(title = "EIP-7702 Execution Options")]
+#[serde(rename_all = "camelCase", untagged)]
+pub enum Eip7702ExecutionOptions {
+    /// Execute the transaction as the owner of the account
+    Owner(Eip7702OwnerExecution),
+    /// Execute a transaction on a different delegated account (`account_address`), which has granted a session key to the `session_key_address`
+    /// `session_key_address` is the signer for this transaction
+    SessionKey(Eip7702SessionKeyExecution),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
+#[schema(title = "EIP-7702 Owner Execution")]
 #[serde(rename_all = "camelCase")]
-pub struct Eip7702ExecutionOptions {
-    /// The EOA address that will sign the EIP-7702 transaction
-    #[schemars(with = "AddressDef")]
+pub struct Eip7702OwnerExecution {
     #[schema(value_type = AddressDef)]
+    /// The delegated EOA address
     pub from: Address,
 }
+
+#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
+#[schema(title = "EIP-7702 Session Key Execution")]
+#[serde(rename_all = "camelCase")]
+pub struct Eip7702SessionKeyExecution {
+    #[schema(value_type = AddressDef)]
+    /// The session key address is your server wallet, which has been granted a session key to the `account_address`
+    pub session_key_address: Address,
+    #[schema(value_type = AddressDef)]
+    /// The account address is the address of a delegated account you want to execute the transaction on. This account has granted a session key to the `session_key_address`
+    pub account_address: Address,
+}

core/src/execution_options/eip7702.rs

@@ -27,7 +27,7 @@ fn default_idempotency_key() -> String {
 }
 
 /// All supported specific execution options are contained here
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, utoipa::ToSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
 #[serde(tag = "type")]
 #[schema(title = "Execution Option Variants")]
 pub enum SpecificExecutionOptions {

core/src/execution_options/mod.rs

@@ -338,7 +338,7 @@ impl AccountSigner for EoaSigner {
             } => {
                 let iaw_result = self
                     .iaw_client
-                    .sign_transaction(auth_token, thirdweb_auth, &transaction)
+                    .sign_transaction(auth_token, thirdweb_auth, transaction)
                     .await
                     .map_err(|e| {
                         tracing::error!("Error signing transaction with EOA (IAW): {:?}", e);

core/src/signer.rs

@@ -0,0 +1,14 @@
+[package]
+name = "engine-eip7702-core"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+alloy = { workspace = true, features = ["serde"] }
+tokio = "1.44.2"
+engine-core = { path = "../core" }
+serde = { version = "1.0.219", features = ["derive"] }
+serde_json = "1.0"
+tracing = "0.1.41"
+rand = "0.9"
+thiserror = "2.0" 

eip7702-core/Cargo.toml

@@ -0,0 +1,11 @@
+use alloy::primitives::{Address, address};
+
+/// The minimal account implementation address used for EIP-7702 delegation
+pub const MINIMAL_ACCOUNT_IMPLEMENTATION_ADDRESS: Address =
+    address!("0xD6999651Fc0964B9c6B444307a0ab20534a66560");
+
+/// EIP-7702 delegation prefix bytes
+pub const EIP_7702_DELEGATION_PREFIX: [u8; 3] = [0xef, 0x01, 0x00];
+
+/// EIP-7702 delegation code length (prefix + address)
+pub const EIP_7702_DELEGATION_CODE_LENGTH: usize = 23; 

eip7702-core/src/constants.rs

@@ -0,0 +1,132 @@
+use alloy::{
+    primitives::{Address, FixedBytes},
+    providers::Provider,
+};
+use engine_core::{
+    chain::Chain,
+    credentials::SigningCredential,
+    error::{AlloyRpcErrorToEngineError, EngineError},
+    signer::{AccountSigner, EoaSigner, EoaSigningOptions},
+};
+use rand::Rng;
+
+use crate::constants::{
+    EIP_7702_DELEGATION_CODE_LENGTH, EIP_7702_DELEGATION_PREFIX,
+    MINIMAL_ACCOUNT_IMPLEMENTATION_ADDRESS,
+};
+
+/// Represents an EOA address that can have EIP-7702 delegation, associated with a specific chain
+#[derive(Clone, Debug)]
+pub struct DelegatedAccount<C: Chain> {
+    /// The EOA address that may have delegation
+    pub eoa_address: Address,
+    /// The chain this account operates on
+    pub chain: C,
+}
+
+impl<C: Chain> DelegatedAccount<C> {
+    /// Create a new delegated account from an EOA address and chain
+    pub fn new(eoa_address: Address, chain: C) -> Self {
+        Self { eoa_address, chain }
+    }
+
+    /// Check if the EOA has EIP-7702 delegation to the minimal account implementation
+    pub async fn is_minimal_account(&self) -> Result<bool, EngineError> {
+        // Get the bytecode at the EOA address using eth_getCode
+        let code = self
+            .chain
+            .provider()
+            .get_code_at(self.eoa_address)
+            .await
+            .map_err(|e| e.to_engine_error(self.chain()))?;
+
+        tracing::debug!(
+            eoa_address = ?self.eoa_address,
+            code_length = code.len(),
+            code_hex = ?alloy::hex::encode(&code),
+            "Checking EIP-7702 delegation"
+        );
+
+        // Check if code exists and starts with EIP-7702 delegation prefix "0xef0100"
+        if code.len() < EIP_7702_DELEGATION_CODE_LENGTH
+            || !code.starts_with(&EIP_7702_DELEGATION_PREFIX)
+        {
+            tracing::debug!(
+                eoa_address = ?self.eoa_address,
+                has_delegation = false,
+                reason = "Code too short or doesn't start with EIP-7702 prefix",
+                "EIP-7702 delegation check result"
+            );
+            return Ok(false);
+        }
+
+        // Extract the target address from bytes 3-23 (20 bytes for address)
+        // EIP-7702 format: 0xef0100 + 20 bytes address
+        let target_bytes = &code[3..23];
+        let target_address = Address::from_slice(target_bytes);
+
+        // Compare with the minimal account implementation address
+        let is_delegated = target_address == MINIMAL_ACCOUNT_IMPLEMENTATION_ADDRESS;
+
+        tracing::debug!(
+            eoa_address = ?self.eoa_address,
+            target_address = ?target_address,
+            minimal_account_address = ?MINIMAL_ACCOUNT_IMPLEMENTATION_ADDRESS,
+            has_delegation = is_delegated,
+            "EIP-7702 delegation check result"
+        );
+
+        Ok(is_delegated)
+    }
+
+    /// Get the EOA address
+    pub fn address(&self) -> Address {
+        self.eoa_address
+    }
+
+    /// Get the current nonce for the EOA
+    pub async fn get_nonce(&self) -> Result<u64, EngineError> {
+        self.chain
+            .provider()
+            .get_transaction_count(self.eoa_address)
+            .await
+            .map_err(|e| e.to_engine_error(self.chain()))
+    }
+
+    /// Get a reference to the chain
+    pub fn chain(&self) -> &C {
+        &self.chain
+    }
+
+    /// Sign authorization for EIP-7702 delegation (automatically fetches nonce)
+    pub async fn sign_authorization(
+        &self,
+        eoa_signer: &EoaSigner,
+        credentials: &SigningCredential,
+    ) -> Result<alloy::eips::eip7702::SignedAuthorization, EngineError> {
+        let nonce = self.get_nonce().await?;
+
+        let signing_options = EoaSigningOptions {
+            from: self.eoa_address,
+            chain_id: Some(self.chain.chain_id()),
+        };
+
+        eoa_signer
+            .sign_authorization(
+                signing_options,
+                self.chain.chain_id(),
+                MINIMAL_ACCOUNT_IMPLEMENTATION_ADDRESS,
+                nonce,
+                credentials,
+            )
+            .await
+    }
+
+    /// Generate a random UID for wrapped calls
+    pub fn generate_random_uid() -> FixedBytes<32> {
+        let mut rng = rand::rng();
+        let mut bytes = [0u8; 32];
+        rng.fill(&mut bytes);
+        FixedBytes::from(bytes)
+    }
+}

eip7702-core/src/delegated_account.rs

@@ -0,0 +1,3 @@
+pub mod constants;
+pub mod delegated_account;
+pub mod transaction;