add eoa transaction batching using 7702 (#26)

* add eoa transaction batching using 7702

- Implemented `calldata_for_self_execution` method in the `MinimalAccountTransaction` struct to facilitate self-execution of transactions.
- Added `moka` for caching in the execution router for authorization cache

* cleanup

* fix error message

Author: d4mr

Cargo.lock

@@ -221,6 +221,14 @@ impl<C: Chain> MinimalAccountTransaction<C> {
         Ok((wrapped_calls_json, signature))
     }
 
+    pub fn calldata_for_self_execution(&self) -> Vec<u8> {
+        let calls = self.wrapped_calls.calls.clone();
+
+        let execute_call = executeCall { calls };
+
+        execute_call.abi_encode()
+    }
+
     /// Execute the transaction directly via bundler client
     /// This builds the transaction and calls tw_execute on the bundler
     pub async fn execute(

eip7702-core/src/transaction.rs

@@ -42,3 +42,5 @@ utoipa-axum = "0.2.0"
 utoipa-scalar = { version = "0.3.0", features = ["axum"] }
 serde_with = "3.14.0"
 aws-arn = "0.3.1"
+moka = { version = "0.12.10", features = ["future"] }
+engine-eip7702-core = { path = "../eip7702-core" }

server/Cargo.toml

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use alloy::primitives::U256;
+use alloy::primitives::{Address, U256};
 use engine_aa_core::smart_account::{DeterminedSmartAccount, SmartAccount, SmartAccountFromSalt};
 use engine_core::{
     chain::{ChainService, RpcCredentials},
@@ -13,6 +13,7 @@ use engine_core::{
     },
     transaction::InnerTransaction,
 };
+use engine_eip7702_core::delegated_account::DelegatedAccount;
 use engine_executors::{
     eip7702_executor::{
         confirm::Eip7702ConfirmationHandler,
@@ -50,6 +51,13 @@ pub struct ExecutionRouter {
     pub transaction_registry: Arc<TransactionRegistry>,
     pub vault_client: Arc<VaultClient>,
     pub chains: Arc<ThirdwebChainService>,
+    pub authorization_cache: moka::future::Cache<AuthorizationCacheKey, bool>,
+}
+
+#[derive(Hash, Eq, PartialEq)]
+pub struct AuthorizationCacheKey {
+    eoa_address: Address,
+    chain_id: u64,
 }
 
 impl ExecutionRouter {
@@ -391,14 +399,53 @@ impl ExecutionRouter {
         transactions: &[InnerTransaction],
         rpc_credentials: RpcCredentials,
         signing_credential: SigningCredential,
-    ) -> Result<(), TwmqError> {
-        if transactions.len() != 1 {
-            return Err(TwmqError::Runtime {
-                message: "EOA execution currently supports only single transactions".to_string(),
-            });
-        }
+    ) -> Result<(), EngineError> {
+        let chain = self
+            .chains
+            .get_chain(base_execution_options.chain_id)
+            .map_err(|e| EngineError::InternalError {
+                message: format!("Failed to get chain: {}", e),
+            })?;
+
+        let transaction = if transactions.len() > 1 {
+            let delegated_account = DelegatedAccount::new(eoa_execution_options.from, chain);
+            let is_minimal_account = self
+                .authorization_cache
+                .try_get_with(
+                    AuthorizationCacheKey {
+                        eoa_address: eoa_execution_options.from,
+                        chain_id: base_execution_options.chain_id,
+                    },
+                    delegated_account.is_minimal_account(),
+                )
+                .await;
+
+            let is_minimal_account =
+                is_minimal_account.map_err(|e| EngineError::InternalError {
+                    message: format!("Failed to check 7702 delegation: {:?}", e),
+                })?;
+
+            if !is_minimal_account {
+                return Err(EngineError::ValidationError {
+                    message: "EOA is not a 7702 delegated account. Batching transactions requires 7702 delegation. Please send a 7702 transaction first to upgrade the EOA.".to_string(),
+                });
+            }
+
+            let calldata = delegated_account
+                .owner_transaction(transactions)
+                .calldata_for_self_execution();
+
+            InnerTransaction {
+                to: Some(eoa_execution_options.from),
+                data: calldata.into(),
+                gas_limit: None,
+                transaction_type_data: None,
+                value: U256::ZERO,
+            }
+        } else {
+            transactions[0].clone()
+        };
 
-        let transaction = &transactions[0];
         let eoa_transaction_request = EoaTransactionRequest {
             transaction_id: base_execution_options.idempotency_key.clone(),
             chain_id: base_execution_options.chain_id,

server/src/execution_router/mod.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::{sync::Arc, time::Duration};
 
 use engine_core::{signer::EoaSigner, userop::UserOpSigner};
 use thirdweb_core::{abi::ThirdwebAbiServiceBuilder, auth::ThirdwebAuth, iaw::IAWClient};
@@ -77,6 +77,11 @@ async fn main() -> anyhow::Result<()> {
     let execution_router = ExecutionRouter {
         namespace: config.queue.execution_namespace.clone(),
         redis: redis_client.get_connection_manager().await?,
+        authorization_cache: moka::future::Cache::builder()
+            .max_capacity(1024 * 1024 * 1024)
+            .time_to_live(Duration::from_secs(60 * 5))
+            .time_to_idle(Duration::from_secs(60))
+            .build(),
         webhook_queue: queue_manager.webhook_queue.clone(),
         external_bundler_send_queue: queue_manager.external_bundler_send_queue.clone(),
         userop_confirm_queue: queue_manager.userop_confirm_queue.clone(),