@pimlico/alto 0.0.7 → 0.0.9

package/esm/executor/executor.js

@@ -1,46 +1,33 @@
-import { deriveUserOperation, EntryPointV06Abi, EntryPointV07Abi } from "../types/index.js";
-import { getRequiredPrefund, getUserOperationHash, isVersion06, maxBigInt, parseViemError, toPackedUserOperation } from "../utils/index.js";
-// biome-ignore lint/style/noNamespaceImport: explicitly make it clear when sentry is used
+import { EntryPointV06Abi, EntryPointV07Abi, deriveUserOperation } from "../types/index.js";
+import { getRequiredPrefund, getUserOperationHash, isVersion06, maxBigInt, parseViemError, scaleBigIntByPercent, 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";
+import { FeeCapTooLowError, InsufficientFundsError, IntrinsicGasTooLowError, NonceTooLowError, TransactionExecutionError, encodeFunctionData, getContract, BaseError, NonceTooHighError } from "viem";
+import { createCompressedCalldata, filterOpsAndEstimateGas, flushStuckTransaction, simulatedOpsToResults, isTransactionUnderpricedError } from "./utils.js";
 export 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 Mutex();
     }
     getCompressionHandler() {
@@ -60,7 +47,16 @@ export 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 = maxBigInt(gasPriceParameters.maxFeePerGas, (newRequest.maxFeePerGas * 11n + 9n) / 10n);
         newRequest.maxPriorityFeePerGas = maxBigInt(gasPriceParameters.maxPriorityFeePerGas, (newRequest.maxPriorityFeePerGas * 11n + 9n) / 10n);
         newRequest.account = transactionInfo.executor;
@@ -68,7 +64,7 @@ export class Executor {
             const op = deriveUserOperation(opInfo.mempoolUserOperation);
             return {
                 mempoolUserOperation: opInfo.mempoolUserOperation,
-                userOperationHash: getUserOperationHash(op, transactionInfo.entryPoint, this.walletClient.chain.id),
+                userOperationHash: getUserOperationHash(op, transactionInfo.entryPoint, this.config.walletClient.chain.id),
                 entryPoint: opInfo.entryPoint
             };
         });
@@ -89,8 +85,8 @@ export class Executor {
                 abi: isUserOpVersion06 ? EntryPointV06Abi : EntryPointV07Abi,
                 address: entryPoint,
                 client: {
-                    public: this.publicClient,
-                    wallet: this.walletClient
+                    public: this.config.publicClient,
+                    wallet: this.config.walletClient
                 }
             });
             callContext = {
@@ -101,13 +97,13 @@ export 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 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 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
@@ -136,7 +132,7 @@ export class Executor {
             }
             return opInfo;
         });
