@pimlico/alto 0.0.0-main.20250620T170042 → 0.0.0-main.20250622T171316

package/esm/executor/executorManager.js

@@ -1,13 +1,3 @@
-import { EntryPointV06Abi } from "../types/index.js";
-import { getAAError, getBundleStatus, parseUserOperationReceipt, jsonStringifyWithBigint } from "../utils/index.js";
-import { TransactionReceiptNotFoundError, getAbiItem, NonceTooLowError } from "viem";
-import { BaseError } from "abitype";
-import { getUserOpHashes } from "./utils.js";
-function getTransactionsFromUserOperationEntries(submittedOps) {
-    const transactionInfos = submittedOps.map((userOpInfo) => userOpInfo.transactionInfo);
-    // Remove duplicates
-    return Array.from(new Set(transactionInfos));
-}
 const SCALE_FACTOR = 10; // Interval increases by 10ms per task per minute
 const RPM_WINDOW = 60000; // 1 minute window in ms
 export class ExecutorManager {
@@ -15,47 +5,26 @@ export class ExecutorManager {
     config;
     executor;
     mempool;
-    monitor;
     logger;
     metrics;
-    reputationManager;
-    unWatch;
     gasPriceManager;
-    eventManager;
     opsCount = [];
     bundlingMode;
-    cachedLatestBlock = null;
-    blockCacheTTL;
+    userOpMonitor;
+    unWatch;
     currentlyHandlingBlock = false;
-    async getLatestBlockWithCache() {
-        const now = Date.now();
-        if (this.cachedLatestBlock &&
-            now - this.cachedLatestBlock.timestamp < this.blockCacheTTL) {
-            // Use cached block number if it's still valid
-            this.logger.debug("Using cached block number");
-            return this.cachedLatestBlock.value;
-        }
-        // Otherwise fetch a new block number and cache it
-        const latestBlock = await this.config.publicClient.getBlockNumber();
-        this.cachedLatestBlock = { value: latestBlock, timestamp: now };
-        this.logger.debug("Fetched and cached new block number");
-        return latestBlock;
-    }
-    constructor({ config, executor, mempool, monitor, reputationManager, metrics, gasPriceManager, eventManager, senderManager }) {
+    constructor({ config, executor, mempool, metrics, gasPriceManager, senderManager, userOpMonitor }) {
         this.config = config;
-        this.reputationManager = reputationManager;
         this.executor = executor;
         this.mempool = mempool;
-        this.monitor = monitor;
         this.logger = config.getLogger({ module: "executor_manager" }, {
             level: config.executorLogLevel || config.logLevel
         });
         this.metrics = metrics;
         this.gasPriceManager = gasPriceManager;
-        this.eventManager = eventManager;
         this.senderManager = senderManager;
-        this.blockCacheTTL = config.blockNumberCacheTtl;
         this.bundlingMode = this.config.bundleMode;
+        this.userOpMonitor = userOpMonitor;
         if (this.bundlingMode === "auto") {
             this.autoScalingBundling();
         }
@@ -74,14 +43,13 @@ export class ExecutorManager {
         this.opsCount = this.opsCount.filter((timestamp) => now - timestamp < RPM_WINDOW);
         const bundles = await this.mempool.getBundles();
         if (bundles.length > 0) {
-            const opsCount = bundles
-                .map(({ userOps }) => userOps.length)
-                .reduce((a, b) => a + b);
-            // Add timestamps for each task
-            const timestamp = Date.now();
-            this.opsCount.push(...Array(opsCount).fill(timestamp));
-            // Send bundles to executor
-            bundles.map((bundle) => this.sendBundleToExecutor(bundle));
+            // Count total ops and add timestamps
+            const totalOps = bundles.reduce((sum, bundle) => sum + bundle.userOps.length, 0);
+            this.opsCount.push(...Array(totalOps).fill(Date.now()));
+        }
+        // Send bundles to executor
+        for (const bundle of bundles) {
+            this.sendBundleToExecutor(bundle);
         }
         const rpm = this.opsCount.length;
         // Calculate next interval with linear scaling
@@ -92,12 +60,14 @@ export class ExecutorManager {
             setTimeout(this.autoScalingBundling.bind(this), nextInterval);
         }
     }
-    startWatchingBlocks(handleBlock) {
+    startWatchingBlocks() {
         if (this.unWatch) {
             return;
         }
         this.unWatch = this.config.publicClient.watchBlockNumber({
-            onBlockNumber: handleBlock,
+            onBlockNumber: async (blockNumber) => {
+                await this.handleBlock(blockNumber);
+            },
             onError: (error) => {
                 this.logger.error({ error }, "error while watching blocks");
             },
@@ -106,19 +76,6 @@ export class ExecutorManager {
         });
         this.logger.debug("started watching blocks");
     }
-    // Debug endpoint
-    async sendBundleNow() {
-        const bundles = await this.mempool.getBundles(1);
-        const bundle = bundles[0];
-        if (bundles.length === 0 || bundle.userOps.length === 0) {
-            return;
-        }
-        const txHash = await this.sendBundleToExecutor(bundle);
-        if (!txHash) {
-            throw new Error("no tx hash");
-        }
-        return txHash;
-    }
     async getBaseFee() {
         if (this.config.legacyTransactions) {
             return 0n;
@@ -142,9 +99,13 @@ export class ExecutorManager {
             return [];
         });
         if (!gasPriceParams || nonce === undefined) {
-            await this.resubmitUserOperations(userOps, entryPoint, "Failed to get nonce and gas parameters for bundling");
             // Free executor if failed to get initial params.
             await this.senderManager.markWalletProcessed(wallet);
+            await this.mempool.resubmitUserOps({
+                userOps,
+                entryPoint,
+                reason: "Failed to get nonce and gas parameters for bundling"
+            });
             return undefined;
         }
         const bundleResult = await this.executor.bundle({
@@ -154,426 +115,144 @@ export class ExecutorManager {
             networkBaseFee: baseFee,
             nonce
         });
-        // Free wallet if no bundle was sent.
-        if (bundleResult.status !== "submission_success") {
+        if (!bundleResult.success) {
+            const { rejectedUserOps, recoverableOps, reason } = bundleResult;
+            // Free wallet as no bundle was sent.
             await this.senderManager.markWalletProcessed(wallet);
-        }
-        // All ops failed simulation, drop them and return.
-        if (bundleResult.status === "filterops_all_rejected") {
-            const { rejectedUserOps } = bundleResult;
-            await this.dropUserOps(entryPoint, rejectedUserOps);
-            return undefined;
-        }
-        // Unhandled error during simulation, drop all ops.
-        if (bundleResult.status === "filterops_unhandled_error") {
-            const rejectedUserOps = userOps.map((userOp) => ({
-                ...userOp,
-                reason: "filterOps simulation error"
-            }));
-            await this.dropUserOps(entryPoint, rejectedUserOps);
-            this.metrics.bundlesSubmitted.labels({ status: "failed" }).inc();
-            return undefined;
-        }
-        // Resubmit if executor has insufficient funds.
-        if (bundleResult.status === "submission_insufficient_funds_error") {
-            const { userOpsToBundle, rejectedUserOps } = bundleResult;
-            await this.dropUserOps(entryPoint, rejectedUserOps);
-            await this.resubmitUserOperations(userOpsToBundle, entryPoint, "Executor has insufficient funds");
-            this.metrics.bundlesSubmitted.labels({ status: "resubmit" }).inc();
-            return undefined;
-        }
-        // Encountered unhandled error during bundle submission.
-        if (bundleResult.status === "submission_generic_error") {
-            const { rejectedUserOps, userOpsToBundle, reason } = bundleResult;
-            await this.dropUserOps(entryPoint, rejectedUserOps);
-            // NOTE: these ops passed validation, so we can try resubmitting them
-            await this.resubmitUserOperations(userOpsToBundle, entryPoint, reason instanceof BaseError
-                ? reason.name
-                : "Encountered unhandled error during bundle submission");
-            this.metrics.bundlesSubmitted.labels({ status: "failed" }).inc();
-            return undefined;
-        }
-        if (bundleResult.status === "submission_success") {
-            let { userOpsBundled, rejectedUserOps, transactionRequest, transactionHash } = bundleResult;
-            // Increment submission attempts for all userOps submitted.
-            userOpsBundled = userOpsBundled.map((userOpInfo) => ({
-                ...userOpInfo,
-                submissionAttempts: userOpInfo.submissionAttempts + 1
-            }));
-            const transactionInfo = {
-                executor: wallet,
-                transactionHash,
-                transactionRequest,
-                bundle: {
+            // Drop rejected ops
+            await this.mempool.dropUserOps(entryPoint, rejectedUserOps);
+            this.metrics.userOperationsSubmitted
+                .labels({ status: "failed" })
+                .inc(rejectedUserOps.length);
+            // Handle recoverable ops
+            if (recoverableOps.length) {
+                await this.mempool.resubmitUserOps({
+                    userOps: recoverableOps,
                     entryPoint,
-                    version,
-                    userOps: userOpsBundled,
-                    submissionAttempts: 1
-                },
-                previousTransactionHashes: [],
-                lastReplaced: Date.now(),
-                timesPotentiallyIncluded: 0
-            };
-            await this.markUserOperationsAsSubmitted(userOpsBundled, transactionInfo);
-            await this.dropUserOps(entryPoint, rejectedUserOps);
-            this.metrics.bundlesSubmitted.labels({ status: "success" }).inc();
-            return transactionHash;
+                    reason
+                });
+            }
+            if (reason === "filterops_failed" || reason === "generic_error") {
+                this.metrics.bundlesSubmitted.labels({ status: "failed" }).inc();
+            }
+            return undefined;
         }
-        return undefined;
+        // Success case
+        let { userOpsBundled, rejectedUserOps, transactionRequest, transactionHash } = bundleResult;
+        // Increment submission attempts for all userOps submitted.
+        userOpsBundled = userOpsBundled.map((userOpInfo) => ({
+            ...userOpInfo,
+            submissionAttempts: userOpInfo.submissionAttempts + 1
+        }));
+        const submittedBundle = {
+            executor: wallet,
+            transactionHash,
+            transactionRequest,
+            bundle: {
+                entryPoint,
+                version,
+                userOps: userOpsBundled,
+                submissionAttempts: 1
+            },
+            previousTransactionHashes: [],
+            lastReplaced: Date.now()
+        };
+        this.userOpMonitor.trackBundle(submittedBundle);
+        await this.mempool.markUserOpsAsSubmitted({
+            userOps: submittedBundle.bundle.userOps,
+            entryPoint: submittedBundle.bundle.entryPoint,
+            transactionHash: submittedBundle.transactionHash
+        });
+        // Start watching blocks after marking operations as submitted
+        this.startWatchingBlocks();
+        await this.mempool.dropUserOps(entryPoint, rejectedUserOps);
+        this.metrics.bundlesSubmitted.labels({ status: "success" }).inc();
+        return transactionHash;
     }
     stopWatchingBlocks() {
         if (this.unWatch) {
-            this.logger.debug("stopped watching blocks");
             this.unWatch();
             this.unWatch = undefined;
         }
     }
-    // update the current status of the bundling transaction/s
-    async refreshTransactionStatus(transactionInfo) {
-        const { transactionHash: currentTxhash, bundle, previousTransactionHashes } = transactionInfo;
-        const { userOps, entryPoint } = bundle;
-        const txHashesToCheck = [currentTxhash, ...previousTransactionHashes];
-        const transactionDetails = await Promise.all(txHashesToCheck.map(async (transactionHash) => ({
-            transactionHash,
-            ...(await getBundleStatus({
-                transactionHash,
-                bundle: transactionInfo.bundle,
-                publicClient: this.config.publicClient,
-                logger: this.logger
-            }))
-        })));
-        // first check if bundling txs returns status "mined", if not, check for reverted
-        const mined = transactionDetails.find(({ bundlingStatus }) => bundlingStatus.status === "included");
-        const reverted = transactionDetails.find(({ bundlingStatus }) => bundlingStatus.status === "reverted");
-        const finalizedTransaction = mined ?? reverted;
-        if (!finalizedTransaction) {
-            return;
-        }
-        const { bundlingStatus, transactionHash, blockNumber } = finalizedTransaction;
-        // Free executor if tx landed onchain
-        if (bundlingStatus.status !== "not_found") {
-            await this.senderManager.markWalletProcessed(transactionInfo.executor);
-        }
-        if (bundlingStatus.status === "included") {
-            const { userOperationDetails } = bundlingStatus;
-            await this.markUserOpsIncluded(userOps, entryPoint, blockNumber, transactionHash, userOperationDetails);
-        }
-        if (bundlingStatus.status === "reverted") {
-            await Promise.all(userOps.map(async (userOpInfo) => {
-                const { userOpHash } = userOpInfo;
-                await this.checkFrontrun({
-                    entryPoint,
-                    userOpHash,
-                    transactionHash,
-                    blockNumber
-                });
-            }));
-            await this.removeSubmitted(entryPoint, userOps);
-        }
-    }
-    async checkFrontrun({ userOpHash, entryPoint, transactionHash, blockNumber }) {
-        const unwatch = this.config.publicClient.watchBlockNumber({
-            onBlockNumber: async (currentBlockNumber) => {
-                if (currentBlockNumber > blockNumber + 1n) {
-                    try {
-                        const userOperationReceipt = await this.getUserOperationReceipt(userOpHash);
-                        if (userOperationReceipt) {
-                            const transactionHash = userOperationReceipt.receipt.transactionHash;
-                            const blockNumber = userOperationReceipt.receipt.blockNumber;
-                            await this.mempool.removeSubmitted({
-                                entryPoint,
-                                userOpHash
-                            });
-                            await this.monitor.setUserOperationStatus(userOpHash, {
-                                status: "included",
-                                transactionHash
-                            });
-                            this.eventManager.emitFrontranOnChain(userOpHash, transactionHash, blockNumber);
-                            this.logger.info({
-                                userOpHash,
-                                transactionHash
-                            }, "user op frontrun onchain");
-                            this.metrics.userOperationsOnChain
-                                .labels({ status: "frontran" })
-                                .inc(1);
-                        }
-                        else {
-                            await this.monitor.setUserOperationStatus(userOpHash, {
-                                status: "failed",
-                                transactionHash
-                            });
-                            this.eventManager.emitFailedOnChain(userOpHash, transactionHash, blockNumber);
-                            this.logger.info({
-                                userOpHash,
-                                transactionHash
-                            }, "user op failed onchain");
-                            this.metrics.userOperationsOnChain
-                                .labels({ status: "reverted" })
-                                .inc(1);
-                        }
-                    }
-                    catch (error) {
-                        this.logger.error({
-                            userOpHash,
-                            transactionHash,
-                            error
-                        }, "Error checking frontrun status");
-                        // Still mark as failed since we couldn't verify inclusion
-                        await this.monitor.setUserOperationStatus(userOpHash, {
-                            status: "failed",
-                            transactionHash
-                        });
-                    }
-                    unwatch();
-                }
-            }
-        });
-    }
-    async getUserOperationReceipt(userOperationHash) {
-        const userOperationEventAbiItem = getAbiItem({
-            abi: EntryPointV06Abi,
-            name: "UserOperationEvent"
-        });
-        let fromBlock = undefined;
-        let toBlock = undefined;
-        if (this.config.maxBlockRange !== undefined) {
-            const latestBlock = await this.getLatestBlockWithCache();
-            fromBlock = latestBlock - BigInt(this.config.maxBlockRange);
-            if (fromBlock < 0n) {
-                fromBlock = 0n;
-            }
-            toBlock = "latest";
-        }
-        const filterResult = await this.config.publicClient.getLogs({
-            address: this.config.entrypoints,
-            event: userOperationEventAbiItem,
-            fromBlock,
-            toBlock,
-            args: {
-                userOpHash: userOperationHash
-            }
-        });
-        this.logger.debug({
-            filterResult: filterResult.length,
-            userOperationEvent: filterResult.length === 0
-                ? undefined
-                : filterResult[0].transactionHash
-        }, "filter result length");
-        if (filterResult.length === 0) {
-            return null;
-        }
-        const userOperationEvent = filterResult[0];
-        // throw if any of the members of userOperationEvent are undefined
-        if (userOperationEvent.args.actualGasCost === undefined ||
-            userOperationEvent.args.sender === undefined ||
-            userOperationEvent.args.nonce === undefined ||
-            userOperationEvent.args.userOpHash === undefined ||
-            userOperationEvent.args.success === undefined ||
-            userOperationEvent.args.paymaster === undefined ||
-            userOperationEvent.args.actualGasUsed === undefined) {
-            throw new Error("userOperationEvent has undefined members");
-        }
-        const txHash = userOperationEvent.transactionHash;
-        if (txHash === null) {
-            // transaction pending
-            return null;
-        }
-        const getTransactionReceipt = async (txHash) => {
-            while (true) {
-                try {
-                    const transactionReceipt = await this.config.publicClient.getTransactionReceipt({
-                        hash: txHash
-                    });
-                    let effectiveGasPrice = transactionReceipt.effectiveGasPrice ??
-                        transactionReceipt.gasPrice ??
-                        undefined;
-                    if (effectiveGasPrice === undefined) {
-                        const tx = await this.config.publicClient.getTransaction({
-                            hash: txHash
-                        });
-                        effectiveGasPrice = tx.gasPrice ?? undefined;
-                    }
-                    if (effectiveGasPrice) {
-                        transactionReceipt.effectiveGasPrice = effectiveGasPrice;
-                    }
-                    return transactionReceipt;
-                }
-                catch (e) {
-                    if (e instanceof TransactionReceiptNotFoundError) {
-                        continue;
-                    }
-                    throw e;
-                }
-            }
-        };
-        const receipt = await getTransactionReceipt(txHash);
-        const logs = receipt.logs;
-        if (logs.some((log) => log.blockHash === null ||
-            log.blockNumber === null ||
-            log.transactionIndex === null ||
-            log.transactionHash === null ||
-            log.logIndex === null ||
-            log.topics.length === 0)) {
-            // transaction pending
-            return null;
-        }
-        const userOperationReceipt = parseUserOperationReceipt(userOperationHash, receipt);
-        return userOperationReceipt;
-    }
     async handleBlock(blockNumber) {
-        // Update the cached block number whenever we receive a new block
-        this.cachedLatestBlock = { value: blockNumber, timestamp: Date.now() };
         if (this.currentlyHandlingBlock) {
             return;
         }
         this.currentlyHandlingBlock = true;
-        this.logger.debug({ blockNumber }, "handling block");
-        const dumpSubmittedEntries = async () => {
-            const submittedEntries = [];
-            for (const entryPoint of this.config.entrypoints) {
-                const entries = await this.mempool.dumpSubmittedOps(entryPoint);
-                submittedEntries.push(...entries);
-            }
-            return submittedEntries;
-        };
-        const submittedEntries = await dumpSubmittedEntries();
-        if (submittedEntries.length === 0) {
+        // Process the block and get the results
+        const pendingBundles = await this.userOpMonitor.processBlock(blockNumber);
+        if (pendingBundles.length === 0) {
             this.stopWatchingBlocks();
             this.currentlyHandlingBlock = false;
             return;
         }
-        // refresh op statuses
-        const ops = await dumpSubmittedEntries();
-        const txs = getTransactionsFromUserOperationEntries(ops);
-        await Promise.all(txs.map((txInfo) => this.refreshTransactionStatus(txInfo)));
         // for all still not included check if needs to be replaced (based on gas price)
-        const [gasPriceParams, networkBaseFee] = await Promise.all([
+        const [networkGasPrice, networkBaseFee] = await Promise.all([
             this.gasPriceManager.tryGetNetworkGasPrice().catch(() => ({
                 maxFeePerGas: 0n,
                 maxPriorityFeePerGas: 0n
             })),
             this.getBaseFee().catch(() => 0n)
         ]);
-        const transactionInfos = getTransactionsFromUserOperationEntries(await dumpSubmittedEntries());
-        await Promise.all(transactionInfos.map(async (txInfo) => {
-            const { transactionRequest } = txInfo;
+        await Promise.all(pendingBundles.map(async (submittedBundle) => {
+            const { transactionRequest, lastReplaced } = submittedBundle;
             const { maxFeePerGas, maxPriorityFeePerGas } = transactionRequest;
-            const isMaxFeeTooLow = maxFeePerGas < gasPriceParams.maxFeePerGas;
-            const isPriorityFeeTooLow = maxPriorityFeePerGas < gasPriceParams.maxPriorityFeePerGas;
-            const isStuck = Date.now() - txInfo.lastReplaced >
-                this.config.resubmitStuckTimeout;
-            if (isMaxFeeTooLow || isPriorityFeeTooLow) {
+            const isGasPriceTooLow = maxFeePerGas < networkGasPrice.maxFeePerGas ||
+                maxPriorityFeePerGas < networkGasPrice.maxPriorityFeePerGas;
+            const isStuck = Date.now() - lastReplaced > this.config.resubmitStuckTimeout;
+            if (isGasPriceTooLow) {
                 await this.replaceTransaction({
-                    txInfo,
-                    gasPriceParams,
+                    submittedBundle,
+                    networkGasPrice,
                     networkBaseFee,
                     reason: "gas_price"
                 });
-                return;
             }
-            if (isStuck) {
+            else if (isStuck) {
                 await this.replaceTransaction({
-                    txInfo,
-                    gasPriceParams,
+                    submittedBundle,
+                    networkGasPrice,
                     networkBaseFee,
                     reason: "stuck"
                 });
-                return;
             }
         }));
         this.currentlyHandlingBlock = false;
     }
-    async replaceTransaction({ txInfo, gasPriceParams, networkBaseFee, reason }) {
-        // Setup vars
-        const { bundle, executor, transactionRequest, transactionHash: oldTxHash } = txInfo;
+    async replaceTransaction({ submittedBundle, networkGasPrice, networkBaseFee, reason }) {
+        const { bundle, executor, transactionRequest, transactionHash: oldTxHash } = submittedBundle;
         const { entryPoint } = bundle;
         const bundleResult = await this.executor.bundle({
             executor: executor,
-            networkGasPrice: gasPriceParams,
+            networkGasPrice,
             networkBaseFee,
             userOpBundle: bundle,
             nonce: transactionRequest.nonce
         });
-        // Free wallet and return if potentially included too many times.
-        if (txInfo.timesPotentiallyIncluded >= 3) {
-            this.removeSubmitted(entryPoint, bundle.userOps);
-            this.logger.warn({
-                oldTxHash,
-                userOps: getUserOpHashes(bundleResult.rejectedUserOps)
-            }, "transaction potentially already included too many times, removing");
-            await this.senderManager.markWalletProcessed(txInfo.executor);
-            return;
-        }
-        // Free wallet if no bundle was sent or potentially included.
-        if (bundleResult.status !== "submission_success") {
-            await this.senderManager.markWalletProcessed(txInfo.executor);
-        }
-        // Check if the transaction is potentially included.
-        const nonceTooLow = bundleResult.status === "submission_generic_error" &&
-            bundleResult.reason instanceof NonceTooLowError;
-        const allOpsFailedSimulation = bundleResult.status === "filterops_all_rejected" &&
-            bundleResult.rejectedUserOps.every((op) => op.reason === "AA25 invalid account nonce" ||
-                op.reason === "AA10 sender already constructed");
-        const potentiallyIncluded = nonceTooLow || allOpsFailedSimulation;
-        // log metrics
-        const replaceStatus = (() => {
-            switch (true) {
-                case potentiallyIncluded:
-                    return "potentially_already_included";
-                case bundleResult?.status === "submission_success":
-                    return "replaced";
-                default:
-                    return "failed";
+        // Handle case where no bundle was sent.
+        if (!bundleResult.success) {
+            // Free wallet as no bundle was sent.
+            await this.senderManager.markWalletProcessed(executor);
+            await this.userOpMonitor.stopTrackingBundle(submittedBundle);
+            const { rejectedUserOps, recoverableOps, reason } = bundleResult;
+            this.logger.warn({ oldTxHash, reason }, "failed to replace transaction");
+            // Drop rejected ops
+            await this.mempool.dropUserOps(entryPoint, rejectedUserOps);
+            // Handle recoverable ops
+            if (recoverableOps.length) {
+                await this.mempool.resubmitUserOps({
+                    userOps: recoverableOps,
+                    entryPoint,
+                    reason
+                });
             }
-        })();
-        this.metrics.replacedTransactions
-            .labels({ reason, status: replaceStatus })
-            .inc();
-        if (potentiallyIncluded) {
-            this.logger.info({
-                oldTxHash,
-                userOpHashes: getUserOpHashes(bundleResult.rejectedUserOps)
-            }, "transaction potentially already included");
-            txInfo.timesPotentiallyIncluded += 1;
-            return;
-        }
-        if (bundleResult.status === "filterops_unhandled_error") {
-            const { rejectedUserOps } = bundleResult;
-            await this.failedToReplaceTransaction({
-                entryPoint,
-                oldTxHash,
-                reason: "filterOps simulation error",
-                rejectedUserOps
-            });
-            return;
-        }
-        if (bundleResult.status === "filterops_all_rejected") {
-            await this.failedToReplaceTransaction({
-                entryPoint,
-                oldTxHash,
-                reason: "all ops failed simulation",
-                rejectedUserOps: bundleResult.rejectedUserOps
-            });
-            return;
-        }
-        if (bundleResult.status === "submission_generic_error") {
-            const { reason, rejectedUserOps } = bundleResult;
-            const submissionFailureReason = reason instanceof BaseError ? reason.name : "INTERNAL FAILURE";
-            await this.failedToReplaceTransaction({
-                oldTxHash,
-                rejectedUserOps,
-                reason: submissionFailureReason,
-                entryPoint
-            });
-            return;
-        }
-        if (bundleResult.status === "submission_insufficient_funds_error") {
-            const { userOpsToBundle, rejectedUserOps } = bundleResult;
-            await this.dropUserOps(entryPoint, rejectedUserOps);
-            await this.resubmitUserOperations(userOpsToBundle, entryPoint, "Executor has insufficient funds");
-            this.metrics.bundlesSubmitted.labels({ status: "resubmit" }).inc();
+            this.metrics.replacedTransactions
+                .labels({ reason, status: "failed" })
+                .inc();
             return;
         }
+        // Success case
         const { rejectedUserOps, userOpsBundled, transactionRequest: newTransactionRequest, transactionHash: newTxHash } = bundleResult;
         // Increment submission attempts for all replaced userOps
         const userOpsReplaced = userOpsBundled.map((userOpInfo) => ({
@@ -581,12 +260,12 @@ export class ExecutorManager {
             submissionAttempts: userOpInfo.submissionAttempts + 1
         }));
         const newTxInfo = {
-            ...txInfo,
+            ...submittedBundle,
             transactionRequest: newTransactionRequest,
             transactionHash: newTxHash,
             previousTransactionHashes: [
-                txInfo.transactionHash,
-                ...txInfo.previousTransactionHashes
+                submittedBundle.transactionHash,
+                ...submittedBundle.previousTransactionHashes
             ],
             lastReplaced: Date.now(),
             bundle: {
@@ -595,9 +274,10 @@ export class ExecutorManager {
                 submissionAttempts: bundle.submissionAttempts + 1
             }
         };
-        await this.markUserOperationsAsReplaced(userOpsReplaced, newTxInfo);
+        // Replace existing submitted bundle with new one
+        this.userOpMonitor.trackBundle(newTxInfo);
         // Drop all userOperations that were rejected during simulation.
-        await this.dropUserOps(entryPoint, rejectedUserOps);
+        await this.mempool.dropUserOps(entryPoint, rejectedUserOps);
         this.logger.info({
             oldTxHash,
             newTxHash,
@@ -605,98 +285,5 @@ export class ExecutorManager {
         }, "replaced transaction");
         return;
     }
-    async markUserOperationsAsReplaced(userOpsReplaced, newTxInfo) {
-        // Mark as replaced in mempool
-        await Promise.all(userOpsReplaced.map(async (userOpInfo) => {
-            await this.mempool.replaceSubmitted({
-                userOpInfo,
-                transactionInfo: newTxInfo
-            });
-        }));
-    }
-    async markUserOperationsAsSubmitted(userOpInfos, transactionInfo) {
-        await Promise.all(userOpInfos.map(async (userOpInfo) => {
-            const { userOpHash } = userOpInfo;
-            await this.mempool.markSubmitted({
-                userOpHash,
-                transactionInfo
-            });
-            this.startWatchingBlocks(this.handleBlock.bind(this));
-            this.metrics.userOperationsSubmitted
-                .labels({ status: "success" })
-                .inc();
-        }));
-    }
-    async resubmitUserOperations(userOps, entryPoint, reason) {
-        await Promise.all(userOps.map(async (userOpInfo) => {
-            const { userOpHash, userOp } = userOpInfo;
-            this.logger.warn({
-                userOpHash,
-                reason
-            }, "resubmitting user operation");
-            await this.mempool.removeProcessing({ entryPoint, userOpHash });
-            await this.mempool.add(userOp, entryPoint);
-            this.metrics.userOperationsResubmitted.inc();
-        }));
-    }
-    async failedToReplaceTransaction({ oldTxHash, rejectedUserOps, reason, entryPoint }) {
-        this.logger.warn({ oldTxHash, reason }, "failed to replace transaction");
-        await this.dropUserOps(entryPoint, rejectedUserOps);
-    }
-    async removeSubmitted(entryPoint, userOps) {
-        await Promise.all(userOps.map(async (userOpInfo) => {
-            const { userOpHash } = userOpInfo;
-            await this.mempool.removeSubmitted({ entryPoint, userOpHash });
-        }));
-    }
-    async markUserOpsIncluded(userOps, entryPoint, blockNumber, transactionHash, userOperationDetails) {
-        await Promise.all(userOps.map(async (userOpInfo) => {
-            this.metrics.userOperationsOnChain
-                .labels({ status: "included" })
-                .inc();
-            const { userOpHash, userOp, submissionAttempts } = userOpInfo;
-            const opDetails = userOperationDetails[userOpHash];
-            const firstSubmitted = userOpInfo.addedToMempool;
-            this.metrics.userOperationInclusionDuration.observe((Date.now() - firstSubmitted) / 1000);
-            // Track the number of submission attempts for included ops
-            this.metrics.userOperationsSubmissionAttempts.observe(submissionAttempts);
-            await this.mempool.removeSubmitted({ entryPoint, userOpHash });
-            this.reputationManager.updateUserOperationIncludedStatus(userOp, entryPoint, opDetails.accountDeployed);
-            if (opDetails.status === "succesful") {
-                this.eventManager.emitIncludedOnChain(userOpHash, transactionHash, blockNumber);
-            }
-            else {
-                this.eventManager.emitExecutionRevertedOnChain(userOpHash, transactionHash, opDetails.revertReason || "0x", blockNumber);
-            }
-            await this.monitor.setUserOperationStatus(userOpHash, {
-                status: "included",
-                transactionHash
-            });
-            this.logger.info({
-                opHash: userOpHash,
-                transactionHash
-            }, "user op included");
-        }));
-    }
-    async dropUserOps(entryPoint, rejectedUserOps) {
-        await Promise.all(rejectedUserOps.map(async (rejectedUserOp) => {
-            const { userOp, reason, userOpHash } = rejectedUserOp;
-            await this.mempool.removeProcessing({ entryPoint, userOpHash });
-            await this.mempool.removeSubmitted({ entryPoint, userOpHash });
-            this.eventManager.emitDropped(userOpHash, reason, getAAError(reason));
-            await this.monitor.setUserOperationStatus(userOpHash, {
-                status: "rejected",
-                transactionHash: null
-            });
-            this.logger.warn({
-                userOperation: jsonStringifyWithBigint(userOp),
-                userOpHash,
-                reason
-            }, "user operation rejected");
-            this.metrics.userOperationsSubmitted
-                .labels({ status: "failed" })
-                .inc();
-        }));
-    }
 }
 //# sourceMappingURL=executorManager.js.map