@pimlico/alto 0.0.0-main.20250214T151652 → 0.0.0-main.20250225T152738

package/lib/rpc/methods/pimlico_sendUserOperationNow.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pimlicoSendUserOperationNowHandler = void 0;
+const utils_1 = require("../../utils/index.js");
+const createMethodHandler_1 = require("../createMethodHandler.js");
+const types_1 = require("../../types/index.js");
+exports.pimlicoSendUserOperationNowHandler = (0, createMethodHandler_1.createMethodHandler)({
+    method: "pimlico_sendUserOperationNow",
+    schema: types_1.pimlicoSendUserOperationNowSchema,
+    handler: async ({ rpcHandler, params, apiVersion }) => {
+        if (!rpcHandler.config.enableInstantBundlingEndpoint) {
+            throw new types_1.RpcError("pimlico_sendUserOperationNow endpoint is not enabled", types_1.ValidationErrors.InvalidFields);
+        }
+        const [userOperation, entryPoint] = params;
+        rpcHandler.ensureEntryPointIsSupported(entryPoint);
+        const opHash = (0, utils_1.getUserOperationHash)(userOperation, entryPoint, rpcHandler.config.publicClient.chain.id);
+        await rpcHandler.preMempoolChecks(opHash, userOperation, apiVersion, entryPoint);
+        // Prepare bundle
+        const userOperationInfo = {
+            userOp: userOperation,
+            entryPoint,
+            userOpHash: (0, utils_1.getUserOperationHash)(userOperation, entryPoint, rpcHandler.config.publicClient.chain.id),
+            addedToMempool: Date.now()
+        };
+        const bundle = {
+            entryPoint,
+            userOps: [userOperationInfo],
+            version: (0, utils_1.isVersion06)(userOperation)
+                ? "0.6"
+                : "0.7"
+        };
+        const result = await rpcHandler.executorManager.sendBundleToExecutor(bundle);
+        if (!result) {
+            throw new types_1.RpcError("unhandled error during bundle submission", types_1.ValidationErrors.InvalidFields);
+        }
+        // Wait for receipt.
+        const receipt = await rpcHandler.config.publicClient.waitForTransactionReceipt({
+            hash: result,
+            pollingInterval: 100
+        });
+        return (0, utils_1.parseUserOperationReceipt)(opHash, receipt);
+    }
+});
+//# sourceMappingURL=pimlico_sendUserOperationNow.js.map

package/lib/rpc/methods/pimlico_sendUserOperationNow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pimlico_sendUserOperationNow.js","sourceRoot":"","sources":["../../../rpc/methods/pimlico_sendUserOperationNow.ts"],"names":[],"mappings":";;;AAAA,uCAIoB;AACpB,gEAA4D;AAC5D,uCAMoB;AAEP,QAAA,kCAAkC,GAAG,IAAA,yCAAmB,EAAC;IAClE,MAAM,EAAE,8BAA8B;IACtC,MAAM,EAAE,yCAAiC;IACzC,OAAO,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,EAAE,EAAE;QAClD,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,6BAA6B,EAAE,CAAC;YACnD,MAAM,IAAI,gBAAQ,CACd,sDAAsD,EACtD,wBAAgB,CAAC,aAAa,CACjC,CAAA;QACL,CAAC;QAED,MAAM,CAAC,aAAa,EAAE,UAAU,CAAC,GAAG,MAAM,CAAA;QAE1C,UAAU,CAAC,2BAA2B,CAAC,UAAU,CAAC,CAAA;QAClD,MAAM,MAAM,GAAG,IAAA,4BAAoB,EAC/B,aAAa,EACb,UAAU,EACV,UAAU,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAC1C,CAAA;QAED,MAAM,UAAU,CAAC,gBAAgB,CAC7B,MAAM,EACN,aAAa,EACb,UAAU,EACV,UAAU,CACb,CAAA;QAED,iBAAiB;QACjB,MAAM,iBAAiB,GAAe;YAClC,MAAM,EAAE,aAAa;YACrB,UAAU;YACV,UAAU,EAAE,IAAA,4BAAoB,EAC5B,aAAa,EACb,UAAU,EACV,UAAU,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAC1C;YACD,cAAc,EAAE,IAAI,CAAC,GAAG,EAAE;SAC7B,CAAA;QACD,MAAM,MAAM,GAAwB;YAChC,UAAU;YACV,OAAO,EAAE,CAAC,iBAAiB,CAAC;YAC5B,OAAO,EAAE,IAAA,mBAAW,EAAC,aAAa,CAAC;gBAC/B,CAAC,CAAE,KAAe;gBAClB,CAAC,CAAE,KAAe;SACzB,CAAA;QACD,MAAM,MAAM,GACR,MAAM,UAAU,CAAC,eAAe,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAA;QAEjE,IAAI,CAAC,MAAM,EAAE,CAAC;YACV,MAAM,IAAI,gBAAQ,CACd,0CAA0C,EAC1C,wBAAgB,CAAC,aAAa,CACjC,CAAA;QACL,CAAC;QAED,oBAAoB;QACpB,MAAM,OAAO,GACT,MAAM,UAAU,CAAC,MAAM,CAAC,YAAY,CAAC,yBAAyB,CAAC;YAC3D,IAAI,EAAE,MAAM;YACZ,eAAe,EAAE,GAAG;SACvB,CAAC,CAAA;QAEN,OAAO,IAAA,iCAAyB,EAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACrD,CAAC;CACJ,CAAC,CAAA"}

