@pimlico/alto 0.0.18 → 0.0.20

package/esm/executor/executorManager.js

@@ -1,46 +1,34 @@
-import { EntryPointV06Abi } from "../types/index.js";
-import { getAAError, getBundleStatus, parseUserOperationReceipt, scaleBigIntByPercent } from "../utils/index.js";
-import { TransactionReceiptNotFoundError, getAbiItem, InsufficientFundsError, NonceTooLowError } from "viem";
-import { BaseError } from "abitype";
+import { scaleBigIntByPercent } from "../utils/index.js";
 import { getUserOpHashes } from "./utils.js";
-function getTransactionsFromUserOperationEntries(submittedOps) {
-    const transactionInfos = submittedOps.map((userOpInfo) => userOpInfo.transactionInfo);
-    // Remove duplicates
-    return Array.from(new Set(transactionInfos));
-}
-const MIN_INTERVAL = 100; // 0.1 seconds (100ms)
-const MAX_INTERVAL = 1000; // Capped at 1 second (1000ms)
-const SCALE_FACTOR = 10; // Interval increases by 5ms per task per minute
+const SCALE_FACTOR = 10; // Interval increases by 10ms per task per minute
 const RPM_WINDOW = 60000; // 1 minute window in ms
 export class ExecutorManager {
     senderManager;
     config;
     executor;
     mempool;
-    monitor;
     logger;
     metrics;
-    reputationManager;
-    unWatch;
-    currentlyHandlingBlock = false;
     gasPriceManager;
-    eventManager;
+    bundleManager;
     opsCount = [];
     bundlingMode;
-    constructor({ config, executor, mempool, monitor, reputationManager, metrics, gasPriceManager, eventManager, senderManager }) {
+    unWatch;
+    currentlyHandlingBlock = false;
+    constructor({ config, executor, mempool, metrics, gasPriceManager, senderManager, bundleManager }) {
         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.bundlingMode = this.config.bundleMode;
+        this.bundleManager = bundleManager;
+    }
+    start() {
         if (this.bundlingMode === "auto") {
             this.autoScalingBundling();
         }
@@ -48,7 +36,7 @@ export class ExecutorManager {
     async setBundlingMode(bundleMode) {
         this.bundlingMode = bundleMode;
         if (bundleMode === "manual") {
-            await new Promise((resolve) => setTimeout(resolve, 2 * MAX_INTERVAL));
+            await new Promise((resolve) => setTimeout(resolve, 2 * this.config.maxBundleInterval));
         }
         if (bundleMode === "auto") {
             this.autoScalingBundling();
@@ -57,40 +45,65 @@ export class ExecutorManager {
     async autoScalingBundling() {
         const now = Date.now();
         this.opsCount = this.opsCount.filter((timestamp) => now - timestamp < RPM_WINDOW);
-        const bundles = await this.mempool.getBundles();
+        const bundles = await this.mempool.getBundles(this.config.maxBundleCount);
         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
-            await Promise.all(bundles.map(async (bundle) => {
-                await this.sendBundleToExecutor(bundle);
-            }));
+            // Count total ops and add timestamps
+            const totalOps = bundles.reduce((sum, bundle) => sum + bundle.userOps.length, 0);
+            this.opsCount.push(...new 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
-        const nextInterval = Math.min(MIN_INTERVAL + rpm * SCALE_FACTOR, // Linear scaling
-        MAX_INTERVAL // Cap at 1000ms
+        const nextInterval = Math.min(this.config.minBundleInterval + rpm * SCALE_FACTOR, // Linear scaling
+        this.config.maxBundleInterval // Cap at configured max interval
         );
         if (this.bundlingMode === "auto") {
             setTimeout(this.autoScalingBundling.bind(this), nextInterval);
         }
     }
-    // Debug endpoint
-    async sendBundleNow() {
-        const bundles = await this.mempool.getBundles(1);
-        const bundle = bundles[0];
-        if (bundles.length === 0 || bundle.userOps.length === 0) {
+    startWatchingBlocks() {
+        if (this.unWatch) {
             return;
         }
-        const txHash = await this.sendBundleToExecutor(bundle);
-        if (!txHash) {
-            throw new Error("no tx hash");
+        // If preconfirmationTime is set, poll at intervals instead of watching blocks
+        if (this.config.flashblocksPreconfirmationTime) {
+            // Set up interval to call handleBlock
+            const intervalId = setInterval(async () => {
+                try {
+                    await this.handleBlock();
+                }
+                catch (err) {
+                    this.logger.error({ err }, "error while polling blocks");
+                }
+            }, this.config.flashblocksPreconfirmationTime);
+            // Store cleanup function
+            this.unWatch = () => {
+                clearInterval(intervalId);
+            };
+        }
+        else {
+            // Default behavior - watch blocks
+            this.unWatch = this.config.publicClient.watchBlocks({
+                onBlock: async (block) => {
+                    await this.handleBlock(block);
+                },
+                onError: (err) => {
+                    this.logger.error({ err }, "error while watching blocks");
+                },
+                includeTransactions: false,
+                emitMissed: false
+            });
+        }
+        this.logger.debug("started watching blocks");
+    }
+    async getBaseFee() {
+        if (this.config.legacyTransactions) {
+            return 0n;
         }
-        return txHash;
+        return await this.gasPriceManager.getBaseFee();
     }
     async sendBundleToExecutor(userOpBundle) {
         const { entryPoint, userOps, version } = userOpBundle;
@@ -98,8 +111,9 @@ export class ExecutorManager {
             return undefined;
         }
         const wallet = await this.senderManager.getWallet();
-        const [gasPriceParams, nonce] = await Promise.all([
+        const [gasPriceParams, baseFee, nonce] = await Promise.all([
             this.gasPriceManager.tryGetNetworkGasPrice(),
+            this.getBaseFee(),
             this.config.publicClient.getTransactionCount({
                 address: wallet.address,
                 blockTag: "latest"
@@ -108,571 +122,332 @@ 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({
             executor: wallet,
             userOpBundle,
-            nonce,
-            gasPriceParams,
-            isReplacementTx: false
+            networkGasPrice: gasPriceParams,
+            networkBaseFee: baseFee,
+            nonce
         });
-        // Free wallet if no bundle was sent.
-        if (bundleResult.status !== "bundle_success") {
+        if (!bundleResult.success) {
+            const { rejectedUserOps, recoverableOps, reason } = bundleResult;
+            // Recover any userOps that can be resubmitted.
+            await this.mempool.resubmitUserOps({
+                userOps: recoverableOps,
+                entryPoint,
+                reason
+            });
+            // For rejected userOps, we need to check for frontruns
+            const shouldCheckFrontrun = rejectedUserOps.some(({ reason }) => reason.includes("AA25 invalid account nonce") ||
+                reason.includes("AA10 sender already constructed"));
+            if (shouldCheckFrontrun) {
+                // Check each rejected userOp for frontrun or included
+                const results = await Promise.all(rejectedUserOps.map(async (userOpInfo) => ({
+                    userOpInfo,
+                    status: await this.bundleManager.getUserOpStatus({
+                        userOpInfo,
+                        entryPoint,
+                        bundlerTxs: [],
+                        blockReceivedTimestamp: Date.now()
+                    })
+                })));
+                // Drop userOps that were rejected but not frontrun or included
+                const notFoundUserOps = results
+                    .filter(({ status }) => status === "not_found")
+                    .map(({ userOpInfo }) => userOpInfo);
+                await this.mempool.dropUserOps(entryPoint, notFoundUserOps);
+                // Stop tracking userOps that were included onchain either due to frontrun or included
+                const confirmedUserOps = results
+                    .filter(({ status }) => ["frontran", "included"].includes(status))
+                    .map(({ userOpInfo }) => userOpInfo);
+                await this.mempool.removeProcessing({
+                    entryPoint,
+                    userOps: confirmedUserOps
+                });
+            }
+            else {
+                this.logger.warn({ reason }, "failed to send bundle transaction");
+                await this.mempool.dropUserOps(entryPoint, rejectedUserOps);
+            }
+            // Free wallet as no bundle was sent.
             await this.senderManager.markWalletProcessed(wallet);
-        }
-        // All ops failed simulation, drop them and return.
-        if (bundleResult.status === "all_ops_failed_simulation") {
-            const { rejectedUserOps } = bundleResult;
-            await this.dropUserOps(entryPoint, rejectedUserOps);
-            return undefined;
-        }
-        // Unhandled error during simulation, drop all ops.
-        if (bundleResult.status === "unhandled_simulation_failure") {
-            const { rejectedUserOps } = bundleResult;
-            await this.dropUserOps(entryPoint, rejectedUserOps);
-            this.metrics.bundlesSubmitted.labels({ status: "failed" }).inc();
-            return undefined;
-        }
-        // Resubmit if executor has insufficient funds.
-        if (bundleResult.status === "bundle_submission_failure" &&
-            bundleResult.reason instanceof InsufficientFundsError) {
-            const { reason, userOpsToBundle, rejectedUserOps } = bundleResult;
-            await this.dropUserOps(entryPoint, rejectedUserOps);
-            await this.resubmitUserOperations(userOpsToBundle, entryPoint, reason.name);
-            this.metrics.bundlesSubmitted.labels({ status: "resubmit" }).inc();
-            return undefined;
-        }
-        // Encountered unhandled error during bundle simulation.
-        if (bundleResult.status === "bundle_submission_failure") {
-            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 simulation");
-            this.metrics.bundlesSubmitted.labels({ status: "failed" }).inc();
+            this.metrics.userOpsSubmitted
+                .labels({ status: "failed" })
+                .inc(rejectedUserOps.length);
+            if (reason === "filterops_failed" || reason === "generic_error") {
+                this.metrics.bundlesSubmitted.labels({ status: "failed" }).inc();
+            }
             return undefined;
         }
-        if (bundleResult.status === "bundle_success") {
-            const { userOpsBundled, rejectedUserOps, transactionRequest, transactionHash } = bundleResult;
-            const transactionInfo = {
-                executor: wallet,
-                transactionHash,
-                transactionRequest,
-                bundle: {
-                    entryPoint,
-                    version,
-                    userOps: userOpsBundled
-                },
-                previousTransactionHashes: [],
-                lastReplaced: Date.now(),
-                firstSubmitted: Date.now(),
-                timesPotentiallyIncluded: 0
-            };
-            await this.markUserOperationsAsSubmitted(userOpsBundled, transactionInfo);
-            await this.dropUserOps(entryPoint, rejectedUserOps);
-            this.metrics.bundlesSubmitted.labels({ status: "success" }).inc();
-            return transactionHash;
-        }
-        return undefined;
-    }
-    startWatchingBlocks(handleBlock) {
-        if (this.unWatch) {
-            return;
-        }
-        this.unWatch = this.config.publicClient.watchBlocks({
-            onBlock: handleBlock,
-            onError: (error) => {
-                this.logger.error({ error }, "error while watching blocks");
+        // 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 = {
+            uid: transactionHash,
+            executor: wallet,
+            transactionHash,
+            transactionRequest,
+            bundle: {
+                entryPoint,
+                version,
+                userOps: userOpsBundled,
+                submissionAttempts: 1
             },
-            emitMissed: false,
-            includeTransactions: false,
-            pollingInterval: this.config.pollingInterval
+            previousTransactionHashes: [],
+            lastReplaced: Date.now()
+        };
+        // Track bundle and start loop to watch blocks
+        this.bundleManager.trackBundle(submittedBundle);
+        this.startWatchingBlocks();
+        await this.mempool.markUserOpsAsSubmitted({
+            userOps: submittedBundle.bundle.userOps,
+            transactionHash: submittedBundle.transactionHash
         });
-        this.logger.debug("started watching blocks");
+        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;
-        // TODO: there has to be a better way of solving onchain AA95 errors.
-        if (bundlingStatus.status === "reverted" && bundlingStatus.isAA95) {
-            // resubmit with more gas when bundler encounters AA95
-            transactionInfo.transactionRequest.gas = scaleBigIntByPercent(transactionInfo.transactionRequest.gas, this.config.aa95GasMultiplier);
-            transactionInfo.transactionRequest.nonce += 1;
-            await this.replaceTransaction(transactionInfo, "AA95");
-            return;
-        }
-        // 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
-                            });
-                            await 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
-                            });
-                            await 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.config.publicClient.getBlockNumber();
-            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(block) {
         if (this.currentlyHandlingBlock) {
             return;
         }
         this.currentlyHandlingBlock = true;
-        this.logger.debug({ blockNumber: block.number }, "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) {
+        const blockReceivedTimestamp = Date.now();
+        const pendingBundles = this.bundleManager.getPendingBundles();
+        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 gasPriceParameters = await this.gasPriceManager
-            .tryGetNetworkGasPrice()
-            .catch(() => ({
-            maxFeePerGas: 0n,
-            maxPriorityFeePerGas: 0n
-        }));
-        const transactionInfos = getTransactionsFromUserOperationEntries(await dumpSubmittedEntries());
-        await Promise.all(transactionInfos.map(async (txInfo) => {
-            const { transactionRequest } = txInfo;
-            const { maxFeePerGas, maxPriorityFeePerGas } = transactionRequest;
-            const isMaxFeeTooLow = maxFeePerGas < gasPriceParameters.maxFeePerGas;
-            const isPriorityFeeTooLow = maxPriorityFeePerGas <
-                gasPriceParameters.maxPriorityFeePerGas;
-            const isStuck = Date.now() - txInfo.lastReplaced >
-                this.config.resubmitStuckTimeout;
-            if (isMaxFeeTooLow || isPriorityFeeTooLow) {
-                await this.replaceTransaction(txInfo, "gas_price");
-                return;
+        const [bundleStatuses, networkGasPrice, networkBaseFee] = await Promise.all([
+            this.bundleManager.getBundleStatuses(pendingBundles),
+            this.gasPriceManager.tryGetNetworkGasPrice().catch(() => ({
+                maxFeePerGas: 0n,
+                maxPriorityFeePerGas: 0n
+            })),
+            this.getBaseFee().catch(() => 0n)
+        ]);
+        await Promise.all(bundleStatuses.map(async (bundleStatus, index) => {
+            if (bundleStatus.status === "included") {
+                await this.bundleManager.processIncludedBundle({
+                    submittedBundle: pendingBundles[index],
+                    bundleReceipt: bundleStatus,
+                    blockReceivedTimestamp
+                });
+            }
+            if (bundleStatus.status === "reverted") {
+                await this.bundleManager.processRevertedBundle({
+                    blockReceivedTimestamp,
+                    submittedBundle: pendingBundles[index],
+                    bundleReceipt: bundleStatus,
+                    block
+                });
             }
-            if (isStuck) {
-                await this.replaceTransaction(txInfo, "stuck");
-                return;
+            // can be potentially resubmitted - so we first submit it again to optimize for the speed
+            if (bundleStatus.status === "not_found") {
+                this.potentiallyResubmitBundle({
+                    blockReceivedTimestamp,
+                    submittedBundle: pendingBundles[index],
+                    networkGasPrice,
+                    networkBaseFee
+                });
             }
         }));
         this.currentlyHandlingBlock = false;
     }
-    async replaceTransaction(txInfo, reason) {
-        // Setup vars
-        const { bundle, executor, transactionRequest, transactionHash: oldTxHash } = txInfo;
-        const { userOps, entryPoint } = bundle;
-        const gasPriceParameters = await this.gasPriceManager
-            .tryGetNetworkGasPrice()
-            .catch((_) => {
-            return undefined;
-        });
-        if (!gasPriceParameters) {
-            const rejectedUserOps = userOps.map((userOpInfo) => ({
-                ...userOpInfo,
-                reason: "Failed to get network gas price during replacement"
-            }));
-            await this.failedToReplaceTransaction({
-                entryPoint,
-                rejectedUserOps,
-                oldTxHash,
-                reason: "Failed to get network gas price during replacement"
+    potentiallyResubmitBundle({ blockReceivedTimestamp, submittedBundle, networkGasPrice, networkBaseFee }) {
+        const { transactionRequest, lastReplaced } = submittedBundle;
+        const { maxFeePerGas, maxPriorityFeePerGas } = transactionRequest;
+        const isGasPriceTooLow = maxFeePerGas < networkGasPrice.maxFeePerGas ||
+            maxPriorityFeePerGas < networkGasPrice.maxPriorityFeePerGas;
+        const isStuck = Date.now() - lastReplaced > this.config.resubmitStuckTimeout;
+        if (isGasPriceTooLow) {
+            this.bundleManager.stopTrackingBundle(submittedBundle);
+            this.replaceTransaction({
+                blockReceivedTimestamp,
+                submittedBundle,
+                networkGasPrice,
+                networkBaseFee,
+                reason: "gas_price"
             });
-            // Free executor if failed to get initial params.
-            await this.senderManager.markWalletProcessed(txInfo.executor);
-            return;
         }
+        else if (isStuck) {
+            this.bundleManager.stopTrackingBundle(submittedBundle);
+            this.replaceTransaction({
+                blockReceivedTimestamp,
+                submittedBundle,
+                networkGasPrice,
+                networkBaseFee,
+                reason: "stuck"
+            });
+        }
+    }
+    async cancelBundle(submittedBundle) {
+        const { bundle: { userOps }, executor, transactionRequest, transactionHash } = submittedBundle;
+        const { walletClients, publicClient, blockTime } = this.config;
+        const walletClient = walletClients.public;
+        const logger = this.logger.child({
+            userOps: getUserOpHashes(userOps)
+        });
+        let gasMultiplier = 150n; // Start with 50% increase
+        for (let attempt = 0; attempt < 5; attempt++) {
+            try {
+                // Check if transaction is still pending
+                const currentNonce = await publicClient.getTransactionCount({
+                    address: executor.address,
+                    blockTag: "latest"
+                });
+                if (currentNonce > transactionRequest.nonce) {
+                    logger.info("Transaction already mined or cancelled");
+                    return;
+                }
+                logger.info(`Trying to cancel bundle, attempt ${attempt + 1}`);
+                // Send cancel transaction with increasing gas price
+                const cancelTxHash = await walletClient.sendTransaction({
+                    account: executor,
+                    to: executor.address,
+                    value: 0n,
+                    nonce: transactionRequest.nonce,
+                    maxFeePerGas: scaleBigIntByPercent(transactionRequest.maxFeePerGas, gasMultiplier),
+                    maxPriorityFeePerGas: scaleBigIntByPercent(transactionRequest.maxPriorityFeePerGas, gasMultiplier)
+                });
+                logger.info({
+                    originalTxHash: transactionHash,
+                    cancelTxHash,
+                    attempt: attempt + 1
+                }, "cancel transaction sent");
+                // Wait for transaction to potentially be mined
+                await new Promise((resolve) => setTimeout(resolve, blockTime / 2));
+            }
+            catch (err) {
+                logger.warn({ err }, "failed to cancel bundle");
+                gasMultiplier += 20n; // Increase gas by additional 20% each retry
+            }
+        }
+        // All retries exhausted
+        logger.error({ transactionHash }, "failed to cancel bundle after max retries");
+    }
+    async replaceTransaction({ blockReceivedTimestamp, submittedBundle, networkGasPrice, networkBaseFee, reason }) {
+        const { bundle, executor, transactionRequest, transactionHash: oldTxHash } = submittedBundle;
+        const { entryPoint } = bundle;
         const bundleResult = await this.executor.bundle({
             executor: executor,
+            networkGasPrice,
+            networkBaseFee,
             userOpBundle: bundle,
-            nonce: transactionRequest.nonce,
-            gasPriceParams: {
-                maxFeePerGas: scaleBigIntByPercent(gasPriceParameters.maxFeePerGas, 115n),
-                maxPriorityFeePerGas: scaleBigIntByPercent(gasPriceParameters.maxPriorityFeePerGas, 115n)
-            },
-            gasLimitSuggestion: transactionRequest.gas,
-            isReplacementTx: true
+            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 !== "bundle_success") {
-            await this.senderManager.markWalletProcessed(txInfo.executor);
-        }
-        // Check if the transaction is potentially included.
-        const nonceTooLow = bundleResult.status === "bundle_submission_failure" &&
-            bundleResult.reason instanceof NonceTooLowError;
-        const allOpsFailedSimulation = bundleResult.status === "all_ops_failed_simulation" &&
-            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 === "bundle_success":
-                    return "replaced";
-                default:
-                    return "failed";
-            }
-        })();
-        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 === "unhandled_simulation_failure") {
-            const { rejectedUserOps, reason } = bundleResult;
-            await this.failedToReplaceTransaction({
-                entryPoint,
-                oldTxHash,
-                reason,
-                rejectedUserOps
-            });
-            return;
-        }
-        if (bundleResult.status === "all_ops_failed_simulation") {
-            await this.failedToReplaceTransaction({
+        // Handle case where no bundle was sent.
+        if (!bundleResult.success) {
+            const { rejectedUserOps, recoverableOps, reason } = bundleResult;
+            // Recover any userOps that can be resubmitted.
+            await this.mempool.resubmitUserOps({
+                userOps: recoverableOps,
                 entryPoint,
-                oldTxHash,
-                reason: "all ops failed simulation",
-                rejectedUserOps: bundleResult.rejectedUserOps
-            });
-            return;
-        }
-        if (bundleResult.status === "bundle_submission_failure") {
-            const { reason, rejectedUserOps } = bundleResult;
-            const submissionFailureReason = reason instanceof BaseError ? reason.name : "INTERNAL FAILURE";
-            await this.failedToReplaceTransaction({
-                oldTxHash,
-                rejectedUserOps,
-                reason: submissionFailureReason,
-                entryPoint
+                reason
             });
+            // For rejected userOps, we need to check for frontruns
+            const shouldCheckFrontrun = rejectedUserOps.some(({ reason }) => reason.includes("AA25 invalid account nonce") ||
+                reason.includes("AA10 sender already constructed"));
+            if (shouldCheckFrontrun) {
+                // Check each rejected userOp for frontrun or included
+                const results = await Promise.all(rejectedUserOps.map(async (userOpInfo) => ({
+                    userOpInfo,
+                    status: await this.bundleManager.getUserOpStatus({
+                        userOpInfo,
+                        entryPoint,
+                        bundlerTxs: [
+                            submittedBundle.transactionHash,
+                            ...submittedBundle.previousTransactionHashes
+                        ],
+                        blockReceivedTimestamp
+                    })
+                })));
+                const hasFrontrun = results.some(({ status }) => status === "frontran");
+                // If one userOp in the bundle was frontrun, we need to cancel the entire bundle
+                // as it will fail onchain
+                if (hasFrontrun) {
+                    await this.cancelBundle(submittedBundle);
+                }
+                // Drop userOps that were rejected but not frontrun or included
+                const notFoundUserOps = results
+                    .filter(({ status }) => status === "not_found")
+                    .map(({ userOpInfo }) => userOpInfo);
+                await this.mempool.dropUserOps(entryPoint, notFoundUserOps);
+                // Stop tracking userOps that were included onchain either due to frontrun or included
+                const confirmedUserOps = results
+                    .filter(({ status }) => ["frontran", "included"].includes(status))
+                    .map(({ userOpInfo }) => userOpInfo);
+                await this.mempool.removeProcessing({
+                    entryPoint,
+                    userOps: confirmedUserOps
+                });
+            }
+            else {
+                this.logger.warn({ oldTxHash, reason }, "failed to replace transaction");
+                await this.mempool.dropUserOps(entryPoint, rejectedUserOps);
+            }
+            // Free wallet as no bundle was sent.
+            await this.senderManager.markWalletProcessed(executor);
+            this.metrics.replacedTransactions
+                .labels({ reason, status: "failed" })
+                .inc();
             return;
         }
+        // Success case
         const { rejectedUserOps, userOpsBundled, transactionRequest: newTransactionRequest, transactionHash: newTxHash } = bundleResult;
-        const userOpsReplaced = userOpsBundled;
+        // Increment submission attempts for all replaced userOps
+        const userOpsReplaced = userOpsBundled.map((userOpInfo) => ({
+            ...userOpInfo,
+            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: {
-                ...txInfo.bundle,
-                userOps: userOpsReplaced
+                ...bundle,
+                userOps: userOpsReplaced,
+                submissionAttempts: bundle.submissionAttempts + 1
             }
         };
-        await Promise.all(userOpsReplaced.map(async (userOpInfo) => {
-            await this.mempool.replaceSubmitted({
-                userOpInfo,
-                transactionInfo: newTxInfo
-            });
-        }));
+        // Track bundle and start loop to watch blocks
+        this.bundleManager.trackBundle(newTxInfo);
+        this.startWatchingBlocks();
         // Drop all userOperations that were rejected during simulation.
-        await this.dropUserOps(entryPoint, rejectedUserOps);
+        await this.mempool.dropUserOps(entryPoint, rejectedUserOps);
         this.logger.info({
             oldTxHash,
             newTxHash,
             reason
         }, "replaced transaction");
-        return;
-    }
-    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 } = userOpInfo;
-            const opDetails = userOperationDetails[userOpHash];
-            const firstSubmitted = userOpInfo.addedToMempool;
-            this.metrics.userOperationInclusionDuration.observe((Date.now() - firstSubmitted) / 1000);
-            await this.mempool.removeSubmitted({ entryPoint, userOpHash });
-            this.reputationManager.updateUserOperationIncludedStatus(userOp, entryPoint, opDetails.accountDeployed);
-            if (opDetails.status === "succesful") {
-                await this.eventManager.emitIncludedOnChain(userOpHash, transactionHash, blockNumber);
-            }
-            else {
-                await 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 });
-            await this.eventManager.emitDropped(userOpHash, reason, getAAError(reason));
-            await this.monitor.setUserOperationStatus(userOpHash, {
-                status: "rejected",
-                transactionHash: null
-            });
-            this.logger.warn({
-                userOperation: JSON.stringify(userOp, (_k, v) => typeof v === "bigint" ? v.toString() : v),
-                userOpHash,
-                reason
-            }, "user operation rejected");
-            this.metrics.userOperationsSubmitted
-                .labels({ status: "failed" })
-                .inc();
-        }));
+        this.metrics.replacedTransactions
+            .labels({ reason, status: "success" })
+            .inc();
     }
 }
 //# sourceMappingURL=executorManager.js.map