@pimlico/alto 0.0.0-main.20240607T034324 → 0.0.0-staging.20240606T093925

package/esm/executor/executor.js

@@ -1,643 +0,0 @@
-import { EntryPointV06Abi, EntryPointV07Abi, deriveUserOperation } from "../types/index.js";
-import { getUserOperationHash, isVersion06, maxBigInt, parseViemError, toPackedUserOperation } from "../utils/index.js";
-import * as sentry from "@sentry/node";
-import { Mutex } from "async-mutex";
-import { FeeCapTooLowError, InsufficientFundsError, IntrinsicGasTooLowError, NonceTooLowError, encodeFunctionData, getContract } from "viem";
-import { createCompressedCalldata, filterOpsAndEstimateGas, flushStuckTransaction, simulatedOpsToResults } from "./utils.js";
-export class NullExecutor {
-    bundle(_entryPoint, _ops) {
-        return Promise.resolve([]);
-    }
-    bundleCompressed(_entryPoint, _compressedOps) {
-        return Promise.resolve([]);
-    }
-    replaceTransaction(_entryPoint, _transactionInfo) {
-        return Promise.resolve({ status: "failed" });
-    }
-    replaceOps(_opHashes) {
-        return Promise.resolve();
-    }
-    cancelOps(_entryPoint, _ops) {
-        return Promise.resolve();
-    }
-    markWalletProcessed(_executor) {
-        return Promise.resolve();
-    }
-    flushStuckTransactions() {
-        return Promise.resolve();
-    }
-}
-export class Executor {
-    // private unWatch: WatchBlocksReturnType | undefined
-    publicClient;
-    walletClient;
-    entryPoints;
-    senderManager;
-    logger;
-    metrics;
-    simulateTransaction;
-    legacyTransactions;
-    fixedGasLimitForEstimation;
-    localGasLimitCalculation;
-    reputationManager;
-    compressionHandler;
-    gasPriceManager;
-    mutex;
-    constructor(publicClient, walletClient, senderManager, reputationManager, entryPoints, logger, metrics, compressionHandler, gasPriceManager, simulateTransaction = false, legacyTransactions = false, fixedGasLimitForEstimation, localGasLimitCalculation = false) {
-        this.publicClient = publicClient;
-        this.walletClient = walletClient;
-        this.senderManager = senderManager;
-        this.reputationManager = reputationManager;
-        this.logger = logger;
-        this.metrics = metrics;
-        this.simulateTransaction = simulateTransaction;
-        this.legacyTransactions = legacyTransactions;
-        this.fixedGasLimitForEstimation = fixedGasLimitForEstimation;
-        this.localGasLimitCalculation = localGasLimitCalculation;
-        this.compressionHandler = compressionHandler;
-        this.gasPriceManager = gasPriceManager;
-        this.entryPoints = entryPoints;
-        this.mutex = new Mutex();
-    }
-    getCompressionHandler() {
-        if (!this.compressionHandler) {
-            throw new Error("Support for compressed bundles has not initialized");
-        }
-        return this.compressionHandler;
-    }
-    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 };
-        const gasPriceParameters = await this.gasPriceManager.getGasPrice();
-        newRequest.maxFeePerGas = maxBigInt(gasPriceParameters.maxFeePerGas, (newRequest.maxFeePerGas * 11n + 9n) / 10n);
-        newRequest.maxPriorityFeePerGas = maxBigInt(gasPriceParameters.maxPriorityFeePerGas, (newRequest.maxPriorityFeePerGas * 11n + 9n) / 10n);
-        newRequest.account = transactionInfo.executor;
-        const opsWithHashes = transactionInfo.userOperationInfos.map((opInfo) => {
-            const op = deriveUserOperation(opInfo.mempoolUserOperation);
-            return {
-                mempoolUserOperation: opInfo.mempoolUserOperation,
-                userOperationHash: getUserOperationHash(op, transactionInfo.entryPoint, this.walletClient.chain.id),
-                entryPoint: opInfo.entryPoint
-            };
-        });
-        let callContext;
-        if (transactionInfo.transactionType === "default") {
-            const [isUserOpVersion06, entryPoint] = opsWithHashes.reduce((acc, op) => {
-                if (acc[0] !==
-                    isVersion06(op.mempoolUserOperation) ||
-                    acc[1] !== op.entryPoint) {
-                    throw new Error("All user operations must be of the same version");
-                }
-                return acc;
-            }, [
-                isVersion06(opsWithHashes[0].mempoolUserOperation),
-                opsWithHashes[0].entryPoint
-            ]);
-            const ep = getContract({
-                abi: isUserOpVersion06 ? EntryPointV06Abi : EntryPointV07Abi,
-                address: entryPoint,
-                client: {
-                    public: this.publicClient,
-                    wallet: this.walletClient
-                }
-            });
-            callContext = {
-                ep,
-                type: "default"
-            };
-        }
-        else {
-            const compressionHandler = this.getCompressionHandler();
-            callContext = {
-                publicClient: this.publicClient,
-                bundleBulker: compressionHandler.bundleBulkerAddress,
-                perOpInflatorId: compressionHandler.perOpInflatorId,
-                type: "compressed"
-            };
-        }
-        const result = await filterOpsAndEstimateGas(transactionInfo.entryPoint, callContext, transactionInfo.executor, opsWithHashes, newRequest.nonce, newRequest.maxFeePerGas, newRequest.maxPriorityFeePerGas, "latest", this.legacyTransactions, this.fixedGasLimitForEstimation, this.reputationManager, this.logger);
-        const childLogger = this.logger.child({
-            transactionHash: transactionInfo.transactionHash,
-            executor: transactionInfo.executor.address
-        });
-        if (result.simulatedOps.length === 0) {
-            childLogger.warn("no ops to bundle");
-            this.markWalletProcessed(transactionInfo.executor);
-            return { status: "failed" };
-        }
-        if (result.simulatedOps.every((op) => op.reason === "AA25 invalid account nonce" ||
-            op.reason === "AA10 sender already constructed")) {
-            childLogger.trace({ reasons: result.simulatedOps.map((sop) => sop.reason) }, "all ops failed simulation with nonce error");
-            return { status: "potentially_already_included" };
-        }
-        if (result.simulatedOps.every((op) => op.reason !== undefined)) {
-            childLogger.warn("all ops failed simulation");
-            this.markWalletProcessed(transactionInfo.executor);
-            return { status: "failed" };
-        }
-        const opsToBundle = result.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;
-        });
-        newRequest.gas = this.localGasLimitCalculation
-            ? opsToBundle.reduce((acc, opInfo) => {
-                const userOperation = deriveUserOperation(opInfo.mempoolUserOperation);
-                return (acc +
-                    userOperation.preVerificationGas +
-                    3n * userOperation.verificationGasLimit +
-                    userOperation.callGasLimit);
-            }, 0n)
-            : result.gasLimit;
-        // update calldata to include only ops that pass simulation
-        if (transactionInfo.transactionType === "default") {
-            const isUserOpVersion06 = opsWithHashes.reduce((acc, op) => {
-                if (acc !==
-                    isVersion06(op.mempoolUserOperation)) {
-                    throw new Error("All user operations must be of the same version");
-                }
-                return acc;
-            }, isVersion06(opsWithHashes[0].mempoolUserOperation));
-            newRequest.data = isUserOpVersion06
-                ? encodeFunctionData({
-                    abi: EntryPointV06Abi,
-                    functionName: "handleOps",
-                    args: [
-                        opsToBundle.map((opInfo) => opInfo.mempoolUserOperation),
-                        transactionInfo.executor.address
-                    ]
-                })
-                : encodeFunctionData({
-                    abi: EntryPointV07Abi,
-                    functionName: "handleOps",
-                    args: [
-                        opsToBundle.map((opInfo) => toPackedUserOperation(opInfo.mempoolUserOperation)),
-                        transactionInfo.executor.address
-                    ]
-                });
-        }
-        else if (transactionInfo.transactionType === "compressed") {
-            const compressedOps = opsToBundle.map((opInfo) => opInfo.mempoolUserOperation);
-            newRequest.data = createCompressedCalldata(compressedOps, this.getCompressionHandler().perOpInflatorId);
-        }
-        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.walletClient.sendTransaction(this.legacyTransactions
-                ? {
-                    ...newRequest,
-                    gasPrice: newRequest.maxFeePerGas,
-                    maxFeePerGas: undefined,
-                    maxPriorityFeePerGas: undefined,
-                    type: "legacy",
-                    accessList: undefined
-                }
-                : newRequest);
-            const newTxInfo = {
-                ...transactionInfo,
-                transactionRequest: newRequest,
-                transactionHash: txHash,
-                previousTransactionHashes: [
-                    transactionInfo.transactionHash,
-                    ...transactionInfo.previousTransactionHashes
-                ],
-                lastReplaced: Date.now(),
-                userOperationInfos: opsToBundle.map((opInfo) => {
-                    return {
-                        entryPoint: opInfo.entryPoint,
-                        mempoolUserOperation: opInfo.mempoolUserOperation,
-                        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 gasPrice = await this.gasPriceManager.getGasPrice();
-        const wallets = this.senderManager.utilityAccount
-            ? Array.from(new Set([
-                ...this.senderManager.wallets,
-                this.senderManager.utilityAccount
-            ]))
-            : Array.from(new Set(this.senderManager.wallets));
-        const promises = wallets.map(async (wallet) => {
-            for (const entryPoint of this.entryPoints) {
-                await flushStuckTransaction(this.publicClient, this.walletClient, wallet, gasPrice.maxFeePerGas * 5n, this.logger, entryPoint);
-            }
-        });
-        await Promise.all(promises);
-    }
-    async bundle(entryPoint, ops) {
-        const wallet = await this.senderManager.getWallet();
-        const opsWithHashes = ops.map((op) => {
-            return {
-                mempoolUserOperation: op,
-                userOperationHash: getUserOperationHash(op, entryPoint, this.walletClient.chain.id)
-            };
-        });
-        const isUserOpVersion06 = opsWithHashes.reduce((acc, op) => {
-            if (acc !==
-                isVersion06(op.mempoolUserOperation)) {
-                throw new Error("All user operations must be of the same version");
-            }
-            return acc;
-        }, isVersion06(opsWithHashes[0].mempoolUserOperation));
-        const ep = getContract({
-            abi: isUserOpVersion06 ? EntryPointV06Abi : EntryPointV07Abi,
-            address: entryPoint,
-            client: {
-                public: this.publicClient,
-                wallet: this.walletClient
-            }
-        });
-        let childLogger = this.logger.child({
-            userOperations: opsWithHashes.map((oh) => oh.userOperationHash),
-            entryPoint
-        });
-        childLogger.debug("bundling user operation");
-        const gasPriceParameters = await this.gasPriceManager.getGasPrice();
-        childLogger.debug({ gasPriceParameters }, "got gas price");
-        const nonce = await this.publicClient.getTransactionCount({
-            address: wallet.address,
-            blockTag: "pending"
-        });
-        childLogger.trace({ nonce }, "got nonce");
-        const callContext = {
-            ep,
-            type: "default"
-        };
-        let { gasLimit, simulatedOps, resubmitAllOps } = await filterOpsAndEstimateGas(entryPoint, callContext, wallet, opsWithHashes, nonce, gasPriceParameters.maxFeePerGas, gasPriceParameters.maxPriorityFeePerGas, "pending", this.legacyTransactions, this.fixedGasLimitForEstimation, this.reputationManager, childLogger);
-        gasLimit += 10000n;
-        if (resubmitAllOps) {
-            this.markWalletProcessed(wallet);
-            return opsWithHashes.map((owh) => {
-                const bundleResult = {
-                    status: "resubmit",
-                    info: {
-                        entryPoint,
-                        userOpHash: owh.userOperationHash,
-                        userOperation: owh.mempoolUserOperation,
-                        reason: FeeCapTooLowError.name
-                    }
-                };
-                return bundleResult;
-            });
-        }
-        if (simulatedOps.length === 0) {
-            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.mempoolUserOperation,
-                        reason: "INTERNAL FAILURE"
-                    }
-                };
-            });
-        }
-        if (simulatedOps.every((op) => op.reason !== undefined)) {
-            childLogger.warn("all ops failed simulation");
-            this.markWalletProcessed(wallet);
-            return simulatedOps.map((op) => {
-                return {
-                    status: "failure",
-                    error: {
-                        entryPoint,
-                        userOpHash: op.owh.userOperationHash,
-                        userOperation: op.owh.mempoolUserOperation,
-                        reason: op.reason
-                    }
-                };
-            });
-        }
-        const opsWithHashToBundle = simulatedOps
-            .filter((op) => op.reason === undefined)
-            .map((op) => op.owh);
-        childLogger = this.logger.child({
-            userOperations: opsWithHashToBundle.map((owh) => owh.userOperationHash),
-            entryPoint
-        });
-        childLogger.trace({ gasLimit }, "got gas limit");
-        let txHash;
-        try {
-            const gasOptions = this.legacyTransactions
-                ? {
-                    gasPrice: gasPriceParameters.maxFeePerGas
-                }
-                : {
-                    maxFeePerGas: gasPriceParameters.maxFeePerGas,
-                    maxPriorityFeePerGas: gasPriceParameters.maxPriorityFeePerGas
-                };
-            txHash = isUserOpVersion06
-                ? await ep.write.handleOps([
-                    opsWithHashToBundle.map((owh) => owh.mempoolUserOperation),
-                    wallet.address
-                ], {
-                    account: wallet,
-                    gas: gasLimit,
-                    nonce: nonce,
-                    ...gasOptions
-                })
-                : await ep.write.handleOps([
-                    opsWithHashToBundle.map((owh) => toPackedUserOperation(owh.mempoolUserOperation)),
-                    wallet.address
-                ], {
-                    account: wallet,
-                    gas: gasLimit,
-                    nonce: nonce,
-                    ...gasOptions
-                });
-        }
-        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.mempoolUserOperation,
-                            reason: InsufficientFundsError.name
-                        }
-                    };
-                });
-            }
-            sentry.captureException(err);
-            childLogger.error({ error: JSON.stringify(err) }, "error submitting bundle transaction");
-            this.markWalletProcessed(wallet);
-            return opsWithHashes.map((owh) => {
-                return {
-                    status: "failure",
-                    error: {
-                        entryPoint,
-                        userOpHash: owh.userOperationHash,
-                        userOperation: owh.mempoolUserOperation,
-                        reason: "INTERNAL FAILURE"
-                    }
-                };
-            });
-        }
-        const userOperationInfos = opsWithHashToBundle.map((op) => {
-            return {
-                entryPoint,
-                mempoolUserOperation: op.mempoolUserOperation,
-                userOperationHash: op.userOperationHash,
-                lastReplaced: Date.now(),
-                firstSubmitted: Date.now()
-            };
-        });
-        const transactionInfo = {
-            entryPoint,
-            isVersion06: isUserOpVersion06,
-            transactionType: "default",
-            transactionHash: txHash,
-            previousTransactionHashes: [],
-            transactionRequest: {
-                account: wallet,
-                to: ep.address,
-                data: isUserOpVersion06
-                    ? encodeFunctionData({
-                        abi: ep.abi,
-                        functionName: "handleOps",
-                        args: [
-                            opsWithHashToBundle.map((owh) => owh.mempoolUserOperation),
-                            wallet.address
-                        ]
-                    })
-                    : encodeFunctionData({
-                        abi: ep.abi,
-                        functionName: "handleOps",
-                        args: [
-                            opsWithHashToBundle.map((owh) => toPackedUserOperation(owh.mempoolUserOperation)),
-                            wallet.address
-                        ]
-                    }),
-                gas: gasLimit,
-                chain: this.walletClient.chain,
-                maxFeePerGas: gasPriceParameters.maxFeePerGas,
-                maxPriorityFeePerGas: gasPriceParameters.maxPriorityFeePerGas,
-                nonce: nonce
-            },
-            executor: wallet,
-            userOperationInfos,
-            lastReplaced: Date.now(),
-            firstSubmitted: Date.now(),
-            timesPotentiallyIncluded: 0
-        };
-        const userOperationResults = simulatedOpsToResults(simulatedOps, transactionInfo);
-        childLogger.info({
-            transactionRequest: {
-                ...transactionInfo.transactionRequest,
-                abi: undefined
-            },
-            txHash,
-            opHashes: opsWithHashToBundle.map((owh) => owh.userOperationHash)
-        }, "submitted bundle transaction");
-        return userOperationResults;
-    }
-    async bundleCompressed(entryPoint, compressedOps) {
-        const compressionHandler = this.getCompressionHandler();
-        const wallet = await this.senderManager.getWallet();
-        const childLogger = this.logger.child({
-            compressedUserOperations: compressedOps,
-            entryPoint: entryPoint
-        });
-        childLogger.debug("bundling compressed user operation");
-        const gasPriceParameters = await this.gasPriceManager.getGasPrice();
-        childLogger.debug({ gasPriceParameters }, "got gas price");
-        const nonce = await this.publicClient.getTransactionCount({
-            address: wallet.address,
-            blockTag: "pending"
-        });
-        childLogger.trace({ nonce }, "got nonce");
-        const callContext = {
-            publicClient: this.publicClient,
-            bundleBulker: compressionHandler.bundleBulkerAddress,
-            perOpInflatorId: compressionHandler.perOpInflatorId,
-            type: "compressed"
-        };
-        let { gasLimit, simulatedOps, resubmitAllOps } = await filterOpsAndEstimateGas(entryPoint, callContext, wallet, compressedOps.map((compressedOp) => {
-            return {
-                mempoolUserOperation: compressedOp,
-                userOperationHash: getUserOperationHash(compressedOp.inflatedOp, entryPoint, this.walletClient.chain.id)
-            };
-        }), nonce, gasPriceParameters.maxFeePerGas, gasPriceParameters.maxPriorityFeePerGas, "pending", this.legacyTransactions, this.fixedGasLimitForEstimation, this.reputationManager, childLogger);
-        gasLimit += 10000n;
-        if (resubmitAllOps) {
-            this.markWalletProcessed(wallet);
-            return compressedOps.map((compressedOp) => {
-                return {
-                    status: "resubmit",
-                    info: {
-                        entryPoint,
-                        userOpHash: getUserOperationHash(compressedOp.inflatedOp, entryPoint, this.walletClient.chain.id),
-                        userOperation: compressedOp,
-                        reason: FeeCapTooLowError.name
-                    }
-                };
-            });
-        }
-        if (simulatedOps.length === 0) {
-            childLogger.warn("no ops to bundle");
-            this.markWalletProcessed(wallet);
-            return compressedOps.map((compressedOp) => {
-                return {
-                    status: "failure",
-                    error: {
-                        entryPoint,
-                        userOpHash: getUserOperationHash(compressedOp.inflatedOp, entryPoint, this.walletClient.chain.id),
-                        userOperation: compressedOp,
-                        reason: "INTERNAL FAILURE"
-                    }
-                };
-            });
-        }
-        // if not all succeeded, return error
-        if (simulatedOps.some((simulatedOp) => simulatedOp.reason !== undefined)) {
-            childLogger.warn("some ops failed simulation");
-            this.markWalletProcessed(wallet);
-            return simulatedOps.map((simulatedOp) => {
-                return {
-                    status: "failure",
-                    error: {
-                        entryPoint,
-                        userOpHash: simulatedOp.owh.userOperationHash,
-                        userOperation: simulatedOp.owh.mempoolUserOperation,
-                        reason: simulatedOp.reason
-                    }
-                };
-            });
-        }
-        const opsToBundle = simulatedOps
-            .filter((simulatedOp) => simulatedOp.reason === undefined)
-            .map((simulatedOp) => simulatedOp.owh);
-        let txHash;
-        try {
-            const gasOptions = this.legacyTransactions
-                ? {
-                    gasPrice: gasPriceParameters.maxFeePerGas
-                }
-                : {
-                    maxFeePerGas: gasPriceParameters.maxFeePerGas,
-                    maxPriorityFeePerGas: gasPriceParameters.maxPriorityFeePerGas
-                };
-            // need to use sendTransaction to target BundleBulker's fallback
-            txHash = await this.walletClient.sendTransaction({
-                account: wallet,
-                to: compressionHandler.bundleBulkerAddress,
-                data: createCompressedCalldata(compressedOps, compressionHandler.perOpInflatorId),
-                gas: gasLimit,
-                nonce: nonce,
-                ...gasOptions
-            });
-        }
-        catch (err) {
-            sentry.captureException(err);
-            childLogger.error({ error: JSON.stringify(err) }, "error submitting bundle transaction");
-            this.markWalletProcessed(wallet);
-            return opsToBundle.map((op) => {
-                return {
-                    status: "failure",
-                    error: {
-                        entryPoint,
-                        userOpHash: op.userOperationHash,
-                        userOperation: op.mempoolUserOperation,
-                        reason: "INTERNAL FAILURE"
-                    }
-                };
-            });
-        }
-        const userOperationInfos = opsToBundle.map((owh) => {
-            return {
-                entryPoint,
-                mempoolUserOperation: owh.mempoolUserOperation,
-                userOperationHash: owh.userOperationHash,
-                lastReplaced: Date.now(),
-                firstSubmitted: Date.now()
-            };
-        });
-        const transactionInfo = {
-            entryPoint,
-            isVersion06: true, //TODO: compressed bundles are always v06
-            transactionType: "compressed",
-            transactionHash: txHash,
-            previousTransactionHashes: [],
-            transactionRequest: {
-                to: compressionHandler.bundleBulkerAddress,
-                data: createCompressedCalldata(compressedOps, compressionHandler.perOpInflatorId),
-                gas: gasLimit,
-                account: wallet,
-                chain: this.walletClient.chain,
-                maxFeePerGas: gasPriceParameters.maxFeePerGas,
-                maxPriorityFeePerGas: gasPriceParameters.maxPriorityFeePerGas,
-                nonce: nonce
-            },
-            executor: wallet,
-            userOperationInfos,
-            lastReplaced: Date.now(),
-            firstSubmitted: Date.now(),
-            timesPotentiallyIncluded: 0
-        };
-        const userOperationResults = simulatedOpsToResults(simulatedOps, transactionInfo);
-        childLogger.info({
-            txHash,
-            opHashes: opsToBundle.map((owh) => owh.userOperationHash)
-        }, "submitted bundle transaction");
-        return userOperationResults;
-    }
-}
-//# sourceMappingURL=executor.js.map