@pimlico/alto 0.0.0-staging.20240606T115633 → 0.0.2

package/esm/rpc/rpcHandler.js

@@ -1,727 +0,0 @@
-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";
-export class RpcHandler {
-    entryPoints;
-    publicClient;
-    validator;
-    mempool;
-    executor;
-    monitor;
-    nonceQueuer;
-    usingTenderly;
-    rpcMaxBlockRange;
-    logger;
-    metrics;
-    chainId;
-    chainType;
-    enableDebugEndpoints;
-    executorManager;
-    reputationManager;
-    compressionHandler;
-    legacyTransactions;
-    dangerousSkipUserOperationValidation;
-    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) {
-        this.entryPoints = entryPoints;
-        this.publicClient = publicClient;
-        this.validator = validator;
-        this.mempool = mempool;
-        this.executor = executor;
-        this.monitor = monitor;
-        this.nonceQueuer = nonceQueuer;
-        this.usingTenderly = usingTenderly;
-        this.rpcMaxBlockRange = rpcMaxBlockRange;
-        this.logger = logger;
-        this.metrics = metrics;
-        this.enableDebugEndpoints = enableDebugEndpoints;
-        this.chainId = publicClient.chain.id;
-        this.executorManager = executorManager;
-        this.reputationManager = reputationManager;
-        this.compressionHandler = compressionHandler;
-        this.legacyTransactions = legacyTransactions;
-        this.dangerousSkipUserOperationValidation =
-            dangerousSkipUserOperationValidation;
-        this.gasPriceMultipliers = gasPriceMultipliers;
-        this.chainType = chainType;
-        this.gasPriceManager = gasPriceManager;
-        this.paymasterGasLimitMultiplier = paymasterGasLimitMultiplier;
-    }
-    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: this.debug_bundler_setBundlingMode(...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_sendCompressedUserOperation":
-                return {
-                    method,
-                    result: await this.pimlico_sendCompressedUserOperation(apiVersion, ...request.params)
-                };
-        }
-    }
-    eth_chainId() {
-        return BigInt(this.chainId);
-    }
-    eth_supportedEntryPoints() {
-        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(", ")}`);
-        }
-        if (userOperation.maxFeePerGas === 0n) {
-            throw new RpcError("user operation max fee per gas must be larger than 0 during gas estimation");
-        }
-        const preVerificationGas = ((await calcPreVerificationGas(this.publicClient, userOperation, entryPoint, this.chainId, this.chainType, this.gasPriceManager, false)) *
-            110n) /
-            100n;
-        userOperation.preVerificationGas = 1000000n;
-        userOperation.verificationGasLimit = 10000000n;
-        userOperation.callGasLimit = 10000000n;
-        if (this.chainId === chains.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;
-        }
-        // This is necessary because entryPoint pays
-        // min(maxFeePerGas, baseFee + maxPriorityFeePerGas) for the verification
-        // Since we don't want our estimations to depend upon baseFee, we set
-        // maxFeePerGas to maxPriorityFeePerGas
-        userOperation.maxPriorityFeePerGas = userOperation.maxFeePerGas;
-        // Check if the nonce is valid
-        // If the nonce is less than the current nonce, the user operation has already been executed
-        // If the nonce is greater than the current nonce, we may have missing user operations in the mempool
-        const currentNonceValue = await this.getNonceValue(userOperation, entryPoint);
-        const [, userOperationNonceValue] = getNonceKeyAndValue(userOperation.nonce);
-        let queuedUserOperations = [];
-        if (userOperationNonceValue < currentNonceValue) {
-            throw new RpcError("UserOperation reverted during simulation with reason: AA25 invalid account nonce", ValidationErrors.InvalidFields);
-        }
-        if (userOperationNonceValue > currentNonceValue) {
-            // Nonce queues are supported only for v7 user operations
-            if (isVersion06(userOperation)) {
-                throw new RpcError("UserOperation reverted during simulation with reason: AA25 invalid account nonce", ValidationErrors.InvalidFields);
-            }
-            queuedUserOperations = await this.mempool.getQueuedUserOperations(userOperation, entryPoint, currentNonceValue);
-            if (userOperationNonceValue >
-                currentNonceValue + BigInt(queuedUserOperations.length)) {
-                throw new RpcError("UserOperation reverted during simulation with reason: AA25 invalid account nonce", ValidationErrors.InvalidFields);
-            }
-        }
-        const executionResult = await this.validator.getExecutionResult(userOperation, entryPoint, queuedUserOperations, stateOverrides);
-        let { verificationGasLimit, callGasLimit } = calcVerificationGasAndCallGasLimit(userOperation, executionResult.data.executionResult, this.chainId, executionResult.data.callDataResult);
-        let paymasterVerificationGasLimit = 0n;
-        let paymasterPostOpGasLimit = 0n;
-        if (isVersion07(userOperation) &&
-            userOperation.paymaster !== null &&
-            "paymasterVerificationGasLimit" in
-                executionResult.data.executionResult &&
-            "paymasterPostOpGasLimit" in executionResult.data.executionResult) {
-            paymasterVerificationGasLimit =
-                executionResult.data.executionResult
-                    .paymasterVerificationGasLimit || 1n;
-            paymasterPostOpGasLimit =
-                executionResult.data.executionResult.paymasterPostOpGasLimit ||
-                    1n;
-            const multiplier = this.paymasterGasLimitMultiplier;
-            paymasterVerificationGasLimit =
-                (paymasterVerificationGasLimit * multiplier) / 100n;
-            paymasterPostOpGasLimit =
-                (paymasterPostOpGasLimit * multiplier) / 100n;
-        }
-        if (this.chainId === chains.base.id ||
-            this.chainId === chains.baseSepolia.id) {
-            callGasLimit += 10000n;
-        }
-        if (this.chainId === chains.base.id ||
-            this.chainId === chains.optimism.id) {
-            callGasLimit = maxBigInt(callGasLimit, 120000n);
-        }
-        if (userOperation.callData === "0x") {
-            callGasLimit = 0n;
-        }
-        if (isVersion07(userOperation)) {
-            return {
-                preVerificationGas,
-                verificationGasLimit,
-                callGasLimit,
-                paymasterVerificationGasLimit,
-                paymasterPostOpGasLimit
-            };
-        }
-        if (apiVersion === "v2") {
-            return {
-                preVerificationGas,
-                verificationGasLimit,
-                callGasLimit
-            };
-        }
-        return {
-            preVerificationGas,
-            verificationGas: verificationGasLimit,
-            verificationGasLimit,
-            callGasLimit
-        };
-    }
-    async eth_sendUserOperation(apiVersion, userOperation, entryPoint) {
-        let status = "rejected";
-        try {
-            status = await this.addToMempoolIfValid(userOperation, entryPoint, apiVersion);
-            const hash = getUserOperationHash(userOperation, entryPoint, this.chainId);
-            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 = 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];
-        const txHash = userOperationEvent.transactionHash;
-        if (txHash === null) {
-            // transaction pending
-            return null;
-        }
-        const getTransaction = async (txHash) => {
-            try {
-                return await this.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 = undefined;
-        try {
-            const decoded = decodeFunctionData({
-                abi: EntryPointV06Abi,
-                data: tx.input
-            });
-            if (decoded.functionName !== "handleOps") {
-                return null;
-            }
-            const ops = decoded.args[0];
-            op = ops.find((op) => op.sender === userOperationEvent.args.sender &&
-                op.nonce === userOperationEvent.args.nonce);
-        }
-        catch {
-            return null;
-        }
-        if (op === undefined) {
-            return null;
-        }
-        const result = {
-            userOperation: isVersion06(op) ? op : toUnpackedUserOperation(op),
-            entryPoint: getAddress(tx.to),
-            transactionHash: txHash,
-            blockHash: tx.blockHash ?? "0x",
-            blockNumber: BigInt(tx.blockNumber ?? 0n)
-        };
-        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;
-    }
-    debug_bundler_clearState() {
-        if (!this.enableDebugEndpoints) {
-            throw new RpcError("debug_bundler_clearState is only available in development environment");
-        }
-        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.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(", ")}`);
-        }
-        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");
-        }
-        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.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(", ")}`);
-        }
-        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(", ")}`);
-        }
-        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.reputationManager.setReputation(args[1], args[0]);
-        return "ok";
-    }
-    pimlico_getUserOperationStatus(userOperationHash) {
-        return this.monitor.getUserOperationStatus(userOperationHash);
-    }
-    async pimlico_getUserOperationGasPrice() {
-        const gasPrice = await this.gasPriceManager.getGasPrice();
-        const { slow, standard, fast } = this.gasPriceMultipliers;
-        return {
-            slow: {
-                maxFeePerGas: (gasPrice.maxFeePerGas * slow) / 100n,
-                maxPriorityFeePerGas: (gasPrice.maxPriorityFeePerGas * slow) / 100n
-            },
-            standard: {
-                maxFeePerGas: (gasPrice.maxFeePerGas * standard) / 100n,
-                maxPriorityFeePerGas: (gasPrice.maxPriorityFeePerGas * standard) / 100n
-            },
-            fast: {
-                maxFeePerGas: (gasPrice.maxFeePerGas * fast) / 100n,
-                maxPriorityFeePerGas: (gasPrice.maxPriorityFeePerGas * fast) / 100n
-            }
-        };
-    }
-    // check if we want to bundle userOperation. If yes, add to mempool
-    async addToMempoolIfValid(op, entryPoint, apiVersion) {
-        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 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);
-        }
-        if (userOperationNonceValue > currentNonceValue + 10n) {
-            throw new RpcError("UserOperation reverted during simulation with reason: AA25 invalid account nonce", ValidationErrors.InvalidFields);
-        }
-        let queuedUserOperations = [];
-        if (userOperationNonceValue > currentNonceValue &&
-            isVersion07(userOperation)) {
-            queuedUserOperations = await this.mempool.getQueuedUserOperations(userOperation, entryPoint, currentNonceValue);
-        }
-        if (userOperationNonceValue ===
-            currentNonceValue + BigInt(queuedUserOperations.length)) {
-            if (this.dangerousSkipUserOperationValidation) {
-                const success = this.mempool.add(op, entryPoint);
-                if (!success) {
-                    throw new RpcError("UserOperation reverted during simulation with reason: AA25 invalid account nonce", ValidationErrors.InvalidFields);
-                }
-            }
-            else {
-                if (apiVersion !== "v1") {
-                    await this.validator.validatePreVerificationGas(userOperation, entryPoint);
-                }
-                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);
-                if (!success) {
-                    throw new RpcError("UserOperation reverted during simulation with reason: AA25 invalid account nonce", ValidationErrors.InvalidFields);
-                }
-                return "added";
-            }
-        }
-        this.nonceQueuer.add(op, entryPoint);
-        return "queued";
-    }
-    async pimlico_sendCompressedUserOperation(apiVersion, compressedCalldata, inflatorAddress, entryPoint) {
-        let status = "rejected";
-        try {
-            const { inflatedOp, inflatorId } = await this.validateAndInflateCompressedUserOperation(inflatorAddress, compressedCalldata);
-            const compressedUserOp = {
-                compressedCalldata,
-                inflatedOp,
-                inflatorAddress,
-                inflatorId
-            };
-            // check userOps inputs.
-            status = await this.addToMempoolIfValid(compressedUserOp, entryPoint, apiVersion);
-            const hash = getUserOperationHash(inflatedOp, entryPoint, this.chainId);
-            return hash;
-        }
-        catch (error) {
-            status = "rejected";
-            throw error;
-        }
-        finally {
-            this.metrics.userOperationsReceived
-                .labels({
-                status,
-                type: "compressed"
-            })
-                .inc();
-        }
-    }
-    async validateAndInflateCompressedUserOperation(inflatorAddress, compressedCalldata) {
-        // check if inflator is registered with our PerOpInflator.
-        if (this.compressionHandler === null) {
-            throw new RpcError("Endpoint not supported");
-        }
-        const inflatorId = await this.compressionHandler.getInflatorRegisteredId(inflatorAddress, this.publicClient);
-        if (inflatorId === 0) {
-            throw new RpcError(`Inflator ${inflatorAddress} is not registered`, ValidationErrors.InvalidFields);
-        }
-        // infalte + start to validate user op.
-        const inflatorContract = getContract({
-            address: inflatorAddress,
-            abi: IOpInflatorAbi,
-            client: {
-                public: this.publicClient
-            }
-        });
-        let inflatedOp;
-        try {
-            inflatedOp = await inflatorContract.read.inflate([
-                compressedCalldata
-            ]);
-        }
-        catch (e) {
-            throw new RpcError(`Inflator ${inflatorAddress} failed to inflate calldata ${compressedCalldata}, due to ${e}`, ValidationErrors.InvalidFields);
-        }
-        // check if perUseropIsRegisterd to target BundleBulker
-        const perOpInflatorId = this.compressionHandler.perOpInflatorId;
-        if (perOpInflatorId === 0) {
-            throw new RpcError(`PerUserOp ${this.compressionHandler.perOpInflatorAddress} has not been registered with BundelBulker`, ValidationErrors.InvalidFields);
-        }
-        return { inflatedOp, inflatorId };
-    }
-    async getNonceValue(userOperation, entryPoint) {
-        const entryPointContract = getContract({
-            address: entryPoint,
-            abi: isVersion06(userOperation)
-                ? EntryPointV06Abi
-                : EntryPointV07Abi,
-            client: {
-                public: this.publicClient
-            }
-        });
-        const [nonceKey] = getNonceKeyAndValue(userOperation.nonce);
-        const getNonceResult = await entryPointContract.read.getNonce([userOperation.sender, nonceKey], {
-            blockTag: "latest"
-        });
-        const [_, currentNonceValue] = getNonceKeyAndValue(getNonceResult);
-        return currentNonceValue;
-    }
-}
-//# sourceMappingURL=rpcHandler.js.map