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

package/esm/rpc/methods/pimlico_sendUserOperationNow.js

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

package/esm/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,OAAO,EACH,oBAAoB,EACpB,WAAW,EACX,yBAAyB,EAC5B,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AAC5D,OAAO,EACH,QAAQ,EAGR,gBAAgB,EAChB,iCAAiC,EACpC,MAAM,aAAa,CAAA;AAEpB,MAAM,CAAC,MAAM,kCAAkC,GAAG,mBAAmB,CAAC;IAClE,MAAM,EAAE,8BAA8B;IACtC,MAAM,EAAE,iCAAiC;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,QAAQ,CACd,sDAAsD,EACtD,gBAAgB,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,oBAAoB,CAC/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,oBAAoB,CAC5B,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,WAAW,CAAC,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,QAAQ,CACd,0CAA0C,EAC1C,gBAAgB,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,yBAAyB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACrD,CAAC;CACJ,CAAC,CAAA"}

package/esm/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/esm/rpc/rpcHandler.js

@@ -1,8 +1,9 @@
-import { EntryPointV06Abi, EntryPointV07Abi, RpcError, ValidationErrors, bundlerGetStakeStatusResponseSchema } from "../types/index.js";
-import { calcPreVerificationGas, calcVerificationGasAndCallGasLimit, deepHexlify, getAAError, getNonceKeyAndSequence, getUserOperationHash, isVersion06, isVersion07, maxBigInt, parseUserOperationReceipt, scaleBigIntByPercent, toUnpackedUserOperation } from "../utils/index.js";
-import { TransactionNotFoundError, decodeFunctionData, getAbiItem, getAddress, getContract, slice, toFunctionSelector } from "viem";
+import { EntryPointV06Abi, EntryPointV07Abi, RpcError, ValidationErrors } from "../types/index.js";
+import { calcPreVerificationGas, calcVerificationGasAndCallGasLimit, deepHexlify, getAAError, getNonceKeyAndSequence, getUserOperationHash, isVersion06, isVersion07, maxBigInt, scaleBigIntByPercent } from "../utils/index.js";
+import { getContract } from "viem";
 import { base, baseSepolia, optimism } from "viem/chains";
 import { recoverAuthorizationAddress } from "viem/experimental";
+import { registerHandlers } from "./methods/index.js";
 export class RpcHandler {
     config;
     validator;
@@ -10,133 +11,44 @@ export 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();
+        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 RpcError("Method not supported", ValidationErrors.InvalidFields);
+        }
+        return await handler.handler({
+            rpcHandler: this,
+            params: request.params,
+            apiVersion
+        });
     }
     ensureEntryPointIsSupported(entryPoint) {
         if (!this.config.entrypoints.includes(entryPoint)) {
@@ -148,6 +60,11 @@ export class RpcHandler {
             throw new RpcError(`${methodName} is only available in development environment`);
         }
     }
+    ensureExperimentalEndpointsAreEnabled(methodName) {
+        if (!this.config.enableExperimental7702Endpoints) {
+            throw new RpcError(`${methodName} endpoint is not enabled`, ValidationErrors.InvalidFields);
+        }
+    }
     async preMempoolChecks(opHash, userOperation, apiVersion, entryPoint) {
         if (this.config.legacyTransactions &&
             userOperation.maxFeePerGas !== userOperation.maxPriorityFeePerGas) {
@@ -190,208 +107,6 @@ export 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 = 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 = getAbiItem({
-            abi: 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 TransactionNotFoundError) {
-                    return getTransaction(txHash);
-                }
-                throw e;
-            }
-        };
-        const tx = await getTransaction(txHash);
-        if (!tx.to) {
-            return null;
-        }
-        let op;
-        try {
-            const decoded = decodeFunctionData({
-                abi: [...EntryPointV06Abi, ...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 = getAbiItem({
-                abi: EntryPointV07Abi,
-                name: "handleOps"
-            });
-            const handleOpsV07Selector = toFunctionSelector(handleOpsV07AbiItem);
-            if (slice(tx.input, 0, 4) === handleOpsV07Selector) {
-                op = toUnpackedUserOperation(foundOp);
-            }
-            else {
-                op = foundOp;
-            }
-        }
-        catch {
-            return null;
-        }
-        const result = {
-            userOperation: Object.fromEntries(Object.entries(op).filter(([_, v]) => v !== null)),
-            entryPoint: 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 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);
@@ -446,60 +161,6 @@ export class RpcHandler {
         }
         return "added";
     }
-    async pimlico_experimental_estimateUserOperationGas7702(apiVersion, userOperation, entryPoint, stateOverrides) {
-        if (!this.config.enableExperimental7702Endpoints) {
-            throw new RpcError("pimlico_experimental_estimateUserOperationGas7702 endpoint is not enabled", 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 RpcError("pimlico_experimental_sendUserOperation7702 endpoint is not enabled", ValidationErrors.InvalidFields);
-        }
-        this.ensureEntryPointIsSupported(entryPoint);
-        await this.validateEip7702Auth(userOperation);
-        await this.addToMempoolIfValid(userOperation, entryPoint, apiVersion);
-        return getUserOperationHash(userOperation, entryPoint, this.config.publicClient.chain.id);
-    }
-    async pimlico_sendUserOperationNow(apiVersion, userOperation, entryPoint) {
-        if (!this.config.enableInstantBundlingEndpoint) {
-            throw new RpcError("pimlico_sendUserOperationNow endpoint is not enabled", ValidationErrors.InvalidFields);
-        }
-        this.ensureEntryPointIsSupported(entryPoint);
-        const opHash = getUserOperationHash(userOperation, entryPoint, this.config.publicClient.chain.id);
-        await this.preMempoolChecks(opHash, userOperation, apiVersion, entryPoint);
-        // Prepare bundle
-        const userOperationInfo = {
-            userOp: userOperation,
-            entryPoint,
-            userOpHash: getUserOperationHash(userOperation, entryPoint, this.config.publicClient.chain.id),
-            addedToMempool: Date.now()
-        };
-        const bundle = {
-            entryPoint,
-            userOps: [userOperationInfo],
-            version: isVersion06(userOperation)
-                ? "0.6"
-                : "0.7"
-        };
-        const result = await this.executorManager.sendBundleToExecutor(bundle);
-        if (!result) {
-            throw new RpcError("unhandled error during bundle submission", ValidationErrors.InvalidFields);
-        }
-        // Wait for receipt.
-        const receipt = await this.config.publicClient.waitForTransactionReceipt({
-            hash: result,
-            pollingInterval: 100
-        });
-        const userOperationReceipt = parseUserOperationReceipt(opHash, receipt);
-        return userOperationReceipt;
-    }
     async validateEip7702Auth(userOperation) {
         if (!userOperation.eip7702auth) {
             throw new RpcError("UserOperation is missing eip7702auth", ValidationErrors.InvalidFields);
@@ -538,7 +199,7 @@ export class RpcHandler {
     }
     async estimateGas({ apiVersion, userOperation, entryPoint, stateOverrides }) {
         this.ensureEntryPointIsSupported(entryPoint);
-        if (userOperation.maxFeePerGas === 0n) {
+        if (userOperation.maxFeePerGas === 0n && !this.config.isGasFreeChain) {
             throw new RpcError("user operation max fee per gas must be larger than 0 during gas estimation");
         }
         // Check if the nonce is valid