package/lib/rpc/rpcHandler.d.ts

@@ -1,35 +1,27 @@
 import type { Executor, ExecutorManager } from "../executor/index.js";
 import type { EventManager, GasPriceManager } from "../handlers/index.js";
-import type { InterfaceReputationManager, MemoryMempool, Monitor } from "../mempool/index.js";
-import type { ApiVersion, BundlerClearReputationResponseResult, StateOverrides } from "../types/index.js";
-import { type Address, type BundlerClearMempoolResponseResult, type BundlerClearStateResponseResult, type BundlerDumpMempoolResponseResult, type BundlerDumpReputationsResponseResult, type BundlerGetStakeStatusResponseResult, type BundlerRequest, type BundlerResponse, type BundlerSendBundleNowResponseResult, type BundlerSetBundlingModeResponseResult, type BundlerSetReputationsRequestParams, type BundlingMode, type ChainIdResponseResult, type EstimateUserOperationGasResponseResult, type GetUserOperationByHashResponseResult, type GetUserOperationReceiptResponseResult, type HexData32, type InterfaceValidator, type PimlicoGetUserOperationGasPriceResponseResult, type PimlicoGetUserOperationStatusResponseResult, type SendUserOperationResponseResult, type SupportedEntryPointsResponseResult, type UserOperation } from "../types/index.js";
+import type { InterfaceReputationManager, MemoryMempool, Monitor, NonceQueuer } from "../mempool/index.js";
+import type { ApiVersion, BundlerRequest, StateOverrides } from "../types/index.js";
+import { type Address, type InterfaceValidator, type UserOperation } from "../types/index.js";
 import type { Logger, Metrics } from "../utils/index.js";
 import { type Hex } from "viem";
-import type { NonceQueuer } from "./nonceQueuer.js";
 import type { AltoConfig } from "../createConfig.js";
