async bundler

Author: d4mr

drizzle/0000_deep_stephen_strange.sql drizzle/0000_broad_blacklash.sqldrizzle/0000_deep_stephen_strange.sql renamed to drizzle/0000_broad_blacklash.sql

@@ -1,5 +1,5 @@
 {
-  "id": "67d61535-ec60-44c0-a6b3-e1aea354e8d3",
+  "id": "5fbb4f8e-28bd-4802-877f-23a45622e6c6",
   "prevId": "00000000-0000-0000-0000-000000000000",
   "version": "7",
   "dialect": "postgresql",

drizzle/meta/0000_snapshot.json

@@ -5,8 +5,8 @@
     {
       "idx": 0,
       "version": "7",
-      "when": 1740357427731,
-      "tag": "0000_deep_stephen_strange",
+      "when": 1740684747056,
+      "tag": "0000_broad_blacklash",
       "breakpoints": true
     }
   ]

drizzle/meta/_journal.json

@@ -40,6 +40,9 @@ export type RevertDataSerialized = {
 };
 
 export type ExecutionResult4337Serialized =
+  | {
+      status: "QUEUED";
+    }
   | {
       status: "SUBMITTED";
       monitoringStatus: "WILL_MONITOR" | "CANNOT_MONITOR";

src/db/types.ts

@@ -8,6 +8,7 @@ import {
   type EngineErr,
 } from "../../lib/errors";
 import { execute as executeExternalBundler } from "../external-bundler";
+import { execute as executeExternalBundlerAsync } from "../external-bundler-async";
 import { getChain } from "../../lib/chain";
 import {
   getContract,
@@ -32,11 +33,13 @@ import SuperJSON from "superjson";
 import type {
   ExecutionParamsSerialized,
   TransactionParamsSerialized,
+  ExecutionResult4337Serialized,
 } from "../../db/types";
 import "./external-bundler-confirm-handler";
+import "./external-bundler-send-handler";
 
 function getExecutionAccountFromRequest(
-  request: EncodedExecutionRequest,
+  request: EncodedExecutionRequest
 ): ResultAsync<
   | {
       signerAccount: Account;
@@ -57,7 +60,7 @@ function getExecutionAccountFromRequest(
         yield* getEngineAccount({
           address: request.from,
           encryptionPassword: request.encryptionPassword,
-        }),
+        })
       );
     }
 
