@pimlico/alto 0.0.7 → 0.0.9

package/lib/executor/executor.js

@@ -26,47 +26,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Executor = void 0;
 const types_1 = require("../types/index.js");
 const utils_1 = require("../utils/index.js");
-// biome-ignore lint/style/noNamespaceImport: explicitly make it clear when sentry is used
 const sentry = __importStar(require("@sentry/node"));
 const async_mutex_1 = require("async-mutex");
 const viem_1 = require("viem");
 const utils_2 = require("./utils.js");
 class Executor {
     // private unWatch: WatchBlocksReturnType | undefined
-    publicClient;
-    walletClient;
-    entryPoints;
+    config;
     senderManager;
     logger;
     metrics;
-    simulateTransaction;
-    legacyTransactions;
-    fixedGasLimitForEstimation;
-    localGasLimitCalculation;
     reputationManager;
     compressionHandler;
     gasPriceManager;
-    blockTagSupport;
     mutex;
+    mempool;
     eventManager;
-    noProfitBundling; // if true, bundle such that all beneficiary fees go towards tx gasFees
-    constructor(publicClient, walletClient, senderManager, reputationManager, entryPoints, logger, metrics, compressionHandler, gasPriceManager, eventManager, simulateTransaction = false, legacyTransactions = false, fixedGasLimitForEstimation, blockTagSupport = true, localGasLimitCalculation = false, noProfitBundling = false) {
-        this.publicClient = publicClient;
-        this.walletClient = walletClient;
+    constructor({ config, mempool, senderManager, reputationManager, metrics, compressionHandler, gasPriceManager, eventManager }) {
+        this.config = config;
+        this.mempool = mempool;
         this.senderManager = senderManager;
         this.reputationManager = reputationManager;
-        this.logger = logger;
+        this.logger = config.getLogger({ module: "executor" }, {
+            level: config.executorLogLevel || config.logLevel
+        });
         this.metrics = metrics;
-        this.simulateTransaction = simulateTransaction;
-        this.legacyTransactions = legacyTransactions;
-        this.fixedGasLimitForEstimation = fixedGasLimitForEstimation;
-        this.localGasLimitCalculation = localGasLimitCalculation;
         this.compressionHandler = compressionHandler;
         this.gasPriceManager = gasPriceManager;
         this.eventManager = eventManager;
-        this.blockTagSupport = blockTagSupport;
-        this.entryPoints = entryPoints;
-        this.noProfitBundling = noProfitBundling;
         this.mutex = new async_mutex_1.Mutex();
     }
     getCompressionHandler() {
@@ -86,7 +73,16 @@ class Executor {
     }
     async replaceTransaction(transactionInfo) {
         const newRequest = { ...transactionInfo.transactionRequest };
-        const gasPriceParameters = await this.gasPriceManager.getGasPrice();
+        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 = (0, utils_1.maxBigInt)(gasPriceParameters.maxFeePerGas, (newRequest.maxFeePerGas * 11n + 9n) / 10n);
         newRequest.maxPriorityFeePerGas = (0, utils_1.maxBigInt)(gasPriceParameters.maxPriorityFeePerGas, (newRequest.maxPriorityFeePerGas * 11n + 9n) / 10n);
         newRequest.account = transactionInfo.executor;
@@ -94,7 +90,7 @@ class Executor {
             const op = (0, types_1.deriveUserOperation)(opInfo.mempoolUserOperation);
             return {
                 mempoolUserOperation: opInfo.mempoolUserOperation,
-                userOperationHash: (0, utils_1.getUserOperationHash)(op, transactionInfo.entryPoint, this.walletClient.chain.id),
+                userOperationHash: (0, utils_1.getUserOperationHash)(op, transactionInfo.entryPoint, this.config.walletClient.chain.id),
                 entryPoint: opInfo.entryPoint
             };
         });
@@ -115,8 +111,8 @@ class Executor {
                 abi: isUserOpVersion06 ? types_1.EntryPointV06Abi : types_1.EntryPointV07Abi,
                 address: entryPoint,
                 client: {
-                    public: this.publicClient,
-                    wallet: this.walletClient
+                    public: this.config.publicClient,
+                    wallet: this.config.walletClient
                 }
             });
             callContext = {
@@ -127,13 +123,13 @@ class Executor {
         else {
             const compressionHandler = this.getCompressionHandler();
             callContext = {
-                publicClient: this.publicClient,
+                publicClient: this.config.publicClient,
                 bundleBulker: compressionHandler.bundleBulkerAddress,
                 perOpInflatorId: compressionHandler.perOpInflatorId,
                 type: "compressed"
             };
         }
-        let { simulatedOps, gasLimit } = await (0, utils_2.filterOpsAndEstimateGas)(transactionInfo.entryPoint, callContext, transactionInfo.executor, opsWithHashes, newRequest.nonce, newRequest.maxFeePerGas, newRequest.maxPriorityFeePerGas, this.blockTagSupport ? "latest" : undefined, this.legacyTransactions, this.fixedGasLimitForEstimation, this.reputationManager, this.logger);
+        let { simulatedOps, gasLimit } = await (0, utils_2.filterOpsAndEstimateGas)(transactionInfo.entryPoint, callContext, 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
@@ -162,7 +158,7 @@ class Executor {
             }
             return opInfo;
         });
-        if (this.localGasLimitCalculation) {
+        if (this.config.localGasLimitCalculation) {
             gasLimit = opsToBundle.reduce((acc, opInfo) => {
                 const userOperation = (0, types_1.deriveUserOperation)(opInfo.mempoolUserOperation);
                 return (acc +
@@ -186,6 +182,7 @@ class Executor {
         // ensures that we don't submit again with too low of a gas value
         newRequest.gas = (0, utils_1.maxBigInt)(newRequest.gas, gasLimit);
         // update calldata to include only ops that pass simulation
+        let txParam;
         if (transactionInfo.transactionType === "default") {
             const isUserOpVersion06 = opsWithHashes.reduce((acc, op) => {
                 if (acc !==
@@ -194,27 +191,22 @@ class Executor {
                 }
                 return acc;
             }, (0, utils_1.isVersion06)(opsWithHashes[0].mempoolUserOperation));
-            newRequest.data = isUserOpVersion06
-                ? (0, viem_1.encodeFunctionData)({
-                    abi: types_1.EntryPointV06Abi,
-                    functionName: "handleOps",
-                    args: [
-                        opsToBundle.map((opInfo) => opInfo.mempoolUserOperation),
-                        transactionInfo.executor.address
-                    ]
-                })
-                : (0, viem_1.encodeFunctionData)({
-                    abi: types_1.EntryPointV07Abi,
-                    functionName: "handleOps",
-                    args: [
-                        opsToBundle.map((opInfo) => (0, utils_1.toPackedUserOperation)(opInfo.mempoolUserOperation)),
-                        transactionInfo.executor.address
-                    ]
-                });
+            const userOps = opsToBundle.map((op) => isUserOpVersion06
+                ? op.mempoolUserOperation
+                : (0, utils_1.toPackedUserOperation)(op.mempoolUserOperation));
+            txParam = {
+                type: "default",
+                isUserOpVersion06,
+                ops: userOps,
+                entryPoint: transactionInfo.entryPoint
+            };
         }
-        else if (transactionInfo.transactionType === "compressed") {
-            const compressedOps = opsToBundle.map((opInfo) => opInfo.mempoolUserOperation);
-            newRequest.data = (0, utils_2.createCompressedCalldata)(compressedOps, this.getCompressionHandler().perOpInflatorId);
+        else {
+            const compressedOps = opsToBundle.map(({ mempoolUserOperation }) => mempoolUserOperation);
+            txParam = {
+                type: "compressed",
+                compressedOps: compressedOps
+            };
         }
         try {
             childLogger.info({
@@ -226,20 +218,27 @@ class Executor {
                 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);
-            opsToBundle.map((opToBundle) => {
-                const op = (0, types_1.deriveUserOperation)(opToBundle.mempoolUserOperation);
-                const chainId = this.publicClient.chain?.id;
-                const opHash = (0, utils_1.getUserOperationHash)(op, opToBundle.entryPoint, chainId);
+            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, mempoolUserOperation }) => {
+                const op = (0, types_1.deriveUserOperation)(mempoolUserOperation);
+                const chainId = this.config.publicClient.chain?.id;
+                const opHash = (0, utils_1.getUserOperationHash)(op, entryPoint, chainId);
                 this.eventManager.emitSubmitted(opHash, txHash);
             });
             const newTxInfo = {
@@ -297,18 +296,129 @@ class Executor {
             allWallets.add(utilityWallet);
         }
         const wallets = Array.from(allWallets);
-        const gasPrice = await this.gasPriceManager.getGasPrice();
+        const gasPrice = await this.gasPriceManager.tryGetNetworkGasPrice();
         const promises = wallets.map((wallet) => {
-            (0, utils_2.flushStuckTransaction)(this.publicClient, this.walletClient, wallet, gasPrice.maxFeePerGas * 5n, this.logger);
+            try {
+                (0, utils_2.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;
+        if (txParam.type === "default") {
+            const { isUserOpVersion06, ops, entryPoint } = txParam;
+            data = (0, viem_1.encodeFunctionData)({
+                abi: isUserOpVersion06 ? types_1.EntryPointV06Abi : types_1.EntryPointV07Abi,
+                functionName: "handleOps",
+                args: [ops, opts.account.address]
+            });
+            to = entryPoint;
+        }
+        else {
+            const { compressedOps } = txParam;
+            const compressionHandler = this.getCompressionHandler();
+            data = (0, utils_2.createCompressedCalldata)(compressedOps, compressionHandler.perOpInflatorId);
+            to = compressionHandler.bundleBulkerAddress;
+        }
+        const request = await this.config.walletClient.prepareTransactionRequest({
+            to,
+            data,
+            ...opts
+        });
+        let isTransactionUnderPriced = false;
+        let attempts = 0;
+        let transactionHash;
+        const maxAttempts = 3;
+        // Try sending the transaction and updating relevant fields if there is an error.
+        while (attempts < maxAttempts) {
+            try {
+                transactionHash =
+                    await this.config.walletClient.sendTransaction(request);
+                break;
+            }
+            catch (e) {
+                isTransactionUnderPriced = false;
+                let isErrorHandled = false;
+                if (e instanceof viem_1.BaseError) {
+                    if ((0, utils_2.isTransactionUnderpricedError)(e)) {
+                        this.logger.warn("Transaction underpriced, retrying");
+                        request.maxFeePerGas = (0, utils_1.scaleBigIntByPercent)(request.maxFeePerGas, 150);
+                        request.maxPriorityFeePerGas = (0, utils_1.scaleBigIntByPercent)(request.maxPriorityFeePerGas, 150);
+                        isErrorHandled = true;
+                        isTransactionUnderPriced = true;
+                    }
+                }
+                const error = e;
+                if (error instanceof viem_1.TransactionExecutionError) {
+                    const cause = error.cause;
+                    if (cause instanceof viem_1.NonceTooLowError ||
+                        cause instanceof viem_1.NonceTooHighError) {
+                        this.logger.warn("Nonce too low, retrying");
+                        request.nonce =
+                            await this.config.publicClient.getTransactionCount({
+                                address: request.from,
+                                blockTag: "pending"
+                            });
+                        isErrorHandled = true;
+                    }
+                    if (cause instanceof viem_1.IntrinsicGasTooLowError) {
+                        this.logger.warn("Intrinsic gas too low, retrying");
+                        request.gas = (0, utils_1.scaleBigIntByPercent)(request.gas, 150);
+                        isErrorHandled = true;
+                    }
+                    // This is thrown by OP-Stack chains that use proxyd.
+                    // ref: https://github.com/ethereum-optimism/optimism/issues/2618#issuecomment-1630272888
+                    if (cause.details?.includes("no backends available")) {
+                        this.logger.warn("no backends avaiable error, retrying after 500ms");
+                        await new Promise((resolve) => setTimeout(resolve, 500));
+                        isErrorHandled = true;
+                    }
+                }
+                if (attempts === maxAttempts || !isErrorHandled) {
+                    throw error;
+                }
+                attempts++;
+            }
+        }
+        if (isTransactionUnderPriced) {
+            await this.handleTransactionUnderPriced({
+                nonce: request.nonce,
+                executor: request.from
+            });
+        }
+        // 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 &&
+                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.mempoolUserOperation, op.entryPoint);
+        });
+    }
     async bundle(entryPoint, ops) {
         const wallet = await this.senderManager.getWallet();
         const opsWithHashes = ops.map((op) => {
             return {
                 mempoolUserOperation: op,
-                userOperationHash: (0, utils_1.getUserOperationHash)(op, entryPoint, this.walletClient.chain.id)
+                userOperationHash: (0, utils_1.getUserOperationHash)(op, entryPoint, this.config.walletClient.chain.id)
             };
         });
         const isUserOpVersion06 = opsWithHashes.reduce((acc, op) => {
@@ -322,8 +432,8 @@ class Executor {
             abi: isUserOpVersion06 ? types_1.EntryPointV06Abi : types_1.EntryPointV07Abi,
             address: entryPoint,
             client: {
-                public: this.publicClient,
-                wallet: this.walletClient
+                public: this.config.publicClient,
+                wallet: this.config.walletClient
             }
         });
         let childLogger = this.logger.child({
@@ -331,18 +441,39 @@ class Executor {
             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");
+        // 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.mempoolUserOperation,
+                        reason: "Failed to get parameters for bundling"
+                    }
+                };
+            });
+        }
         const callContext = {
             ep,
             type: "default"
         };
-        let { gasLimit, simulatedOps } = await (0, utils_2.filterOpsAndEstimateGas)(entryPoint, callContext, wallet, opsWithHashes, nonce, gasPriceParameters.maxFeePerGas, gasPriceParameters.maxPriorityFeePerGas, this.blockTagSupport ? "pending" : undefined, this.legacyTransactions, this.fixedGasLimitForEstimation, this.reputationManager, childLogger);
+        let { gasLimit, simulatedOps } = await (0, utils_2.filterOpsAndEstimateGas)(entryPoint, callContext, wallet, opsWithHashes, nonce, gasPriceParameters.maxFeePerGas, gasPriceParameters.maxPriorityFeePerGas, this.config.blockTagSupport ? "pending" : undefined, this.config.legacyTransactions, this.config.fixedGasLimitForEstimation, this.reputationManager, childLogger);
         if (simulatedOps.length === 0) {
             childLogger.error("gas limit simulation encountered unexpected failure");
             this.markWalletProcessed(wallet);
@@ -397,14 +528,14 @@ class Executor {
         childLogger.debug({ gasLimit }, "got gas limit");
         let transactionHash;
         try {
-            const isLegacyTransaction = this.legacyTransactions;
+            const isLegacyTransaction = this.config.legacyTransactions;
             const gasOptions = isLegacyTransaction
                 ? { gasPrice: gasPriceParameters.maxFeePerGas }
                 : {
                     maxFeePerGas: gasPriceParameters.maxFeePerGas,
                     maxPriorityFeePerGas: gasPriceParameters.maxPriorityFeePerGas
                 };
-            if (this.noProfitBundling) {
+            if (this.config.noProfitBundling) {
                 const gasPrice = totalBeneficiaryFees / gasLimit;
                 if (isLegacyTransaction) {
                     gasOptions.gasPrice = gasPrice;
@@ -422,7 +553,15 @@ class Executor {
             const userOps = opsWithHashToBundle.map((owh) => isUserOpVersion06
                 ? owh.mempoolUserOperation
                 : (0, utils_1.toPackedUserOperation)(owh.mempoolUserOperation));
-            transactionHash = await ep.write.handleOps([userOps, wallet.address], opts);
+            transactionHash = await this.sendHandleOpsTransaction({
+                txParam: {
+                    type: "default",
+                    ops: userOps,
+                    isUserOpVersion06,
+                    entryPoint
+                },
+                opts
+            });
             opsWithHashToBundle.map(({ userOperationHash }) => {
                 this.eventManager.emitSubmitted(userOperationHash, transactionHash);
             });
@@ -444,23 +583,6 @@ class Executor {
                     };
                 });
             }
-            if (e?.details
-                .toLowerCase()
-                .includes("replacement transaction underpriced")) {
-                childLogger.error({ error: e }, "replacement transaction underpriced");
-                this.markWalletProcessed(wallet);
-                return opsWithHashToBundle.map((owh) => {
-                    return {
-                        status: "resubmit",
-                        info: {
-                            entryPoint,
-                            userOpHash: owh.userOperationHash,
-                            userOperation: owh.mempoolUserOperation,
-                            reason: "replacement transaction underpriced"
-                        }
-                    };
-                });
-            }
             sentry.captureException(err);
             childLogger.error({ error: JSON.stringify(err) }, "error submitting bundle transaction");
             this.markWalletProcessed(wallet);
@@ -494,25 +616,8 @@ class Executor {
             transactionRequest: {
                 account: wallet,
                 to: ep.address,
-                data: isUserOpVersion06
-                    ? (0, viem_1.encodeFunctionData)({
-                        abi: ep.abi,
-                        functionName: "handleOps",
-                        args: [
-                            opsWithHashToBundle.map((owh) => owh.mempoolUserOperation),
-                            wallet.address
-                        ]
-                    })
-                    : (0, viem_1.encodeFunctionData)({
-                        abi: ep.abi,
-                        functionName: "handleOps",
-                        args: [
-                            opsWithHashToBundle.map((owh) => (0, utils_1.toPackedUserOperation)(owh.mempoolUserOperation)),
-                            wallet.address
-                        ]
-                    }),
                 gas: gasLimit,
-                chain: this.walletClient.chain,
+                chain: this.config.walletClient.chain,
                 maxFeePerGas: gasPriceParameters.maxFeePerGas,
                 maxPriorityFeePerGas: gasPriceParameters.maxPriorityFeePerGas,
                 nonce: nonce
@@ -542,15 +647,36 @@ class Executor {
             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");
+        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 compressedOps.map((compressedOp) => {
+                const userOpHash = (0, utils_1.getUserOperationHash)(compressedOp.inflatedOp, entryPoint, this.config.walletClient.chain.id);
+                return {
+                    status: "resubmit",
+                    info: {
+                        entryPoint,
+                        userOpHash,
+                        userOperation: compressedOp,
+                        reason: "Failed to get parameters for bundling"
+                    }
+                };
+            });
+        }
         const callContext = {
-            publicClient: this.publicClient,
+            publicClient: this.config.publicClient,
             bundleBulker: compressionHandler.bundleBulkerAddress,
             perOpInflatorId: compressionHandler.perOpInflatorId,
             type: "compressed"
@@ -558,15 +684,15 @@ class Executor {
         let { gasLimit, simulatedOps } = await (0, utils_2.filterOpsAndEstimateGas)(entryPoint, callContext, wallet, compressedOps.map((compressedOp) => {
             return {
                 mempoolUserOperation: compressedOp,
-                userOperationHash: (0, utils_1.getUserOperationHash)(compressedOp.inflatedOp, entryPoint, this.walletClient.chain.id)
+                userOperationHash: (0, utils_1.getUserOperationHash)(compressedOp.inflatedOp, entryPoint, this.config.walletClient.chain.id)
             };
-        }), nonce, gasPriceParameters.maxFeePerGas, gasPriceParameters.maxPriorityFeePerGas, this.blockTagSupport ? "pending" : undefined, this.legacyTransactions, this.fixedGasLimitForEstimation, this.reputationManager, childLogger);
+        }), nonce, gasPriceParameters.maxFeePerGas, gasPriceParameters.maxPriorityFeePerGas, this.config.blockTagSupport ? "pending" : undefined, this.config.legacyTransactions, this.config.fixedGasLimitForEstimation, this.reputationManager, childLogger);
         gasLimit += 10000n;
         if (simulatedOps.length === 0) {
             childLogger.warn("no ops to bundle");
             this.markWalletProcessed(wallet);
             return compressedOps.map((compressedOp) => {
-                const userOpHash = (0, utils_1.getUserOperationHash)(compressedOp.inflatedOp, entryPoint, this.walletClient.chain.id);
+                const userOpHash = (0, utils_1.getUserOperationHash)(compressedOp.inflatedOp, entryPoint, this.config.walletClient.chain.id);
                 return {
                     status: "failure",
                     error: {
@@ -599,7 +725,7 @@ class Executor {
             .map((simulatedOp) => simulatedOp.owh);
         let transactionHash;
         try {
-            const gasOptions = this.legacyTransactions
+            const gasOptions = this.config.legacyTransactions
                 ? {
                     gasPrice: gasPriceParameters.maxFeePerGas
                 }
@@ -611,14 +737,12 @@ class Executor {
                 const compressedOp = mempoolUserOperation;
                 return compressedOp;
             });
-            // need to use sendTransaction to target BundleBulker's fallback
-            transactionHash = await this.walletClient.sendTransaction({
-                account: wallet,
-                to: compressionHandler.bundleBulkerAddress,
-                data: (0, utils_2.createCompressedCalldata)(compressedOpsToBundle, compressionHandler.perOpInflatorId),
-                gas: gasLimit,
-                nonce: nonce,
-                ...gasOptions
+            transactionHash = await this.sendHandleOpsTransaction({
+                txParam: {
+                    type: "compressed",
+                    compressedOps: compressedOpsToBundle
+                },
+                opts: { ...gasOptions, gas: gasLimit, account: wallet, nonce }
             });
             opsToBundle.map(({ userOperationHash }) => {
                 this.eventManager.emitSubmitted(userOperationHash, transactionHash);
@@ -657,10 +781,9 @@ class Executor {
             previousTransactionHashes: [],
             transactionRequest: {
                 to: compressionHandler.bundleBulkerAddress,
-                data: (0, utils_2.createCompressedCalldata)(compressedOps, compressionHandler.perOpInflatorId),
                 gas: gasLimit,
                 account: wallet,
-                chain: this.walletClient.chain,
+                chain: this.config.walletClient.chain,
                 maxFeePerGas: gasPriceParameters.maxFeePerGas,
                 maxPriorityFeePerGas: gasPriceParameters.maxPriorityFeePerGas,
                 nonce: nonce