@pimlico/alto 0.0.3 → 0.0.5

package/lib/rpc/rpcHandler.js

@@ -1,35 +1,10 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RpcHandler = void 0;
 const types_1 = require("../types/index.js");
 const utils_1 = require("../utils/index.js");
 const viem_1 = require("viem");
-const chains = __importStar(require("viem/chains"));
-const zod_1 = require("zod");
-const zod_validation_error_1 = require("zod-validation-error");
+const chains_1 = require("viem/chains");
 class RpcHandler {
     entryPoints;
     publicClient;
@@ -53,7 +28,9 @@ class RpcHandler {
     gasPriceManager;
     gasPriceMultipliers;
     paymasterGasLimitMultiplier;
-    constructor(entryPoints, publicClient, validator, mempool, executor, monitor, nonceQueuer, executorManager, reputationManager, usingTenderly, rpcMaxBlockRange, logger, metrics, enableDebugEndpoints, compressionHandler, legacyTransactions, gasPriceManager, gasPriceMultipliers, chainType, paymasterGasLimitMultiplier, dangerousSkipUserOperationValidation = false) {
+    eventManager;
+    enableInstantBundlingEndpoint;
+    constructor(entryPoints, publicClient, validator, mempool, executor, monitor, nonceQueuer, executorManager, reputationManager, usingTenderly, rpcMaxBlockRange, logger, metrics, enableDebugEndpoints, compressionHandler, legacyTransactions, gasPriceManager, gasPriceMultipliers, chainType, paymasterGasLimitMultiplier, eventManager, enableInstantBundlingEndpoint, dangerousSkipUserOperationValidation = false) {
         this.entryPoints = entryPoints;
         this.publicClient = publicClient;
         this.validator = validator;
@@ -77,6 +54,8 @@ class RpcHandler {
         this.chainType = chainType;
         this.gasPriceManager = gasPriceManager;
         this.paymasterGasLimitMultiplier = paymasterGasLimitMultiplier;
+        this.enableInstantBundlingEndpoint = enableInstantBundlingEndpoint;
+        this.eventManager = eventManager;
     }
     async handleMethod(request, apiVersion) {
         // call the method with the params
@@ -167,6 +146,47 @@ class RpcHandler {
                     method,
                     result: await this.pimlico_sendCompressedUserOperation(apiVersion, ...request.params)
                 };
+            case "pimlico_sendUserOperationNow":
+                return {
+                    method,
+                    result: await this.pimlico_sendUserOperationNow(apiVersion, ...request.params)
+                };
+        }
+    }
+    ensureEntryPointIsSupported(entryPoint) {
+        if (!this.entryPoints.includes(entryPoint)) {
+            throw new Error(`EntryPoint ${entryPoint} not supported, supported EntryPoints: ${this.entryPoints.join(", ")}`);
+        }
+    }
+    ensureDebugEndpointsAreEnabled(methodName) {
+        if (!this.enableDebugEndpoints) {
+            throw new types_1.RpcError(`${methodName} is only available in development environment`);
+        }
+    }
+    async preMempoolChecks(opHash, userOperation, apiVersion, entryPoint) {
+        if (this.legacyTransactions &&
+            userOperation.maxFeePerGas !== userOperation.maxPriorityFeePerGas) {
+            const reason = "maxPriorityFeePerGas must equal maxFeePerGas on chains that don't support EIP-1559";
+            this.eventManager.emitFailedValidation(opHash, reason);
+            throw new types_1.RpcError(reason);
+        }
+        if (apiVersion !== "v1") {
+            await this.gasPriceManager.validateGasPrice({
+                maxFeePerGas: userOperation.maxFeePerGas,
+                maxPriorityFeePerGas: userOperation.maxPriorityFeePerGas
+            });
+        }
+        if (userOperation.verificationGasLimit < 10000n) {
+            const reason = "verificationGasLimit must be at least 10000";
+            this.eventManager.emitFailedValidation(opHash, reason);
+            throw new types_1.RpcError(reason);
+        }
+        this.logger.trace({ userOperation, entryPoint }, "beginning validation");
+        if (userOperation.preVerificationGas === 0n ||
+            userOperation.verificationGasLimit === 0n) {
+            const reason = "user operation gas limits must be larger than 0";
+            this.eventManager.emitFailedValidation(opHash, reason);
+            throw new types_1.RpcError(reason);
         }
     }
     eth_chainId() {
@@ -176,10 +196,7 @@ class RpcHandler {
         return this.entryPoints;
     }
     async eth_estimateUserOperationGas(apiVersion, userOperation, entryPoint, stateOverrides) {
-        // check if entryPoint is supported, if not throw
-        if (!this.entryPoints.includes(entryPoint)) {
-            throw new Error(`EntryPoint ${entryPoint} not supported, supported EntryPoints: ${this.entryPoints.join(", ")}`);
-        }
+        this.ensureEntryPointIsSupported(entryPoint);
         if (userOperation.maxFeePerGas === 0n) {
             throw new types_1.RpcError("user operation max fee per gas must be larger than 0 during gas estimation");
         }
@@ -189,14 +206,9 @@ class RpcHandler {
         userOperation.preVerificationGas = 1000000n;
         userOperation.verificationGasLimit = 10000000n;
         userOperation.callGasLimit = 10000000n;
-        if (this.chainId === chains.base.id) {
+        if (this.chainId === chains_1.base.id) {
             userOperation.verificationGasLimit = 5000000n;
         }
-        if (this.chainId === chains.celoAlfajores.id ||
-            this.chainId === chains.celo.id) {
-            userOperation.verificationGasLimit = 1000000n;
-            userOperation.callGasLimit = 1000000n;
-        }
         if ((0, utils_1.isVersion07)(userOperation)) {
             userOperation.paymasterPostOpGasLimit = 2000000n;
             userOperation.paymasterVerificationGasLimit = 5000000n;
@@ -247,12 +259,10 @@ class RpcHandler {
             paymasterPostOpGasLimit =
                 (paymasterPostOpGasLimit * multiplier) / 100n;
         }
-        if (this.chainId === chains.base.id ||
-            this.chainId === chains.baseSepolia.id) {
+        if (this.chainId === chains_1.base.id || this.chainId === chains_1.baseSepolia.id) {
             callGasLimit += 10000n;
         }
-        if (this.chainId === chains.base.id ||
-            this.chainId === chains.optimism.id) {
+        if (this.chainId === chains_1.base.id || this.chainId === chains_1.optimism.id) {
             callGasLimit = (0, utils_1.maxBigInt)(callGasLimit, 120000n);
         }
         if (userOperation.callData === "0x") {
@@ -282,10 +292,11 @@ class RpcHandler {
         };
     }
     async eth_sendUserOperation(apiVersion, userOperation, entryPoint) {
+        const hash = (0, utils_1.getUserOperationHash)(userOperation, entryPoint, this.chainId);
+        this.eventManager.emitReceived(hash);
         let status = "rejected";
         try {
             status = await this.addToMempoolIfValid(userOperation, entryPoint, apiVersion);
-            const hash = (0, utils_1.getUserOperationHash)(userOperation, entryPoint, this.chainId);
             return hash;
         }
         catch (error) {
@@ -349,27 +360,38 @@ class RpcHandler {
         if (!tx.to) {
             return null;
         }
-        let op = undefined;
+        let op;
         try {
             const decoded = (0, viem_1.decodeFunctionData)({
-                abi: types_1.EntryPointV06Abi,
+                abi: [...types_1.EntryPointV06Abi, ...types_1.EntryPointV07Abi],
                 data: tx.input
             });
             if (decoded.functionName !== "handleOps") {
                 return null;
             }
             const ops = decoded.args[0];
-            op = ops.find((op) => op.sender === userOperationEvent.args.sender &&
+            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;
         }
-        if (op === undefined) {
-            return null;
-        }
         const result = {
-            userOperation: (0, utils_1.isVersion06)(op) ? op : (0, utils_1.toUnpackedUserOperation)(op),
+            userOperation: op,
             entryPoint: (0, viem_1.getAddress)(tx.to),
             transactionHash: txHash,
             blockHash: tx.blockHash ?? "0x",
@@ -377,211 +399,53 @@ class RpcHandler {
         };
         return result;
     }
-    async eth_getUserOperationReceipt(userOperationHash) {
-        const userOperationEventAbiItem = (0, viem_1.getAbiItem)({
-            abi: types_1.EntryPointV06Abi,
-            name: "UserOperationEvent"
-        });
-        let fromBlock = undefined;
-        let toBlock = undefined;
-        if (this.rpcMaxBlockRange !== undefined) {
-            const latestBlock = await this.publicClient.getBlockNumber();
-            fromBlock = latestBlock - BigInt(this.rpcMaxBlockRange);
-            if (fromBlock < 0n) {
-                fromBlock = 0n;
-            }
-            toBlock = "latest";
-        }
-        const filterResult = await this.publicClient.getLogs({
-            address: this.entryPoints,
-            event: userOperationEventAbiItem,
-            fromBlock,
-            toBlock,
-            args: {
-                userOpHash: userOperationHash
-            }
-        });
-        if (filterResult.length === 0) {
-            return null;
-        }
-        const userOperationEvent = filterResult[0];
-        // throw if any of the members of userOperationEvent are undefined
-        if (userOperationEvent.args.actualGasCost === undefined ||
-            userOperationEvent.args.sender === undefined ||
-            userOperationEvent.args.nonce === undefined ||
-            userOperationEvent.args.userOpHash === undefined ||
-            userOperationEvent.args.success === undefined ||
-            userOperationEvent.args.paymaster === undefined ||
-            userOperationEvent.args.actualGasUsed === undefined) {
-            throw new Error("userOperationEvent has undefined members");
-        }
-        const txHash = userOperationEvent.transactionHash;
-        if (txHash === null) {
-            // transaction pending
-            return null;
-        }
-        const getTransactionReceipt = async (txHash) => {
-            while (true) {
-                try {
-                    return await this.publicClient.getTransactionReceipt({
-                        hash: txHash
-                    });
-                }
-                catch (e) {
-                    if (e instanceof viem_1.TransactionReceiptNotFoundError) {
-                        continue;
-                    }
-                    throw e;
-                }
-            }
-        };
-        const receipt = await getTransactionReceipt(txHash);
-        const logs = receipt.logs;
-        if (logs.some((log) => log.blockHash === null ||
-            log.blockNumber === null ||
-            log.transactionIndex === null ||
-            log.transactionHash === null ||
-            log.logIndex === null ||
-            log.topics.length === 0)) {
-            // transaction pending
-            return null;
-        }
-        const userOperationRevertReasonAbi = (0, viem_1.parseAbi)([
-            "event UserOperationRevertReason(bytes32 indexed userOpHash, address indexed sender, uint256 nonce, bytes revertReason)"
-        ]);
-        const userOperationRevertReasonTopicEvent = (0, viem_1.encodeEventTopics)({
-            abi: userOperationRevertReasonAbi
-        })[0];
-        let entryPoint = viem_1.zeroAddress;
-        let revertReason = undefined;
-        let startIndex = -1;
-        let endIndex = -1;
-        logs.forEach((log, index) => {
-            if (log?.topics[0] === userOperationEvent.topics[0]) {
-                // process UserOperationEvent
-                if (log.topics[1] === userOperationEvent.topics[1]) {
-                    // it's our userOpHash. save as end of logs array
-                    endIndex = index;
-                    entryPoint = log.address;
-                }
-                else if (endIndex === -1) {
-                    // it's a different hash. remember it as beginning index, but only if we didn't find our end index yet.
-                    startIndex = index;
-                }
-            }
-            if (log?.topics[0] === userOperationRevertReasonTopicEvent) {
-                // process UserOperationRevertReason
-                if (log.topics[1] === userOperationEvent.topics[1]) {
-                    // it's our userOpHash. capture revert reason.
-                    const decodedLog = (0, viem_1.decodeEventLog)({
-                        abi: userOperationRevertReasonAbi,
-                        data: log.data,
-                        topics: log.topics
-                    });
-                    revertReason = decodedLog.args.revertReason;
-                }
-            }
-        });
-        if (endIndex === -1) {
-            throw new Error("fatal: no UserOperationEvent in logs");
-        }
-        const filteredLogs = logs.slice(startIndex + 1, endIndex);
-        const logsParsing = zod_1.z.array(types_1.logSchema).safeParse(filteredLogs);
-        if (!logsParsing.success) {
-            const err = (0, zod_validation_error_1.fromZodError)(logsParsing.error);
-            throw err;
-        }
-        const receiptParsing = types_1.receiptSchema.safeParse({
-            ...receipt,
-            status: receipt.status === "success" ? 1 : 0
-        });
-        if (!receiptParsing.success) {
-            const err = (0, zod_validation_error_1.fromZodError)(receiptParsing.error);
-            throw err;
-        }
-        let paymaster = userOperationEvent.args.paymaster;
-        paymaster = paymaster === viem_1.zeroAddress ? undefined : paymaster;
-        const userOperationReceipt = {
-            userOpHash: userOperationHash,
-            entryPoint,
-            sender: userOperationEvent.args.sender,
-            nonce: userOperationEvent.args.nonce,
-            paymaster,
-            actualGasUsed: userOperationEvent.args.actualGasUsed,
-            actualGasCost: userOperationEvent.args.actualGasCost,
-            success: userOperationEvent.args.success,
-            reason: revertReason,
-            logs: logsParsing.data,
-            receipt: receiptParsing.data
-        };
-        return userOperationReceipt;
+    eth_getUserOperationReceipt(userOperationHash) {
+        return this.executorManager.getUserOperationReceipt(userOperationHash);
     }
     debug_bundler_clearState() {
-        if (!this.enableDebugEndpoints) {
-            throw new types_1.RpcError("debug_bundler_clearState is only available in development environment");
-        }
+        this.ensureDebugEndpointsAreEnabled("debug_bundler_clearState");
         this.mempool.clear();
         this.reputationManager.clear();
         return "ok";
     }
     debug_bundler_clearMempool() {
-        if (!this.enableDebugEndpoints) {
-            throw new types_1.RpcError("debug_bundler_clearMempool is only available in development environment");
-        }
+        this.ensureDebugEndpointsAreEnabled("debug_bundler_clearMempool");
         this.mempool.clear();
         this.reputationManager.clearEntityCount();
         return "ok";
     }
     async debug_bundler_dumpMempool(entryPoint) {
-        if (!this.enableDebugEndpoints) {
-            throw new types_1.RpcError("debug_bundler_dumpMempool is only available in development environment");
-        }
-        if (!this.entryPoints.includes(entryPoint)) {
-            throw new types_1.RpcError(`EntryPoint ${entryPoint} not supported, supported EntryPoints: ${this.entryPoints.join(", ")}`);
-        }
+        this.ensureDebugEndpointsAreEnabled("debug_bundler_dumpMempool");
+        this.ensureEntryPointIsSupported(entryPoint);
         return this.mempool
             .dumpOutstanding()
             .map((userOpInfo) => (0, types_1.deriveUserOperation)(userOpInfo.mempoolUserOperation));
     }
     async debug_bundler_sendBundleNow() {
-        if (!this.enableDebugEndpoints) {
-            throw new types_1.RpcError("debug_bundler_sendBundleNow is only available in development environment");
-        }
+        this.ensureDebugEndpointsAreEnabled("debug_bundler_sendBundleNow");
         const transactions = await this.executorManager.bundleNow();
         return transactions[0];
     }
     debug_bundler_setBundlingMode(bundlingMode) {
-        if (!this.enableDebugEndpoints) {
-            throw new types_1.RpcError("debug_bundler_setBundlingMode is only available in development environment");
-        }
+        this.ensureDebugEndpointsAreEnabled("debug_bundler_setBundlingMode");
         this.executorManager.setBundlingMode(bundlingMode);
         return "ok";
     }
     debug_bundler_dumpReputation(entryPoint) {
-        if (!this.enableDebugEndpoints) {
-            throw new types_1.RpcError("debug_bundler_setRe is only available in development environment");
-        }
-        if (!this.entryPoints.includes(entryPoint)) {
-            throw new types_1.RpcError(`EntryPoint ${entryPoint} not supported, supported EntryPoints: ${this.entryPoints.join(", ")}`);
-        }
+        this.ensureDebugEndpointsAreEnabled("debug_bundler_setReputation");
+        this.ensureEntryPointIsSupported(entryPoint);
         return this.reputationManager.dumpReputations(entryPoint);
     }
     async debug_bundler_getStakeStatus(address, entryPoint) {
-        if (!this.enableDebugEndpoints) {
-            throw new types_1.RpcError("debug_bundler_getStakeStatus is only available in development environment");
-        }
-        if (!this.entryPoints.includes(entryPoint)) {
-            throw new types_1.RpcError(`EntryPoint ${entryPoint} not supported, supported EntryPoints: ${this.entryPoints.join(", ")}`);
-        }
+        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) {
-        if (!this.enableDebugEndpoints) {
-            throw new types_1.RpcError("debug_bundler_setReputation is only available in development environment");
-        }
+        this.ensureDebugEndpointsAreEnabled("debug_bundler_setReputation");
         this.reputationManager.setReputation(args[1], args[0]);
         return "ok";
     }
@@ -589,57 +453,44 @@ class RpcHandler {
         return this.monitor.getUserOperationStatus(userOperationHash);
     }
     async pimlico_getUserOperationGasPrice() {
-        const gasPrice = await this.gasPriceManager.getGasPrice();
+        let { maxFeePerGas, maxPriorityFeePerGas } = await this.gasPriceManager.getGasPrice();
+        if (this.chainType === "hedera") {
+            maxFeePerGas /= 10n ** 9n;
+            maxPriorityFeePerGas /= 10n ** 9n;
+        }
         const { slow, standard, fast } = this.gasPriceMultipliers;
         return {
             slow: {
-                maxFeePerGas: (gasPrice.maxFeePerGas * slow) / 100n,
-                maxPriorityFeePerGas: (gasPrice.maxPriorityFeePerGas * slow) / 100n
+                maxFeePerGas: (maxFeePerGas * slow) / 100n,
+                maxPriorityFeePerGas: (maxPriorityFeePerGas * slow) / 100n
             },
             standard: {
-                maxFeePerGas: (gasPrice.maxFeePerGas * standard) / 100n,
-                maxPriorityFeePerGas: (gasPrice.maxPriorityFeePerGas * standard) / 100n
+                maxFeePerGas: (maxFeePerGas * standard) / 100n,
+                maxPriorityFeePerGas: (maxPriorityFeePerGas * standard) / 100n
             },
             fast: {
-                maxFeePerGas: (gasPrice.maxFeePerGas * fast) / 100n,
-                maxPriorityFeePerGas: (gasPrice.maxPriorityFeePerGas * fast) / 100n
+                maxFeePerGas: (maxFeePerGas * fast) / 100n,
+                maxPriorityFeePerGas: (maxPriorityFeePerGas * fast) / 100n
             }
         };
     }
     // check if we want to bundle userOperation. If yes, add to mempool
     async addToMempoolIfValid(op, entryPoint, apiVersion) {
+        this.ensureEntryPointIsSupported(entryPoint);
         const userOperation = (0, types_1.deriveUserOperation)(op);
-        if (!this.entryPoints.includes(entryPoint)) {
-            throw new types_1.RpcError(`EntryPoint ${entryPoint} not supported, supported EntryPoints: ${this.entryPoints.join(", ")}`);
-        }
-        if (this.chainId === chains.celoAlfajores.id ||
-            this.chainId === chains.celo.id) {
-            if (userOperation.maxFeePerGas !==
-                userOperation.maxPriorityFeePerGas) {
-                throw new types_1.RpcError("maxPriorityFeePerGas must equal maxFeePerGas on Celo chains");
-            }
-        }
-        if (apiVersion !== "v1") {
-            await this.gasPriceManager.validateGasPrice({
-                maxFeePerGas: userOperation.maxFeePerGas,
-                maxPriorityFeePerGas: userOperation.maxPriorityFeePerGas
-            });
-        }
-        if (userOperation.verificationGasLimit < 10000n) {
-            throw new types_1.RpcError("verificationGasLimit must be at least 10000");
-        }
-        this.logger.trace({ userOperation, entryPoint }, "beginning validation");
-        if (userOperation.preVerificationGas === 0n ||
-            userOperation.verificationGasLimit === 0n) {
-            throw new types_1.RpcError("user operation gas limits must be larger than 0");
-        }
+        const opHash = (0, utils_1.getUserOperationHash)(userOperation, entryPoint, this.chainId);
+        await this.preMempoolChecks(opHash, userOperation, apiVersion, entryPoint);
         const currentNonceValue = await this.getNonceValue(userOperation, entryPoint);
         const [, userOperationNonceValue] = (0, utils_1.getNonceKeyAndValue)(userOperation.nonce);
         if (userOperationNonceValue < currentNonceValue) {
-            throw new types_1.RpcError("UserOperation reverted during simulation with reason: AA25 invalid account nonce", types_1.ValidationErrors.InvalidFields);
+            const reason = "UserOperation failed validation with reason: AA25 invalid account nonce";
+            this.eventManager.emitFailedValidation(opHash, reason, "AA25");
+            throw new types_1.RpcError(reason, types_1.ValidationErrors.InvalidFields);
         }
         if (userOperationNonceValue > currentNonceValue + 10n) {
-            throw new types_1.RpcError("UserOperation reverted during simulation with reason: AA25 invalid account nonce", types_1.ValidationErrors.InvalidFields);
+            const reason = "UserOperation failed validaiton with reason: AA25 invalid account nonce";
+            this.eventManager.emitFailedValidation(opHash, reason, "AA25");
+            throw new types_1.RpcError(reason, types_1.ValidationErrors.InvalidFields);
         }
         let queuedUserOperations = [];
         if (userOperationNonceValue > currentNonceValue &&
@@ -649,9 +500,10 @@ class RpcHandler {
         if (userOperationNonceValue ===
             currentNonceValue + BigInt(queuedUserOperations.length)) {
             if (this.dangerousSkipUserOperationValidation) {
-                const success = this.mempool.add(op, entryPoint);
+                const [success, errorReason] = this.mempool.add(op, entryPoint);
                 if (!success) {
-                    throw new types_1.RpcError("UserOperation reverted during simulation with reason: AA25 invalid account nonce", types_1.ValidationErrors.InvalidFields);
+                    this.eventManager.emitFailedValidation(opHash, errorReason, (0, utils_1.getAAError)(errorReason));
+                    throw new types_1.RpcError(`UserOperation reverted during simulation with reason: ${errorReason}`, types_1.ValidationErrors.InvalidFields);
                 }
             }
             else {
@@ -661,9 +513,10 @@ class RpcHandler {
                 const validationResult = await this.validator.validateUserOperation(apiVersion !== "v1", userOperation, queuedUserOperations, entryPoint);
                 await this.reputationManager.checkReputation(userOperation, entryPoint, validationResult);
                 await this.mempool.checkEntityMultipleRoleViolation(userOperation);
-                const success = this.mempool.add(op, entryPoint, validationResult.referencedContracts);
+                const [success, errorReason] = this.mempool.add(op, entryPoint, validationResult.referencedContracts);
                 if (!success) {
-                    throw new types_1.RpcError("UserOperation reverted during simulation with reason: AA25 invalid account nonce", types_1.ValidationErrors.InvalidFields);
+                    this.eventManager.emitFailedValidation(opHash, errorReason, (0, utils_1.getAAError)(errorReason));
+                    throw new types_1.RpcError(`UserOperation reverted during simulation with reason: ${errorReason}`, types_1.ValidationErrors.InvalidFields);
                 }
                 return "added";
             }
@@ -671,10 +524,47 @@ class RpcHandler {
         this.nonceQueuer.add(op, entryPoint);
         return "queued";
     }
+    async pimlico_sendUserOperationNow(apiVersion, userOperation, entryPoint) {
+        if (!this.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.chainId);
+        await this.preMempoolChecks(opHash, userOperation, apiVersion, entryPoint);
+        const result = (await this.executor.bundle(entryPoint, [userOperation]))[0];
+        if (result.status === "failure") {
+            const { userOpHash, reason } = result.error;
+            this.monitor.setUserOperationStatus(userOpHash, {
+                status: "rejected",
+                transactionHash: null
+            });
+            this.logger.warn({
+                userOperation: JSON.stringify(result.error.userOperation, (_k, v) => (typeof v === "bigint" ? v.toString() : v)),
+                userOpHash,
+                reason
+            }, "user operation rejected");
+            this.metrics.userOperationsSubmitted
+                .labels({ status: "failed" })
+                .inc();
+            const { error } = result;
+            throw new types_1.RpcError(`userOperation reverted during simulation with reason: ${error.reason}`);
+        }
+        const res = result;
+        // wait for receipt
+        const receipt = await this.publicClient.waitForTransactionReceipt({
+            hash: res.value.transactionInfo.transactionHash,
+            pollingInterval: 100
+        });
+        const userOperationReceipt = (0, utils_1.parseUserOperationReceipt)(opHash, receipt);
+        return userOperationReceipt;
+    }
     async pimlico_sendCompressedUserOperation(apiVersion, compressedCalldata, inflatorAddress, entryPoint) {
+        const receivedTimestamp = Date.now();
         let status = "rejected";
         try {
             const { inflatedOp, inflatorId } = await this.validateAndInflateCompressedUserOperation(inflatorAddress, compressedCalldata);
+            const hash = (0, utils_1.getUserOperationHash)(inflatedOp, entryPoint, this.chainId);
+            this.eventManager.emitReceived(hash, receivedTimestamp);
             const compressedUserOp = {
                 compressedCalldata,
                 inflatedOp,
@@ -683,7 +573,6 @@ class RpcHandler {
             };
             // check userOps inputs.
             status = await this.addToMempoolIfValid(compressedUserOp, entryPoint, apiVersion);
-            const hash = (0, utils_1.getUserOperationHash)(inflatedOp, entryPoint, this.chainId);
             return hash;
         }
         catch (error) {