@pimlico/alto 0.0.3 → 0.0.5

package/esm/rpc/rpcHandler.js

@@ -1,9 +1,7 @@
-import { EntryPointV06Abi, EntryPointV07Abi, IOpInflatorAbi, RpcError, ValidationErrors, bundlerGetStakeStatusResponseSchema, deriveUserOperation, logSchema, receiptSchema } from "../types/index.js";
-import { calcPreVerificationGas, calcVerificationGasAndCallGasLimit, getNonceKeyAndValue, getUserOperationHash, isVersion06, isVersion07, maxBigInt, toUnpackedUserOperation } from "../utils/index.js";
-import { TransactionNotFoundError, TransactionReceiptNotFoundError, decodeFunctionData, getAbiItem, getAddress, getContract, encodeEventTopics, zeroAddress, decodeEventLog, parseAbi } from "viem";
-import * as chains from "viem/chains";
-import { z } from "zod";
-import { fromZodError } from "zod-validation-error";
+import { EntryPointV06Abi, EntryPointV07Abi, IOpInflatorAbi, RpcError, ValidationErrors, bundlerGetStakeStatusResponseSchema, deriveUserOperation } from "../types/index.js";
+import { calcPreVerificationGas, calcVerificationGasAndCallGasLimit, getAAError, getNonceKeyAndValue, getUserOperationHash, isVersion06, isVersion07, maxBigInt, parseUserOperationReceipt, toUnpackedUserOperation } from "../utils/index.js";
+import { TransactionNotFoundError, decodeFunctionData, getAbiItem, getAddress, getContract, slice, toFunctionSelector } from "viem";
+import { base, baseSepolia, optimism } from "viem/chains";
 export class RpcHandler {
     entryPoints;
     publicClient;
@@ -27,7 +25,9 @@ export 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;
@@ -51,6 +51,8 @@ export 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
@@ -141,6 +143,47 @@ export 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 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 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 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 RpcError(reason);
         }
     }
     eth_chainId() {
@@ -150,10 +193,7 @@ export 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 RpcError("user operation max fee per gas must be larger than 0 during gas estimation");
         }