-export interface IRpcEndpoint {
-    handleMethod(request: BundlerRequest, apiVersion: ApiVersion): Promise<BundlerResponse>;
-    eth_chainId(): ChainIdResponseResult;
-    eth_supportedEntryPoints(): SupportedEntryPointsResponseResult;
-    eth_estimateUserOperationGas(apiVersion: ApiVersion, userOperation: UserOperation, entryPoint: Address, stateOverrides?: StateOverrides): Promise<EstimateUserOperationGasResponseResult>;
-    eth_sendUserOperation(apiVersion: ApiVersion, userOperation: UserOperation, entryPoint: Address): Promise<SendUserOperationResponseResult>;
-    eth_getUserOperationByHash(userOperationHash: HexData32): Promise<GetUserOperationByHashResponseResult>;
-    eth_getUserOperationReceipt(userOperationHash: HexData32): Promise<GetUserOperationReceiptResponseResult>;
-}
-export declare class RpcHandler implements IRpcEndpoint {
+import type { MethodHandler } from "./createMethodHandler.js";
+export declare class RpcHandler {
     config: AltoConfig;
     validator: InterfaceValidator;
     mempool: MemoryMempool;
     executor: Executor;
     monitor: Monitor;
     nonceQueuer: NonceQueuer;
-    logger: Logger;
-    metrics: Metrics;
     executorManager: ExecutorManager;
     reputationManager: InterfaceReputationManager;
-    gasPriceManager: GasPriceManager;
+    metrics: Metrics;
     eventManager: EventManager;
-    constructor({ config, validator, mempool, executor, monitor, nonceQueuer, executorManager, reputationManager, metrics, gasPriceManager, eventManager }: {
+    gasPriceManager: GasPriceManager;
+    logger: Logger;
+    private methodHandlers;
+    constructor({ config, validator, mempool, executor, monitor, nonceQueuer, executorManager, reputationManager, metrics, eventManager, gasPriceManager }: {
         config: AltoConfig;
         validator: InterfaceValidator;
         mempool: MemoryMempool;
@@ -42,96 +34,13 @@ export declare class RpcHandler implements IRpcEndpoint {
         eventManager: EventManager;
         gasPriceManager: GasPriceManager;
     });
-    handleMethod(request: BundlerRequest, apiVersion: ApiVersion): Promise<BundlerResponse>;
+    registerHandler(handler: MethodHandler): void;
+    handleMethod(request: BundlerRequest, apiVersion: ApiVersion): Promise<any>;
     ensureEntryPointIsSupported(entryPoint: Address): void;
     ensureDebugEndpointsAreEnabled(methodName: string): void;
+    ensureExperimentalEndpointsAreEnabled(methodName: string): void;
     preMempoolChecks(opHash: Hex, userOperation: UserOperation, apiVersion: ApiVersion, entryPoint: Address): Promise<void>;
-    eth_chainId(): ChainIdResponseResult;
-    eth_supportedEntryPoints(): SupportedEntryPointsResponseResult;
-    eth_estimateUserOperationGas(apiVersion: ApiVersion, userOperation: UserOperation, entryPoint: Address, stateOverrides?: StateOverrides): Promise<EstimateUserOperationGasResponseResult>;
-    eth_sendUserOperation(apiVersion: ApiVersion, userOperation: UserOperation, entryPoint: Address): Promise<SendUserOperationResponseResult>;
-    eth_getUserOperationByHash(userOperationHash: HexData32): Promise<GetUserOperationByHashResponseResult>;
-    eth_getUserOperationReceipt(userOperationHash: HexData32): Promise<GetUserOperationReceiptResponseResult>;
-    debug_bundler_clearState(): BundlerClearStateResponseResult;
-    debug_bundler_clearMempool(): BundlerClearMempoolResponseResult;
-    debug_bundler_dumpMempool(entryPoint: Address): Promise<BundlerDumpMempoolResponseResult>;
-    debug_bundler_sendBundleNow(): Promise<BundlerSendBundleNowResponseResult>;
-    debug_bundler_setBundlingMode(bundlingMode: BundlingMode): Promise<BundlerSetBundlingModeResponseResult>;
-    debug_bundler_dumpReputation(entryPoint: Address): BundlerDumpReputationsResponseResult;
-    debug_bundler_getStakeStatus(address: Address, entryPoint: Address): Promise<BundlerGetStakeStatusResponseResult>;
-    debug_bundler_setReputation(args: BundlerSetReputationsRequestParams): BundlerSetBundlingModeResponseResult;
-    debug_bundler_clearReputation(): BundlerClearReputationResponseResult;
-    pimlico_getUserOperationStatus(userOperationHash: HexData32): PimlicoGetUserOperationStatusResponseResult;
-    pimlico_getUserOperationGasPrice(): Promise<PimlicoGetUserOperationGasPriceResponseResult>;
     addToMempoolIfValid(userOperation: UserOperation, entryPoint: Address, apiVersion: ApiVersion): Promise<"added" | "queued">;
-    pimlico_experimental_estimateUserOperationGas7702(apiVersion: ApiVersion, userOperation: UserOperation, entryPoint: Address, stateOverrides?: StateOverrides): Promise<{
-        preVerificationGas: bigint;
-        verificationGasLimit: bigint;
-        callGasLimit: bigint;
-        paymasterVerificationGasLimit: bigint;
-        paymasterPostOpGasLimit: bigint;
-        verificationGas?: undefined;
-    } | {
-        preVerificationGas: bigint;
-        verificationGasLimit: bigint;
-        callGasLimit: bigint;
-        paymasterVerificationGasLimit?: undefined;
-        paymasterPostOpGasLimit?: undefined;
-        verificationGas?: undefined;
-    } | {
-        preVerificationGas: bigint;
-        verificationGas: bigint;
-        verificationGasLimit: bigint;
-        callGasLimit: bigint;
-        paymasterVerificationGasLimit?: undefined;
-        paymasterPostOpGasLimit?: undefined;
-    }>;
-    pimlico_experimental_sendUserOperation7702(apiVersion: ApiVersion, userOperation: UserOperation, entryPoint: Address): Promise<`0x${string}`>;
-    pimlico_sendUserOperationNow(apiVersion: ApiVersion, userOperation: UserOperation, entryPoint: Address): Promise<{
-        sender: `0x${string}`;
-        userOpHash: `0x${string}`;
-        nonce: bigint;
-        success: boolean;
-        actualGasCost: bigint;
-        actualGasUsed: bigint;
-        entryPoint: `0x${string}`;
-        logs: {
-            address: `0x${string}`;
-            data: `0x${string}`;
-            blockNumber: bigint;
-            blockHash: `0x${string}`;
-            transactionHash: `0x${string}`;
-            logIndex: bigint;
-            transactionIndex: bigint;
-            topics: `0x${string}`[];
-        }[];
-        receipt: {
-            to: `0x${string}` | null;
-            gasUsed: bigint;
-            status: bigint | null;
-            contractAddress: `0x${string}` | null;
-            blockNumber: bigint;
-            blockHash: `0x${string}`;
-            transactionHash: `0x${string}`;
-            transactionIndex: bigint;
-            from: `0x${string}`;
-            cumulativeGasUsed: bigint;
-            logs: {
-                address: `0x${string}`;
-                data: `0x${string}`;
-                blockNumber: bigint;
-                blockHash: `0x${string}`;
-                transactionHash: `0x${string}`;
-                logIndex: bigint;
-                transactionIndex: bigint;
-                topics: `0x${string}`[];
-            }[];
-            logsBloom: string;
-            effectiveGasPrice?: bigint | null | undefined;
-        };
-        paymaster?: `0x${string}` | undefined;
-        reason?: `0x${string}` | undefined;
-    }>;
     validateEip7702Auth(userOperation: UserOperation): Promise<void>;
     getNonceValue(userOperation: UserOperation, entryPoint: Address): Promise<bigint>;
     estimateGas({ apiVersion, userOperation, entryPoint, stateOverrides }: {

package/lib/rpc/rpcHandler.js

@@ -6,6 +6,7 @@ const utils_1 = require("../utils/index.js");
 const viem_1 = require("viem");
 const chains_1 = require("viem/chains");
 const experimental_1 = require("viem/experimental");
+const methods_1 = require("./methods/index.js");
 class RpcHandler {
     config;
     validator;
@@ -13,133 +14,44 @@ class RpcHandler {
     executor;
     monitor;
     nonceQueuer;
-    logger;
-    metrics;
     executorManager;
     reputationManager;
-    gasPriceManager;
+    metrics;
     eventManager;
-    constructor({ config, validator, mempool, executor, monitor, nonceQueuer, executorManager, reputationManager, metrics, gasPriceManager, eventManager }) {
+    gasPriceManager;
+    logger;
+    methodHandlers;
+    constructor({ config, validator, mempool, executor, monitor, nonceQueuer, executorManager, reputationManager, metrics, eventManager, gasPriceManager }) {
         this.config = config;
         this.validator = validator;
         this.mempool = mempool;
         this.executor = executor;
         this.monitor = monitor;
         this.nonceQueuer = nonceQueuer;
-        this.logger = config.getLogger({ module: "rpc" }, {
-            level: config.rpcLogLevel || config.logLevel
-        });
-        this.metrics = metrics;
         this.executorManager = executorManager;
         this.reputationManager = reputationManager;
-        this.gasPriceManager = gasPriceManager;
+        this.metrics = metrics;
         this.eventManager = eventManager;
+        this.gasPriceManager = gasPriceManager;
+        this.logger = config.getLogger({ module: "rpc" }, {
+            level: config.rpcLogLevel || config.logLevel
+        });
+        this.methodHandlers = new Map();
+        (0, methods_1.registerHandlers)(this);
+    }
+    registerHandler(handler) {
+        this.methodHandlers.set(handler.method, handler);
     }
     async handleMethod(request, apiVersion) {
-        // call the method with the params
-        const method = request.method;
-        switch (method) {
-            case "eth_chainId":
-                return {
-                    method,
-                    result: this.eth_chainId(...request.params)
-                };
-            case "eth_supportedEntryPoints":
-                return {
-                    method,
-                    result: this.eth_supportedEntryPoints(...request.params)
-                };
-            case "eth_estimateUserOperationGas":
-                return {
-                    method,
-                    result: await this.eth_estimateUserOperationGas(apiVersion, request.params[0], request.params[1], request.params[2])
-                };
-            case "eth_sendUserOperation":
-                return {
-                    method,
-                    result: await this.eth_sendUserOperation(apiVersion, ...request.params)
-                };
-            case "eth_getUserOperationByHash":
-                return {
-                    method,
-                    result: await this.eth_getUserOperationByHash(...request.params)
-                };
-            case "eth_getUserOperationReceipt":
-                return {
-                    method,
-                    result: await this.eth_getUserOperationReceipt(...request.params)
-                };
-            case "debug_bundler_clearMempool":
-                return {
-                    method,
-                    result: this.debug_bundler_clearMempool(...request.params)
-                };
-            case "debug_bundler_clearState":
-                return {
-                    method,
-                    result: this.debug_bundler_clearState(...request.params)
-                };
-            case "debug_bundler_dumpMempool":
-                return {
-                    method,
-                    result: await this.debug_bundler_dumpMempool(...request.params)
-                };
-            case "debug_bundler_sendBundleNow":
-                return {
-                    method,
-                    result: await this.debug_bundler_sendBundleNow(...request.params)
-                };
-            case "debug_bundler_setBundlingMode":
-                return {
-                    method,
-                    result: await this.debug_bundler_setBundlingMode(...request.params)
-                };
-            case "debug_bundler_clearReputation":
-                return {
-                    method,
-                    result: this.debug_bundler_clearReputation(...request.params)
-                };
-            case "debug_bundler_setReputation":
-                return {
-                    method,
-                    result: this.debug_bundler_setReputation(request.params)
-                };
-            case "debug_bundler_dumpReputation":
-                return {
-                    method,
-                    result: this.debug_bundler_dumpReputation(...request.params)
-                };
-            case "debug_bundler_getStakeStatus":
-                return {
-                    method,
-                    result: await this.debug_bundler_getStakeStatus(...request.params)
-                };
-            case "pimlico_getUserOperationStatus":
-                return {
-                    method,
-                    result: this.pimlico_getUserOperationStatus(...request.params)
-                };
-            case "pimlico_getUserOperationGasPrice":
-                return {
-                    method,
-                    result: await this.pimlico_getUserOperationGasPrice(...request.params)
-                };
-            case "pimlico_sendUserOperationNow":
-                return {
-                    method,
-                    result: await this.pimlico_sendUserOperationNow(apiVersion, ...request.params)
-                };
-            case "pimlico_experimental_sendUserOperation7702":
-                return {
-                    method,
-                    result: await this.pimlico_experimental_sendUserOperation7702(apiVersion, ...request.params)
-                };
-            case "pimlico_experimental_estimateUserOperationGas7702":
-                return {
-                    method,
-                    result: await this.pimlico_experimental_estimateUserOperationGas7702(apiVersion, request.params[0], request.params[1], request.params[2])
-                };
-        }
+        const handler = this.methodHandlers.get(request.method);
+        if (!handler) {
+            throw new types_1.RpcError("Method not supported", types_1.ValidationErrors.InvalidFields);
+        }
+        return await handler.handler({
+            rpcHandler: this,
+            params: request.params,
+            apiVersion
+        });
     }
     ensureEntryPointIsSupported(entryPoint) {
         if (!this.config.entrypoints.includes(entryPoint)) {
@@ -151,6 +63,11 @@ class RpcHandler {
             throw new types_1.RpcError(`${methodName} is only available in development environment`);
         }
     }
+    ensureExperimentalEndpointsAreEnabled(methodName) {
+        if (!this.config.enableExperimental7702Endpoints) {
+            throw new types_1.RpcError(`${methodName} endpoint is not enabled`, types_1.ValidationErrors.InvalidFields);
+        }
+    }
     async preMempoolChecks(opHash, userOperation, apiVersion, entryPoint) {
         if (this.config.legacyTransactions &&
             userOperation.maxFeePerGas !== userOperation.maxPriorityFeePerGas) {
@@ -193,208 +110,6 @@ class RpcHandler {
             }
         }
     }
-    eth_chainId() {
-        return BigInt(this.config.publicClient.chain.id);
-    }
-    eth_supportedEntryPoints() {
-        return this.config.entrypoints;
-    }
-    async eth_estimateUserOperationGas(apiVersion, userOperation, entryPoint, stateOverrides) {
-        return await this.estimateGas({
-            apiVersion,
-            userOperation,
-            entryPoint,
-            stateOverrides
-        });
-    }
-    async eth_sendUserOperation(apiVersion, userOperation, entryPoint) {
-        const hash = (0, utils_1.getUserOperationHash)(userOperation, entryPoint, this.config.publicClient.chain.id);
-        this.eventManager.emitReceived(hash);
-        let status = "rejected";
-        try {
-            status = await this.addToMempoolIfValid(userOperation, entryPoint, apiVersion);
-            return hash;
-        }
-        catch (error) {
-            status = "rejected";
-            throw error;
-        }
-        finally {
-            this.metrics.userOperationsReceived
-                .labels({
-                status,
-                type: "regular"
-            })
-                .inc();
-        }
-    }
-    async eth_getUserOperationByHash(userOperationHash) {
-        const userOperationEventAbiItem = (0, viem_1.getAbiItem)({
-            abi: types_1.EntryPointV06Abi,
-            name: "UserOperationEvent"
-        });
-        let fromBlock;
-        let toBlock;
-        if (this.config.maxBlockRange !== undefined) {
-            const latestBlock = await this.config.publicClient.getBlockNumber();
-            fromBlock = latestBlock - BigInt(this.config.maxBlockRange);
-            if (fromBlock < 0n) {
-                fromBlock = 0n;
-            }
-            toBlock = "latest";
-        }
-        const filterResult = await this.config.publicClient.getLogs({
-            address: this.config.entrypoints,
-            event: userOperationEventAbiItem,
-            fromBlock,
-            toBlock,
-            args: {
-                userOpHash: userOperationHash
-            }
-        });
-        if (filterResult.length === 0) {
-            return null;
-        }
-        const userOperationEvent = filterResult[0];
-        const txHash = userOperationEvent.transactionHash;
-        if (txHash === null) {
-            // transaction pending
-            return null;
-        }
-        const getTransaction = async (txHash) => {
-            try {
-                return await this.config.publicClient.getTransaction({
-                    hash: txHash
-                });
-            }
-            catch (e) {
-                if (e instanceof viem_1.TransactionNotFoundError) {
-                    return getTransaction(txHash);
-                }
-                throw e;
-            }
-        };
-        const tx = await getTransaction(txHash);
-        if (!tx.to) {
-            return null;
-        }
-        let op;
-        try {
-            const decoded = (0, viem_1.decodeFunctionData)({
-                abi: [...types_1.EntryPointV06Abi, ...types_1.EntryPointV07Abi],
-                data: tx.input
-            });
-            if (decoded.functionName !== "handleOps") {
-                return null;
-            }
-            const ops = decoded.args[0];
-            const foundOp = ops.find((op) => op.sender === userOperationEvent.args.sender &&
-                op.nonce === userOperationEvent.args.nonce);
-            if (foundOp === undefined) {
-                return null;
-            }
-            const handleOpsV07AbiItem = (0, viem_1.getAbiItem)({
-                abi: types_1.EntryPointV07Abi,
-                name: "handleOps"
-            });
-            const handleOpsV07Selector = (0, viem_1.toFunctionSelector)(handleOpsV07AbiItem);
-            if ((0, viem_1.slice)(tx.input, 0, 4) === handleOpsV07Selector) {
-                op = (0, utils_1.toUnpackedUserOperation)(foundOp);
-            }
-            else {
-                op = foundOp;
-            }
-        }
-        catch {
-            return null;
-        }
-        const result = {
-            userOperation: Object.fromEntries(Object.entries(op).filter(([_, v]) => v !== null)),
-            entryPoint: (0, viem_1.getAddress)(tx.to),
-            transactionHash: txHash,
-            blockHash: tx.blockHash ?? "0x",
-            blockNumber: BigInt(tx.blockNumber ?? 0n)
-        };
-        return result;
-    }
-    eth_getUserOperationReceipt(userOperationHash) {
-        return this.executorManager.getUserOperationReceipt(userOperationHash);
-    }
-    debug_bundler_clearState() {
-        this.ensureDebugEndpointsAreEnabled("debug_bundler_clearState");
-        this.mempool.clear();
-        this.reputationManager.clear();
-        return "ok";
-    }
-    debug_bundler_clearMempool() {
-        this.ensureDebugEndpointsAreEnabled("debug_bundler_clearMempool");
-        this.mempool.clear();
-        this.reputationManager.clearEntityCount();
-        return "ok";
-    }
-    debug_bundler_dumpMempool(entryPoint) {
-        this.ensureDebugEndpointsAreEnabled("debug_bundler_dumpMempool");
-        this.ensureEntryPointIsSupported(entryPoint);
-        return Promise.resolve(this.mempool.dumpOutstanding());
-    }
-    async debug_bundler_sendBundleNow() {
-        this.ensureDebugEndpointsAreEnabled("debug_bundler_sendBundleNow");
-        await this.executorManager.sendBundleNow();
-        return "ok";
-    }
-    async debug_bundler_setBundlingMode(bundlingMode) {
-        this.ensureDebugEndpointsAreEnabled("debug_bundler_setBundlingMode");
-        await this.executorManager.setBundlingMode(bundlingMode);
-        return "ok";
-    }
-    debug_bundler_dumpReputation(entryPoint) {
-        this.ensureDebugEndpointsAreEnabled("debug_bundler_setReputation");
-        this.ensureEntryPointIsSupported(entryPoint);
-        return this.reputationManager.dumpReputations(entryPoint);
-    }
-    async debug_bundler_getStakeStatus(address, entryPoint) {
-        this.ensureDebugEndpointsAreEnabled("debug_bundler_getStakeStatus");
-        this.ensureEntryPointIsSupported(entryPoint);
-        return types_1.bundlerGetStakeStatusResponseSchema.parse({
-            method: "debug_bundler_getStakeStatus",
-            result: await this.reputationManager.getStakeStatus(entryPoint, address)
-        }).result;
-    }
-    debug_bundler_setReputation(args) {
-        this.ensureDebugEndpointsAreEnabled("debug_bundler_setReputation");
-        this.reputationManager.setReputation(args[1], args[0]);
-        return "ok";
-    }
-    debug_bundler_clearReputation() {
-        this.ensureDebugEndpointsAreEnabled("debug_bundler_clearReputation");
-        this.reputationManager.clear();
-        return "ok";
-    }
-    pimlico_getUserOperationStatus(userOperationHash) {
-        return this.monitor.getUserOperationStatus(userOperationHash);
-    }
-    async pimlico_getUserOperationGasPrice() {
-        let { maxFeePerGas, maxPriorityFeePerGas } = await this.gasPriceManager.getGasPrice();
-        if (this.config.chainType === "hedera") {
-            maxFeePerGas /= 10n ** 9n;
-            maxPriorityFeePerGas /= 10n ** 9n;
-        }
-        const { slow, standard, fast } = this.config.gasPriceMultipliers;
-        return {
-            slow: {
-                maxFeePerGas: (maxFeePerGas * slow) / 100n,
-                maxPriorityFeePerGas: (maxPriorityFeePerGas * slow) / 100n
-            },
-            standard: {
-                maxFeePerGas: (maxFeePerGas * standard) / 100n,
-                maxPriorityFeePerGas: (maxPriorityFeePerGas * standard) / 100n
-            },
-            fast: {
-                maxFeePerGas: (maxFeePerGas * fast) / 100n,
-                maxPriorityFeePerGas: (maxPriorityFeePerGas * fast) / 100n
-            }
-        };
-    }
     // check if we want to bundle userOperation. If yes, add to mempool
     async addToMempoolIfValid(userOperation, entryPoint, apiVersion) {
         this.ensureEntryPointIsSupported(entryPoint);
@@ -449,60 +164,6 @@ class RpcHandler {
         }
         return "added";
     }
-    async pimlico_experimental_estimateUserOperationGas7702(apiVersion, userOperation, entryPoint, stateOverrides) {
-        if (!this.config.enableExperimental7702Endpoints) {
-            throw new types_1.RpcError("pimlico_experimental_estimateUserOperationGas7702 endpoint is not enabled", types_1.ValidationErrors.InvalidFields);
-        }
-        await this.validateEip7702Auth(userOperation);
-        return await this.estimateGas({
-            apiVersion,
-            userOperation,
-            entryPoint,
-            stateOverrides
-        });
-    }
-    async pimlico_experimental_sendUserOperation7702(apiVersion, userOperation, entryPoint) {
-        if (!this.config.enableExperimental7702Endpoints) {
-            throw new types_1.RpcError("pimlico_experimental_sendUserOperation7702 endpoint is not enabled", types_1.ValidationErrors.InvalidFields);
-        }
-        this.ensureEntryPointIsSupported(entryPoint);
-        await this.validateEip7702Auth(userOperation);
-        await this.addToMempoolIfValid(userOperation, entryPoint, apiVersion);
-        return (0, utils_1.getUserOperationHash)(userOperation, entryPoint, this.config.publicClient.chain.id);
-    }
-    async pimlico_sendUserOperationNow(apiVersion, userOperation, entryPoint) {
-        if (!this.config.enableInstantBundlingEndpoint) {
-            throw new types_1.RpcError("pimlico_sendUserOperationNow endpoint is not enabled", types_1.ValidationErrors.InvalidFields);
-        }
-        this.ensureEntryPointIsSupported(entryPoint);
-        const opHash = (0, utils_1.getUserOperationHash)(userOperation, entryPoint, this.config.publicClient.chain.id);
-        await this.preMempoolChecks(opHash, userOperation, apiVersion, entryPoint);
-        // Prepare bundle
-        const userOperationInfo = {
-            userOp: userOperation,
-            entryPoint,
-            userOpHash: (0, utils_1.getUserOperationHash)(userOperation, entryPoint, this.config.publicClient.chain.id),
-            addedToMempool: Date.now()
-        };
-        const bundle = {
-            entryPoint,
-            userOps: [userOperationInfo],
-            version: (0, utils_1.isVersion06)(userOperation)
-                ? "0.6"
-                : "0.7"
-        };
-        const result = await this.executorManager.sendBundleToExecutor(bundle);
-        if (!result) {
-            throw new types_1.RpcError("unhandled error during bundle submission", types_1.ValidationErrors.InvalidFields);
-        }
-        // Wait for receipt.
-        const receipt = await this.config.publicClient.waitForTransactionReceipt({
-            hash: result,
-            pollingInterval: 100
-        });
-        const userOperationReceipt = (0, utils_1.parseUserOperationReceipt)(opHash, receipt);
-        return userOperationReceipt;
-    }
     async validateEip7702Auth(userOperation) {
         if (!userOperation.eip7702auth) {
             throw new types_1.RpcError("UserOperation is missing eip7702auth", types_1.ValidationErrors.InvalidFields);
@@ -541,7 +202,7 @@ class RpcHandler {
     }
     async estimateGas({ apiVersion, userOperation, entryPoint, stateOverrides }) {
         this.ensureEntryPointIsSupported(entryPoint);
-        if (userOperation.maxFeePerGas === 0n) {
+        if (userOperation.maxFeePerGas === 0n && !this.config.isGasFreeChain) {
             throw new types_1.RpcError("user operation max fee per gas must be larger than 0 during gas estimation");
         }
         // Check if the nonce is valid