@@ -241,7 +244,7 @@ export function execute({
     const chain = await getChain(Number.parseInt(request.chainId));
 
     const engineAccountResponse = yield* getExecutionAccountFromRequest(
-      request,
+      request
     );
 
     if ("account" in engineAccountResponse) {
@@ -278,26 +281,74 @@ export function execute({
 
     const idempotencyKey = request.idempotencyKey ?? randomUUID().toString();
 
-    const executionResult = await executeExternalBundler({
-      id: idempotencyKey,
-      chain,
-      client,
-      executionOptions,
-      transactionParams: resolvedTransactionParams,
-    });
+    // Determine which executor to use based on request parameters
+    // Currently, we use the async executor when no encryption password is provided
+    // In the future, this can be expanded to support more executor types
+    const executorType = !request.encryptionPassword ? "async" : "sync";
+    
+    // Variables to track execution state
+    let executionResult: ExecutionResult4337Serialized;
+    let userOpHash: string | undefined;
+
+    // Execute using the appropriate executor
+    if (executorType === "async") {
+      // For async executor, we need to convert the execution options to the format it expects
+      const asyncExecutionOptions = {
+        signerAddress: executionOptions.signer.address as Address,
+        entrypointAddress: executionOptions.entrypointAddress,
+        accountFactoryAddress: executionOptions.accountFactoryAddress,
+        sponsorGas: executionOptions.sponsorGas,
+        smartAccountAddress: executionOptions.smartAccountAddress,
+        accountSalt: executionOptions.accountSalt,
+      };
+
+      // Execute using the async executor
+      const asyncResult = await executeExternalBundlerAsync({
+        id: idempotencyKey,
+        executionOptions: asyncExecutionOptions,
+        chainId: request.chainId,
+        transactionParams: resolvedTransactionParams,
+      });
+
+      // Handle errors from the async executor
+      if (asyncResult.isErr()) {
+        return errAsync(asyncResult.error);
+      }
 
-    let userOpHash: Hex;
-    let didConfirmationQueueJobError = false;
+      // Async executor doesn't return userOpHash immediately, it's queued
+      executionResult = {
+        status: "QUEUED",
+      };
+    } else {
+      // Execute using the sync executor
+      const syncResult = await executeExternalBundler({
+        id: idempotencyKey,
+        chain,
+        client,
+        executionOptions,
+        transactionParams: resolvedTransactionParams,
+      });
 
-    if (executionResult.isErr()) {
-      if (executionResult.error.kind === "queue") {
-        didConfirmationQueueJobError = true;
-        userOpHash = executionResult.error.userOpHash;
+      // Handle errors from the sync executor
+      if (syncResult.isErr()) {
+        if (syncResult.error.kind === "queue") {
+          userOpHash = syncResult.error.userOpHash;
+          executionResult = {
+            status: "SUBMITTED",
+            monitoringStatus: "CANNOT_MONITOR",
+            userOpHash,
+          };
+        } else {
+          return errAsync(syncResult.error);
+        }
       } else {
-        return errAsync(executionResult.error);
+        userOpHash = syncResult.value.data.userOpHash;
+        executionResult = {
+          status: "SUBMITTED",
+          monitoringStatus: "WILL_MONITOR",
+          userOpHash,
+        };
       }
-    } else {
-      userOpHash = executionResult.value.data.userOpHash;
     }
 
     const executionParams: ExecutionParamsSerialized = {
@@ -307,13 +358,9 @@ export function execute({
       signerAddress: executionOptions.signer.address,
     };
 
-    const executionResultSerialized = {
-      status: "SUBMITTED" as const,
-      monitoringStatus: didConfirmationQueueJobError
-        ? "CANNOT_MONITOR"
-        : "WILL_MONITOR",
-      userOpHash,
-    } as const;
+    // For database insertion, we need to ensure userOpHash is a string if status is SUBMITTED
+    // If it's undefined, we'll use an empty string
+    const dbExecutionResult = executionResult;
 
     const dbTransactionEntry = yield* ResultAsync.fromPromise(
       db
@@ -325,23 +372,23 @@ export function execute({
           transactionParams: SuperJSON.serialize(resolvedTransactionParams)
             .json as TransactionParamsSerialized[],
           executionParams,
-          executionResult: executionResultSerialized,
+          executionResult: dbExecutionResult,
           from: executionParams.smartAccountAddress as Address,
         })
         .returning(),
-      mapDbError,
+      mapDbError
     ).mapErr((e) =>
       buildTransactionDbEntryErr({
         error: e,
         executionParams,
-        executionResult: executionResultSerialized,
-      }),
+        executionResult: dbExecutionResult,
+      })
     );
 
     return okAsync({
-      executionResult: executionResultSerialized,
+      executionResult,
       transactions: dbTransactionEntry,
       executionOptions,
     });
   });
-}
+}

src/executors/execute/execute.ts

@@ -2,6 +2,7 @@ import SuperJSON from "superjson";
 import { db } from "../../db/connection";
 import { transactions } from "../../db/schema";
 import { registerCallback, type ConfirmationResult } from "../external-bundler";
+import { registerCallback as registerExternalBundlerAsyncConfirmCallback } from "../external-bundler-async";
 import type {
   ExecutionResult4337Serialized,
   RevertDataSerialized,
@@ -10,12 +11,12 @@ import { and, eq } from "drizzle-orm";
 import { initializeLogger } from "../../lib/logger";
 
 const confirmLogger = initializeLogger(
-  "executor:external-bundler:confirm-handler",
+  "executor:external-bundler:confirm-handler"
 );
 
 // not using neverthrow here, this handler response doesn't go to the user
 export async function externalBundlerConfirmHandler(
-  result: ConfirmationResult,
+  result: ConfirmationResult
 ) {
   const executionResult: ExecutionResult4337Serialized =
     result.onchainStatus === "REVERTED"
@@ -57,11 +58,12 @@ export async function externalBundlerConfirmHandler(
       })
       // 4337 transactions always create a single transaction in the db, with batchIndex 0
       .where(
-        and(eq(transactions.id, result.id), eq(transactions.batchIndex, 0)),
+        and(eq(transactions.id, result.id), eq(transactions.batchIndex, 0))
       );
   } catch (err) {
     confirmLogger.error("Failed to write confirmed transaction to DB", err);
   }
 }
 
 registerCallback(externalBundlerConfirmHandler);
+registerExternalBundlerAsyncConfirmCallback(externalBundlerConfirmHandler);

src/executors/execute/external-bundler-confirm-handler.ts

@@ -0,0 +1,43 @@
+import { db } from "../../db/connection";
+import { transactions } from "../../db/schema";
+import { and, eq } from "drizzle-orm";
+import { initializeLogger } from "../../lib/logger";
+import { sendWorker, type SendResult } from "../external-bundler-async";
+import type { Job } from "bullmq";
+
+const sendLogger = initializeLogger(
+  "executor:external-bundler:send-handler"
+);
+
+// This handler is called when a UserOp is sent by the async executor
+// It updates the transaction record with the userOpHash
+export async function externalBundlerSendHandler(
+  _job: Job, // Unused parameter but required by BullMQ
+  result: SendResult
+) {
+  try {
+    await db
+      .update(transactions)
+      .set({
+        executionResult: {
+          status: "SUBMITTED",
+          monitoringStatus: "WILL_MONITOR",
+          userOpHash: result.userOpHash,
+        },
+      })
+      // 4337 transactions always create a single transaction in the db, with batchIndex 0
+      .where(
+        and(eq(transactions.id, result.id), eq(transactions.batchIndex, 0))
+      );
+      
+    sendLogger.info(`Updated transaction ${result.id} with userOpHash ${result.userOpHash}`);
+  } catch (err) {
+    sendLogger.error("Failed to update transaction with userOpHash", err, {
+      id: result.id,
+      userOpHash: result.userOpHash,
+    });
+  }
+}
+
+// Register the send handler with the async executor's send worker
+sendWorker.on("completed", externalBundlerSendHandler);