-        if (this.localGasLimitCalculation) {
+        if (this.config.localGasLimitCalculation) {
             gasLimit = opsToBundle.reduce((acc, opInfo) => {
                 const userOperation = deriveUserOperation(opInfo.mempoolUserOperation);
                 return (acc +
@@ -160,6 +156,7 @@ export class Executor {
         // 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;
         if (transactionInfo.transactionType === "default") {
             const isUserOpVersion06 = opsWithHashes.reduce((acc, op) => {
                 if (acc !==
@@ -168,27 +165,22 @@ export class Executor {
                 }
                 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
-                    ]
-                });
+            const userOps = opsToBundle.map((op) => isUserOpVersion06
+                ? op.mempoolUserOperation
+                : 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 = createCompressedCalldata(compressedOps, this.getCompressionHandler().perOpInflatorId);
+        else {
+            const compressedOps = opsToBundle.map(({ mempoolUserOperation }) => mempoolUserOperation);
+            txParam = {
+                type: "compressed",
+                compressedOps: compressedOps
+            };
         }
         try {
             childLogger.info({
@@ -200,20 +192,27 @@ export 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 = deriveUserOperation(opToBundle.mempoolUserOperation);
-                const chainId = this.publicClient.chain?.id;
-                const opHash = 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 = deriveUserOperation(mempoolUserOperation);
+                const chainId = this.config.publicClient.chain?.id;
+                const opHash = getUserOperationHash(op, entryPoint, chainId);
                 this.eventManager.emitSubmitted(opHash, txHash);
             });
             const newTxInfo = {
@@ -271,18 +270,129 @@ export 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) => {
-            flushStuckTransaction(this.publicClient, this.walletClient, wallet, gasPrice.maxFeePerGas * 5n, this.logger);
+            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;
+        if (txParam.type === "default") {
+            const { isUserOpVersion06, ops, entryPoint } = txParam;
+            data = encodeFunctionData({
+                abi: isUserOpVersion06 ? EntryPointV06Abi : EntryPointV07Abi,
+                functionName: "handleOps",
+                args: [ops, opts.account.address]
+            });
+            to = entryPoint;
+        }
+        else {
+            const { compressedOps } = txParam;
+            const compressionHandler = this.getCompressionHandler();
+            data = 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 BaseError) {
+                    if (isTransactionUnderpricedError(e)) {
+                        this.logger.warn("Transaction underpriced, retrying");
+                        request.maxFeePerGas = scaleBigIntByPercent(request.maxFeePerGas, 150);
+                        request.maxPriorityFeePerGas = scaleBigIntByPercent(request.maxPriorityFeePerGas, 150);
+                        isErrorHandled = true;
+                        isTransactionUnderPriced = true;
+                    }
+                }
+                const error = e;
+                if (error instanceof TransactionExecutionError) {
+                    const cause = error.cause;
+                    if (cause instanceof NonceTooLowError ||
+                        cause instanceof 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 IntrinsicGasTooLowError) {
+                        this.logger.warn("Intrinsic gas too low, retrying");
+                        request.gas = 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: getUserOperationHash(op, entryPoint, this.walletClient.chain.id)
+                userOperationHash: getUserOperationHash(op, entryPoint, this.config.walletClient.chain.id)
             };
         });
         const isUserOpVersion06 = opsWithHashes.reduce((acc, op) => {
@@ -296,8 +406,8 @@ export class Executor {
             abi: isUserOpVersion06 ? EntryPointV06Abi : EntryPointV07Abi,
             address: entryPoint,
             client: {
-                public: this.publicClient,
-                wallet: this.walletClient
+                public: this.config.publicClient,
+                wallet: this.config.walletClient
             }
         });
         let childLogger = this.logger.child({
@@ -305,18 +415,39 @@ export 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 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 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);
@@ -371,14 +502,14 @@ export 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;
@@ -396,7 +527,15 @@ export class Executor {
             const userOps = opsWithHashToBundle.map((owh) => isUserOpVersion06
                 ? owh.mempoolUserOperation
                 : 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);
             });
@@ -418,23 +557,6 @@ export 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);
@@ -468,25 +590,8 @@ export class Executor {
             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,
+                chain: this.config.walletClient.chain,
                 maxFeePerGas: gasPriceParameters.maxFeePerGas,
                 maxPriorityFeePerGas: gasPriceParameters.maxPriorityFeePerGas,
                 nonce: nonce
@@ -516,15 +621,36 @@ export 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 = 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"
@@ -532,15 +658,15 @@ export class Executor {
         let { gasLimit, simulatedOps } = await filterOpsAndEstimateGas(entryPoint, callContext, wallet, compressedOps.map((compressedOp) => {
             return {
                 mempoolUserOperation: compressedOp,
-                userOperationHash: getUserOperationHash(compressedOp.inflatedOp, entryPoint, this.walletClient.chain.id)
+                userOperationHash: 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 = getUserOperationHash(compressedOp.inflatedOp, entryPoint, this.walletClient.chain.id);
+                const userOpHash = getUserOperationHash(compressedOp.inflatedOp, entryPoint, this.config.walletClient.chain.id);
                 return {
                     status: "failure",
                     error: {
@@ -573,7 +699,7 @@ export class Executor {
             .map((simulatedOp) => simulatedOp.owh);
         let transactionHash;
         try {
-            const gasOptions = this.legacyTransactions
+            const gasOptions = this.config.legacyTransactions
                 ? {
                     gasPrice: gasPriceParameters.maxFeePerGas
                 }
@@ -585,14 +711,12 @@ export 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: 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);
@@ -631,10 +755,9 @@ export class Executor {
             previousTransactionHashes: [],
             transactionRequest: {
                 to: compressionHandler.bundleBulkerAddress,
-                data: 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