@pimlico/alto 0.0.0-main.20250203T212650 → 0.0.0-main.20250205T142138

package/esm/executor/executor.js

@@ -1,25 +1,20 @@
-import { EntryPointV06Abi, EntryPointV07Abi } from "../types/index.js";
-import { getRequiredPrefund, getUserOperationHash, isVersion06, maxBigInt, parseViemError, scaleBigIntByPercent, toPackedUserOperation } from "../utils/index.js";
+import { maxBigInt, parseViemError, scaleBigIntByPercent } from "../utils/index.js";
 import * as sentry from "@sentry/node";
-import { Mutex } from "async-mutex";
-import { FeeCapTooLowError, InsufficientFundsError, IntrinsicGasTooLowError, NonceTooLowError, TransactionExecutionError, encodeFunctionData, getContract, BaseError, NonceTooHighError } from "viem";
-import { filterOpsAndEstimateGas, flushStuckTransaction, simulatedOpsToResults, isTransactionUnderpricedError, getAuthorizationList } from "./utils.js";
+import { IntrinsicGasTooLowError, NonceTooLowError, TransactionExecutionError, NonceTooHighError, BaseError } from "viem";
+import { calculateAA95GasFloor, encodeHandleOpsCalldata, getAuthorizationList, getUserOpHashes, isTransactionUnderpricedError } from "./utils.js";
 import { sendPflConditional } from "./fastlane.js";