@@ -163,14 +203,9 @@ export class RpcHandler {
         userOperation.preVerificationGas = 1000000n;
         userOperation.verificationGasLimit = 10000000n;
         userOperation.callGasLimit = 10000000n;
-        if (this.chainId === chains.base.id) {
+        if (this.chainId === base.id) {
             userOperation.verificationGasLimit = 5000000n;
         }
-        if (this.chainId === chains.celoAlfajores.id ||
-            this.chainId === chains.celo.id) {
-            userOperation.verificationGasLimit = 1000000n;
-            userOperation.callGasLimit = 1000000n;
-        }
         if (isVersion07(userOperation)) {
             userOperation.paymasterPostOpGasLimit = 2000000n;
             userOperation.paymasterVerificationGasLimit = 5000000n;
@@ -221,12 +256,10 @@ export class RpcHandler {
             paymasterPostOpGasLimit =
                 (paymasterPostOpGasLimit * multiplier) / 100n;
         }
-        if (this.chainId === chains.base.id ||
-            this.chainId === chains.baseSepolia.id) {
+        if (this.chainId === base.id || this.chainId === baseSepolia.id) {
             callGasLimit += 10000n;
         }
-        if (this.chainId === chains.base.id ||
-            this.chainId === chains.optimism.id) {
+        if (this.chainId === base.id || this.chainId === optimism.id) {
             callGasLimit = maxBigInt(callGasLimit, 120000n);
         }
         if (userOperation.callData === "0x") {
@@ -256,10 +289,11 @@ export class RpcHandler {
         };
     }
     async eth_sendUserOperation(apiVersion, userOperation, entryPoint) {
+        const hash = getUserOperationHash(userOperation, entryPoint, this.chainId);
+        this.eventManager.emitReceived(hash);
         let status = "rejected";
         try {
             status = await this.addToMempoolIfValid(userOperation, entryPoint, apiVersion);
-            const hash = getUserOperationHash(userOperation, entryPoint, this.chainId);
             return hash;
         }
         catch (error) {
@@ -323,27 +357,38 @@ export class RpcHandler {
         if (!tx.to) {
             return null;
         }
-        let op = undefined;
+        let op;
         try {
             const decoded = decodeFunctionData({
-                abi: EntryPointV06Abi,
+                abi: [...EntryPointV06Abi, ...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 = 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;
         }
-        if (op === undefined) {
-            return null;
-        }
         const result = {
-            userOperation: isVersion06(op) ? op : toUnpackedUserOperation(op),
+            userOperation: op,
             entryPoint: getAddress(tx.to),
             transactionHash: txHash,
             blockHash: tx.blockHash ?? "0x",
@@ -351,211 +396,53 @@ export class RpcHandler {
         };
         return result;
     }
-    async eth_getUserOperationReceipt(userOperationHash) {
-        const userOperationEventAbiItem = getAbiItem({
-            abi: 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 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 = parseAbi([
-            "event UserOperationRevertReason(bytes32 indexed userOpHash, address indexed sender, uint256 nonce, bytes revertReason)"
-        ]);
-        const userOperationRevertReasonTopicEvent = encodeEventTopics({
-            abi: userOperationRevertReasonAbi
-        })[0];
-        let entryPoint = 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 = 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 = z.array(logSchema).safeParse(filteredLogs);
-        if (!logsParsing.success) {
-            const err = fromZodError(logsParsing.error);
-            throw err;
-        }
-        const receiptParsing = receiptSchema.safeParse({
-            ...receipt,
-            status: receipt.status === "success" ? 1 : 0
-        });
-        if (!receiptParsing.success) {
-            const err = fromZodError(receiptParsing.error);
-            throw err;
-        }
-        let paymaster = userOperationEvent.args.paymaster;
-        paymaster = paymaster === 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 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 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 RpcError("debug_bundler_dumpMempool is only available in development environment");
-        }
-        if (!this.entryPoints.includes(entryPoint)) {
-            throw new RpcError(`EntryPoint ${entryPoint} not supported, supported EntryPoints: ${this.entryPoints.join(", ")}`);
-        }
+        this.ensureDebugEndpointsAreEnabled("debug_bundler_dumpMempool");
+        this.ensureEntryPointIsSupported(entryPoint);
         return this.mempool
             .dumpOutstanding()
             .map((userOpInfo) => deriveUserOperation(userOpInfo.mempoolUserOperation));
     }
     async debug_bundler_sendBundleNow() {
-        if (!this.enableDebugEndpoints) {
-            throw new 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 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 RpcError("debug_bundler_setRe is only available in development environment");
-        }
-        if (!this.entryPoints.includes(entryPoint)) {
-            throw new 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 RpcError("debug_bundler_getStakeStatus is only available in development environment");
-        }
-        if (!this.entryPoints.includes(entryPoint)) {
-            throw new RpcError(`EntryPoint ${entryPoint} not supported, supported EntryPoints: ${this.entryPoints.join(", ")}`);
-        }
+        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) {
-        if (!this.enableDebugEndpoints) {
-            throw new RpcError("debug_bundler_setReputation is only available in development environment");
-        }
+        this.ensureDebugEndpointsAreEnabled("debug_bundler_setReputation");
         this.reputationManager.setReputation(args[1], args[0]);
         return "ok";
     }
@@ -563,57 +450,44 @@ export 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 = deriveUserOperation(op);
-        if (!this.entryPoints.includes(entryPoint)) {
-            throw new 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 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 RpcError("verificationGasLimit must be at least 10000");
-        }
-        this.logger.trace({ userOperation, entryPoint }, "beginning validation");
-        if (userOperation.preVerificationGas === 0n ||
-            userOperation.verificationGasLimit === 0n) {
-            throw new RpcError("user operation gas limits must be larger than 0");
-        }
+        const opHash = getUserOperationHash(userOperation, entryPoint, this.chainId);
+        await this.preMempoolChecks(opHash, userOperation, apiVersion, entryPoint);
         const currentNonceValue = await this.getNonceValue(userOperation, entryPoint);
         const [, userOperationNonceValue] = getNonceKeyAndValue(userOperation.nonce);
         if (userOperationNonceValue < currentNonceValue) {
-            throw new RpcError("UserOperation reverted during simulation with reason: AA25 invalid account nonce", ValidationErrors.InvalidFields);
+            const reason = "UserOperation failed validation with reason: AA25 invalid account nonce";
+            this.eventManager.emitFailedValidation(opHash, reason, "AA25");
+            throw new RpcError(reason, ValidationErrors.InvalidFields);
         }
         if (userOperationNonceValue > currentNonceValue + 10n) {
-            throw new RpcError("UserOperation reverted during simulation with reason: AA25 invalid account nonce", ValidationErrors.InvalidFields);
+            const reason = "UserOperation failed validaiton with reason: AA25 invalid account nonce";
+            this.eventManager.emitFailedValidation(opHash, reason, "AA25");
+            throw new RpcError(reason, ValidationErrors.InvalidFields);
         }
         let queuedUserOperations = [];
         if (userOperationNonceValue > currentNonceValue &&
@@ -623,9 +497,10 @@ export 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 RpcError("UserOperation reverted during simulation with reason: AA25 invalid account nonce", ValidationErrors.InvalidFields);
+                    this.eventManager.emitFailedValidation(opHash, errorReason, getAAError(errorReason));
+                    throw new RpcError(`UserOperation reverted during simulation with reason: ${errorReason}`, ValidationErrors.InvalidFields);
                 }
             }
             else {
@@ -635,9 +510,10 @@ export 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 RpcError("UserOperation reverted during simulation with reason: AA25 invalid account nonce", ValidationErrors.InvalidFields);
+                    this.eventManager.emitFailedValidation(opHash, errorReason, getAAError(errorReason));
+                    throw new RpcError(`UserOperation reverted during simulation with reason: ${errorReason}`, ValidationErrors.InvalidFields);
                 }
                 return "added";
             }
@@ -645,10 +521,47 @@ export class RpcHandler {
         this.nonceQueuer.add(op, entryPoint);
         return "queued";
     }
+    async pimlico_sendUserOperationNow(apiVersion, userOperation, entryPoint) {
+        if (!this.enableInstantBundlingEndpoint) {
+            throw new RpcError("pimlico_sendUserOperationNow endpoint is not enabled", ValidationErrors.InvalidFields);
+        }
+        this.ensureEntryPointIsSupported(entryPoint);
+        const opHash = 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 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 = 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 = getUserOperationHash(inflatedOp, entryPoint, this.chainId);
+            this.eventManager.emitReceived(hash, receivedTimestamp);
             const compressedUserOp = {
                 compressedCalldata,
                 inflatedOp,
@@ -657,7 +570,6 @@ export class RpcHandler {
             };
             // check userOps inputs.
             status = await this.addToMempoolIfValid(compressedUserOp, entryPoint, apiVersion);
-            const hash = getUserOperationHash(inflatedOp, entryPoint, this.chainId);
             return hash;
         }
         catch (error) {