+import { filterOpsAndEstimateGas } from "./filterOpsAndEStimateGas.js";
 export class Executor {
-    // private unWatch: WatchBlocksReturnType | undefined
     config;
-    senderManager;
     logger;
     metrics;
     reputationManager;
     gasPriceManager;
-    mutex;
     mempool;
     eventManager;
-    constructor({ config, mempool, senderManager, reputationManager, metrics, gasPriceManager, eventManager }) {
+    constructor({ config, mempool, reputationManager, metrics, gasPriceManager, eventManager }) {
         this.config = config;
         this.mempool = mempool;
-        this.senderManager = senderManager;
         this.reputationManager = reputationManager;
         this.logger = config.getLogger({ module: "executor" }, {
             level: config.executorLogLevel || config.logLevel
@@ -27,243 +22,23 @@ export class Executor {
         this.metrics = metrics;
         this.gasPriceManager = gasPriceManager;
         this.eventManager = eventManager;
-        this.mutex = new Mutex();
     }
     cancelOps(_entryPoint, _ops) {
         throw new Error("Method not implemented.");
     }
-    markWalletProcessed(executor) {
-        if (!this.senderManager.availableWallets.includes(executor)) {
-            this.senderManager.pushWallet(executor);
-        }
-        return Promise.resolve();
-    }
-    async replaceTransaction(transactionInfo) {
-        const newRequest = { ...transactionInfo.transactionRequest };
-        let gasPriceParameters;
-        try {
-            gasPriceParameters =
-                await this.gasPriceManager.tryGetNetworkGasPrice();
-        }
-        catch (err) {
-            this.logger.error({ error: err }, "Failed to get network gas price");
-            this.markWalletProcessed(transactionInfo.executor);
-            return { status: "failed" };
-        }
-        newRequest.maxFeePerGas = scaleBigIntByPercent(gasPriceParameters.maxFeePerGas, 115n);
-        newRequest.maxPriorityFeePerGas = scaleBigIntByPercent(gasPriceParameters.maxPriorityFeePerGas, 115n);
-        newRequest.account = transactionInfo.executor;
-        const opsWithHashes = transactionInfo.userOperationInfos.map((opInfo) => {
-            const op = opInfo.userOperation;
-            return {
-                userOperation: opInfo.userOperation,
-                userOperationHash: getUserOperationHash(op, transactionInfo.entryPoint, this.config.walletClient.chain.id),
-                entryPoint: opInfo.entryPoint
-            };
+    async sendHandleOpsTransaction({ txParam, gasOpts }) {
+        const { isUserOpV06, entryPoint, userOps } = txParam;
+        const handleOpsCalldata = encodeHandleOpsCalldata({
+            userOps,
+            beneficiary: txParam.account.address
         });
-        const [isUserOpVersion06, entryPoint] = opsWithHashes.reduce((acc, owh) => {
-            if (acc[0] !== isVersion06(owh.userOperation) ||
-                acc[1] !== owh.entryPoint) {
-                throw new Error("All user operations must be of the same version");
-            }
-            return acc;
-        }, [
-            isVersion06(opsWithHashes[0].userOperation),
-            opsWithHashes[0].entryPoint
-        ]);
-        const ep = getContract({
-            abi: isUserOpVersion06 ? EntryPointV06Abi : EntryPointV07Abi,
-            address: entryPoint,
-            client: {
-                public: this.config.publicClient,
-                wallet: this.config.walletClient
-            }
-        });
-        let { simulatedOps, gasLimit } = await filterOpsAndEstimateGas(transactionInfo.entryPoint, ep, transactionInfo.executor, opsWithHashes, newRequest.nonce, newRequest.maxFeePerGas, newRequest.maxPriorityFeePerGas, this.config.blockTagSupport ? "latest" : undefined, this.config.legacyTransactions, this.config.fixedGasLimitForEstimation, this.reputationManager, this.logger);
-        const childLogger = this.logger.child({
-            transactionHash: transactionInfo.transactionHash,
-            executor: transactionInfo.executor.address
-        });
-        if (simulatedOps.length === 0) {
-            childLogger.warn("no ops to bundle");
-            this.markWalletProcessed(transactionInfo.executor);
-            return { status: "failed" };
-        }
-        if (simulatedOps.every((op) => op.reason === "AA25 invalid account nonce" ||
-            op.reason === "AA10 sender already constructed")) {
-            childLogger.trace({ reasons: simulatedOps.map((sop) => sop.reason) }, "all ops failed simulation with nonce error");
-            return { status: "potentially_already_included" };
-        }
-        if (simulatedOps.every((op) => op.reason !== undefined)) {
-            childLogger.warn("all ops failed simulation");
-            this.markWalletProcessed(transactionInfo.executor);
-            return { status: "failed" };
-        }
-        const opsToBundle = simulatedOps
-            .filter((op) => op.reason === undefined)
-            .map((op) => {
-            const opInfo = transactionInfo.userOperationInfos.find((info) => info.userOperationHash === op.owh.userOperationHash);
-            if (!opInfo) {
-                throw new Error("opInfo not found");
-            }
-            return opInfo;
-        });
-        if (this.config.localGasLimitCalculation) {
-            gasLimit = opsToBundle.reduce((acc, opInfo) => {
-                const userOperation = opInfo.userOperation;
-                return (acc +
-                    userOperation.preVerificationGas +
-                    3n * userOperation.verificationGasLimit +
-                    userOperation.callGasLimit);
-            }, 0n);
-        }
-        // https://github.com/eth-infinitism/account-abstraction/blob/fa61290d37d079e928d92d53a122efcc63822214/contracts/core/EntryPoint.sol#L236
-        let innerHandleOpFloor = 0n;
-        for (const owh of opsToBundle) {
-            const op = owh.userOperation;
-            innerHandleOpFloor +=
-                op.callGasLimit + op.verificationGasLimit + 5000n;
-        }
-        if (gasLimit < innerHandleOpFloor) {
-            gasLimit += innerHandleOpFloor;
-        }
-        // sometimes the estimation rounds down, adding a fixed constant accounts for this
-        gasLimit += 10000n;
-        // ensures that we don't submit again with too low of a gas value
-        newRequest.gas = maxBigInt(newRequest.gas, gasLimit);
-        // update calldata to include only ops that pass simulation
-        let txParam;
-        const userOps = opsToBundle.map((op) => isUserOpVersion06
-            ? op.userOperation
-            : toPackedUserOperation(op.userOperation));
-        txParam = {
-            isUserOpVersion06,
-            isReplacementTx: true,
-            ops: userOps,
-            entryPoint: transactionInfo.entryPoint
-        };
-        try {
-            childLogger.info({
-                newRequest: {
-                    ...newRequest,
-                    abi: undefined,
-                    chain: undefined
-                },
-                executor: newRequest.account.address,
-                opsToBundle: opsToBundle.map((opInfo) => opInfo.userOperationHash)
-            }, "replacing transaction");
-            const txHash = await this.sendHandleOpsTransaction({
-                txParam,
-                opts: this.config.legacyTransactions
-                    ? {
-                        account: newRequest.account,
-                        gasPrice: newRequest.maxFeePerGas,
-                        gas: newRequest.gas,
-                        nonce: newRequest.nonce
-                    }
-                    : {
-                        account: newRequest.account,
-                        maxFeePerGas: newRequest.maxFeePerGas,
-                        maxPriorityFeePerGas: newRequest.maxPriorityFeePerGas,
-                        gas: newRequest.gas,
-                        nonce: newRequest.nonce
-                    }
-            });
-            opsToBundle.map(({ entryPoint, userOperation }) => {
-                const chainId = this.config.publicClient.chain?.id;
-                const opHash = getUserOperationHash(userOperation, entryPoint, chainId);
-                this.eventManager.emitSubmitted(opHash, txHash);
-            });
-            const newTxInfo = {
-                ...transactionInfo,
-                transactionRequest: newRequest,
-                transactionHash: txHash,
-                previousTransactionHashes: [
-                    transactionInfo.transactionHash,
-                    ...transactionInfo.previousTransactionHashes
-                ],
-                lastReplaced: Date.now(),
-                userOperationInfos: opsToBundle.map((opInfo) => {
-                    return {
-                        entryPoint: opInfo.entryPoint,
-                        userOperation: opInfo.userOperation,
-                        userOperationHash: opInfo.userOperationHash,
-                        lastReplaced: Date.now(),
-                        firstSubmitted: opInfo.firstSubmitted
-                    };
-                })
-            };
-            return {
-                status: "replaced",
-                transactionInfo: newTxInfo
-            };
-        }
-        catch (err) {
-            const e = parseViemError(err);
-            if (!e) {
-                sentry.captureException(err);
-                childLogger.error({ error: err }, "unknown error replacing transaction");
-            }
-            if (e instanceof NonceTooLowError) {
-                childLogger.trace({ error: e }, "nonce too low, potentially already included");
-                return { status: "potentially_already_included" };
-            }
-            if (e instanceof FeeCapTooLowError) {
-                childLogger.warn({ error: e }, "fee cap too low, not replacing");
-            }
-            if (e instanceof InsufficientFundsError) {
-                childLogger.warn({ error: e }, "insufficient funds, not replacing");
-            }
-            if (e instanceof IntrinsicGasTooLowError) {
-                childLogger.warn({ error: e }, "intrinsic gas too low, not replacing");
-            }
-            childLogger.warn({ error: e }, "error replacing transaction");
-            this.markWalletProcessed(transactionInfo.executor);
-            return { status: "failed" };
-        }
-    }
-    async flushStuckTransactions() {
-        const allWallets = new Set(this.senderManager.wallets);
-        const utilityWallet = this.senderManager.utilityAccount;
-        if (utilityWallet) {
-            allWallets.add(utilityWallet);
-        }
-        const wallets = Array.from(allWallets);
-        let gasPrice;
-        try {
-            gasPrice = await this.gasPriceManager.tryGetNetworkGasPrice();
-        }
-        catch (e) {
-            this.logger.error({ error: e }, "error flushing stuck transaction");
-            return;
-        }
-        const promises = wallets.map((wallet) => {
-            try {
-                flushStuckTransaction(this.config.publicClient, this.config.walletClient, wallet, gasPrice.maxFeePerGas * 5n, this.logger);
-            }
-            catch (e) {
-                this.logger.error({ error: e }, "error flushing stuck transaction");
-            }
-        });
-        await Promise.all(promises);
-    }
-    async sendHandleOpsTransaction({ txParam, opts }) {
-        let data;
-        let to;
-        const { isUserOpVersion06, ops, entryPoint } = txParam;
-        data = encodeFunctionData({
-            abi: isUserOpVersion06 ? EntryPointV06Abi : EntryPointV07Abi,
-            functionName: "handleOps",
-            args: [ops, opts.account.address]
-        });
-        to = entryPoint;
         const request = await this.config.walletClient.prepareTransactionRequest({
-            to,
-            data,
-            ...opts
+            to: entryPoint,
+            data: handleOpsCalldata,
+            ...txParam,
+            ...gasOpts
         });
         request.gas = scaleBigIntByPercent(request.gas, this.config.executorGasMultiplier);
-        let isTransactionUnderPriced = false;
         let attempts = 0;
         let transactionHash;
         const maxAttempts = 3;
@@ -271,7 +46,7 @@ export class Executor {
         while (attempts < maxAttempts) {
             try {
                 if (this.config.enableFastlane &&
-                    isUserOpVersion06 &&
+                    isUserOpV06 &&
                     !txParam.isReplacementTx &&
                     attempts === 0) {
                     const serializedTransaction = await this.config.walletClient.signTransaction(request);
@@ -288,13 +63,11 @@ export class Executor {
                 break;
             }
             catch (e) {
-                isTransactionUnderPriced = false;
                 if (e instanceof BaseError) {
                     if (isTransactionUnderpricedError(e)) {
                         this.logger.warn("Transaction underpriced, retrying");
                         request.maxFeePerGas = scaleBigIntByPercent(request.maxFeePerGas, 150n);
                         request.maxPriorityFeePerGas = scaleBigIntByPercent(request.maxPriorityFeePerGas, 150n);
-                        isTransactionUnderPriced = true;
                     }
                 }
                 const error = e;
@@ -320,286 +93,153 @@ export class Executor {
                         await new Promise((resolve) => setTimeout(resolve, 500));
                     }
                 }
+                attempts++;
                 if (attempts === maxAttempts) {
                     throw error;
                 }
-                attempts++;
             }
         }
-        if (isTransactionUnderPriced) {
-            await this.handleTransactionUnderPriced({
-                nonce: request.nonce,
-                executor: request.account
-            });
-        }
         // needed for TS
         if (!transactionHash) {
             throw new Error("Transaction hash not assigned");
         }
         return transactionHash;
     }
-    // Occurs when tx was sent with conflicting nonce, we want to resubmit all conflicting ops
-    async handleTransactionUnderPriced({ nonce, executor }) {
-        const submitted = this.mempool.dumpSubmittedOps();
-        const conflictingOps = submitted
-            .filter((submitted) => {
-            const tx = submitted.transactionInfo;
-            return (tx.executor.address === executor.address &&
-                tx.transactionRequest.nonce === nonce);
-        })
-            .map(({ userOperation }) => userOperation);
-        conflictingOps.map((op) => {
-            this.logger.info(`Resubmitting ${op.userOperationHash} due to transaction underpriced`);
-            this.mempool.removeSubmitted(op.userOperationHash);
-            this.mempool.add(op.userOperation, op.entryPoint);
-        });
-        if (conflictingOps.length > 0) {
-            this.markWalletProcessed(executor);
-        }
-    }
-    async bundle(entryPoint, ops) {
-        const wallet = await this.senderManager.getWallet();
-        const opsWithHashes = ops.map((userOperation) => {
-            return {
-                userOperation,
-                userOperationHash: getUserOperationHash(userOperation, entryPoint, this.config.walletClient.chain.id)
-            };
-        });
-        const isUserOpVersion06 = opsWithHashes.reduce((acc, op) => {
-            if (acc !== isVersion06(op.userOperation)) {
-                throw new Error("All user operations must be of the same version");
-            }
-            return acc;
-        }, isVersion06(opsWithHashes[0].userOperation));
-        const ep = getContract({
-            abi: isUserOpVersion06 ? EntryPointV06Abi : EntryPointV07Abi,
-            address: entryPoint,
-            client: {
-                public: this.config.publicClient,
-                wallet: this.config.walletClient
-            }
-        });
+    async bundle({ executor, userOpBundle, nonce, gasPriceParams, gasLimitSuggestion, isReplacementTx }) {
+        const { entryPoint, userOps, version } = userOpBundle;
+        const { maxFeePerGas, maxPriorityFeePerGas } = gasPriceParams;
+        const isUserOpV06 = version === "0.6";
         let childLogger = this.logger.child({
-            userOperations: opsWithHashes.map((oh) => oh.userOperationHash),
+            isReplacementTx,
+            userOperations: getUserOpHashes(userOps),
             entryPoint
         });
-        childLogger.debug("bundling user operation");
-        // These calls can throw, so we try/catch them to mark wallet as processed in event of error.
-        let nonce;
-        let gasPriceParameters;
-        try {
-            ;
-            [gasPriceParameters, nonce] = await Promise.all([
-                this.gasPriceManager.tryGetNetworkGasPrice(),
-                this.config.publicClient.getTransactionCount({
-                    address: wallet.address,
-                    blockTag: "pending"
-                })
-            ]);
-        }
-        catch (err) {
-            childLogger.error({ error: err }, "Failed to get parameters for bundling");
-            this.markWalletProcessed(wallet);
-            return opsWithHashes.map((owh) => {
-                return {
-                    status: "resubmit",
-                    info: {
-                        entryPoint,
-                        userOpHash: owh.userOperationHash,
-                        userOperation: owh.userOperation,
-                        reason: "Failed to get parameters for bundling"
-                    }
-                };
-            });
-        }
-        let { gasLimit, simulatedOps } = await filterOpsAndEstimateGas(entryPoint, ep, wallet, opsWithHashes, nonce, gasPriceParameters.maxFeePerGas, gasPriceParameters.maxPriorityFeePerGas, this.config.blockTagSupport ? "pending" : undefined, this.config.legacyTransactions, this.config.fixedGasLimitForEstimation, this.reputationManager, childLogger, getAuthorizationList(opsWithHashes.map(({ userOperation }) => userOperation)));
-        if (simulatedOps.length === 0) {
+        let estimateResult = await filterOpsAndEstimateGas({
+            userOpBundle,
+            executor,
+            nonce,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+            reputationManager: this.reputationManager,
+            config: this.config,
+            logger: childLogger
+        });
+        if (estimateResult.status === "unhandled_failure") {
             childLogger.error("gas limit simulation encountered unexpected failure");
-            this.markWalletProcessed(wallet);
-            return opsWithHashes.map((owh) => {
-                return {
-                    status: "failure",
-                    error: {
-                        entryPoint,
-                        userOpHash: owh.userOperationHash,
-                        userOperation: owh.userOperation,
-                        reason: "INTERNAL FAILURE"
-                    }
-                };
-            });
+            return {
+                status: "unhandled_simulation_failure",
+                rejectedUserOps: estimateResult.rejectedUserOps,
+                reason: "INTERNAL FAILURE"
+            };
         }
-        if (simulatedOps.every((op) => op.reason !== undefined)) {
+        if (estimateResult.status === "all_ops_failed_simulation") {
             childLogger.warn("all ops failed simulation");
-            this.markWalletProcessed(wallet);
-            return simulatedOps.map(({ reason, owh }) => {
-                return {
-                    status: "failure",
-                    error: {
-                        entryPoint,
-                        userOpHash: owh.userOperationHash,
-                        userOperation: owh.userOperation,
-                        reason: reason
-                    }
-                };
-            });
+            return {
+                status: "all_ops_failed_simulation",
+                rejectedUserOps: estimateResult.rejectedUserOps
+            };
         }
-        const opsWithHashToBundle = simulatedOps
-            .filter((op) => op.reason === undefined)
-            .map((op) => op.owh);
+        let { gasLimit, userOpsToBundle, rejectedUserOps } = estimateResult;
+        // Update child logger with userOperations being sent for bundling.
         childLogger = this.logger.child({
-            userOperations: opsWithHashToBundle.map((owh) => owh.userOperationHash),
+            isReplacementTx,
+            userOperations: getUserOpHashes(userOpsToBundle),
             entryPoint
         });
-        // https://github.com/eth-infinitism/account-abstraction/blob/fa61290d37d079e928d92d53a122efcc63822214/contracts/core/EntryPoint.sol#L236
-        let innerHandleOpFloor = 0n;
-        let totalBeneficiaryFees = 0n;
-        for (const owh of opsWithHashToBundle) {
-            const op = owh.userOperation;
-            innerHandleOpFloor +=
-                op.callGasLimit + op.verificationGasLimit + 5000n;
-            totalBeneficiaryFees += getRequiredPrefund(op);
-        }
-        if (gasLimit < innerHandleOpFloor) {
-            gasLimit += innerHandleOpFloor;
+        // Ensure that we don't submit with gas too low leading to AA95.
+        const aa95GasFloor = calculateAA95GasFloor(userOpsToBundle);
+        if (gasLimit < aa95GasFloor) {
+            gasLimit += aa95GasFloor;
         }
         // sometimes the estimation rounds down, adding a fixed constant accounts for this
         gasLimit += 10000n;
-        childLogger.debug({ gasLimit }, "got gas limit");
+        gasLimit = gasLimitSuggestion
+            ? maxBigInt(gasLimit, gasLimitSuggestion)
+            : gasLimit;
         let transactionHash;
         try {
             const isLegacyTransaction = this.config.legacyTransactions;
-            if (this.config.noProfitBundling) {
-                const gasPrice = totalBeneficiaryFees / gasLimit;
-                if (isLegacyTransaction) {
-                    gasPriceParameters.maxFeePerGas = gasPrice;
-                    gasPriceParameters.maxPriorityFeePerGas = gasPrice;
-                }
-                else {
-                    gasPriceParameters.maxFeePerGas = maxBigInt(gasPrice, gasPriceParameters.maxFeePerGas || 0n);
-                }
-            }
-            const authorizationList = getAuthorizationList(opsWithHashToBundle.map(({ userOperation }) => userOperation));
-            let opts;
+            const authorizationList = getAuthorizationList(userOpsToBundle);
+            const { maxFeePerGas, maxPriorityFeePerGas } = gasPriceParams;
+            let gasOpts;
             if (isLegacyTransaction) {
-                opts = {
+                gasOpts = {
                     type: "legacy",
-                    gasPrice: gasPriceParameters.maxFeePerGas,
-                    account: wallet,
-                    gas: gasLimit,
-                    nonce
+                    gasPrice: maxFeePerGas
                 };
             }
             else if (authorizationList) {
-                opts = {
+                gasOpts = {
                     type: "eip7702",
-                    maxFeePerGas: gasPriceParameters.maxFeePerGas,
-                    maxPriorityFeePerGas: gasPriceParameters.maxPriorityFeePerGas,
-                    account: wallet,
-                    gas: gasLimit,
-                    nonce,
+                    maxFeePerGas,
+                    maxPriorityFeePerGas,
                     authorizationList
                 };
             }
             else {
-                opts = {
+                gasOpts = {
                     type: "eip1559",
-                    maxFeePerGas: gasPriceParameters.maxFeePerGas,
-                    maxPriorityFeePerGas: gasPriceParameters.maxPriorityFeePerGas,
-                    account: wallet,
-                    gas: gasLimit,
-                    nonce
+                    maxFeePerGas,
+                    maxPriorityFeePerGas
                 };
             }
-            const userOps = opsWithHashToBundle.map(({ userOperation }) => {
-                if (isUserOpVersion06) {
-                    return userOperation;
-                }
-                return toPackedUserOperation(userOperation);
-            });
             transactionHash = await this.sendHandleOpsTransaction({
                 txParam: {
-                    ops: userOps,
-                    isReplacementTx: false,
-                    isUserOpVersion06,
+                    account: executor,
+                    nonce,
+                    gas: gasLimit,
+                    userOps: userOpsToBundle,
+                    isReplacementTx,
+                    isUserOpV06,
                     entryPoint
                 },
-                opts
+                gasOpts
             });
-            opsWithHashToBundle.map(({ userOperationHash }) => {
-                this.eventManager.emitSubmitted(userOperationHash, transactionHash);
+            this.eventManager.emitSubmitted({
+                userOpHashes: getUserOpHashes(userOpsToBundle),
+                transactionHash
             });
         }
         catch (err) {
             const e = parseViemError(err);
-            if (e instanceof InsufficientFundsError) {
-                childLogger.error({ error: e }, "insufficient funds, not submitting transaction");
-                this.markWalletProcessed(wallet);
-                return opsWithHashToBundle.map((owh) => {
-                    return {
-                        status: "resubmit",
-                        info: {
-                            entryPoint,
-                            userOpHash: owh.userOperationHash,
-                            userOperation: owh.userOperation,
-                            reason: InsufficientFundsError.name
-                        }
-                    };
-                });
-            }
-            sentry.captureException(err);
-            childLogger.error({ error: JSON.stringify(err) }, "error submitting bundle transaction");
-            this.markWalletProcessed(wallet);
-            return opsWithHashes.map((owh) => {
+            const { rejectedUserOps, userOpsToBundle } = estimateResult;
+            // if unknown error, return INTERNAL FAILURE
+            if (!e) {
+                sentry.captureException(err);
+                childLogger.error({ error: JSON.stringify(err) }, "error submitting bundle transaction");
                 return {
-                    status: "failure",
-                    error: {
-                        entryPoint,
-                        userOpHash: owh.userOperationHash,
-                        userOperation: owh.userOperation,
-                        reason: "INTERNAL FAILURE"
-                    }
+                    rejectedUserOps,
+                    userOpsToBundle,
+                    status: "bundle_submission_failure",
+                    reason: "INTERNAL FAILURE"
                 };
-            });
-        }
-        const userOperationInfos = opsWithHashToBundle.map((op) => {
+            }
             return {
-                entryPoint,
-                userOperation: op.userOperation,
-                userOperationHash: op.userOperationHash,
-                lastReplaced: Date.now(),
-                firstSubmitted: Date.now()
+                rejectedUserOps,
+                userOpsToBundle,
+                status: "bundle_submission_failure",
+                reason: e
             };
-        });
-        const transactionInfo = {
-            entryPoint,
-            isVersion06: isUserOpVersion06,
-            transactionHash: transactionHash,
-            previousTransactionHashes: [],
+        }
+        const userOpsBundled = userOpsToBundle;
+        const bundleResult = {
+            status: "bundle_success",
+            userOpsBundled,
+            rejectedUserOps,
+            transactionHash,
             transactionRequest: {
-                account: wallet,
-                to: ep.address,
                 gas: gasLimit,
-                chain: this.config.walletClient.chain,
-                maxFeePerGas: gasPriceParameters.maxFeePerGas,
-                maxPriorityFeePerGas: gasPriceParameters.maxPriorityFeePerGas,
-                nonce: nonce
-            },
-            executor: wallet,
-            userOperationInfos,
-            lastReplaced: Date.now(),
-            firstSubmitted: Date.now(),
-            timesPotentiallyIncluded: 0
+                maxFeePerGas: gasPriceParams.maxFeePerGas,
+                maxPriorityFeePerGas: gasPriceParams.maxPriorityFeePerGas,
+                nonce
+            }
         };
-        const userOperationResults = simulatedOpsToResults(simulatedOps, transactionInfo);
         childLogger.info({
-            transactionRequest: {
-                ...transactionInfo.transactionRequest,
-                abi: undefined
-            },
+            transactionRequest: bundleResult.transactionRequest,
             txHash: transactionHash,
-            opHashes: opsWithHashToBundle.map((owh) => owh.userOperationHash)
+            opHashes: getUserOpHashes(userOpsBundled)
         }, "submitted bundle transaction");
-        return userOperationResults;
+        return bundleResult;
     }
 }
 //# sourceMappingURL=executor.js.map