@pimlico/alto 0.0.0-main.20250203T212650 → 0.0.0-main.20250205T150420

package/esm/mempool/mempool.js

@@ -1,8 +1,5 @@
-// import { MongoClient, Collection, Filter } from "mongodb"
-// import { PublicClient, getContract } from "viem"
-// import { EntryPointAbi } from "../types/EntryPoint"
 import { EntryPointV06Abi, EntryPointV07Abi, RpcError, ValidationErrors } from "../types/index.js";
-import { getAddressFromInitCodeOrPaymasterAndData, getNonceKeyAndValue, getUserOperationHash, isVersion06, isVersion07 } from "../utils/index.js";
+import { getAddressFromInitCodeOrPaymasterAndData, getNonceKeyAndSequence, getUserOperationHash, isVersion06, isVersion07, scaleBigIntByPercent } from "../utils/index.js";
 import { getAddress, getContract } from "viem";
 import { ReputationStatuses } from "./reputationManager.js";
 import { MemoryStore } from "./store.js";
@@ -27,31 +24,31 @@ export class MemoryMempool {
         this.throttledEntityBundleCount = 4; // we don't have any config for this as of now
         this.eventManager = eventManager;
     }
-    replaceSubmitted(userOperation, transactionInfo) {
-        const op = this.store
+    replaceSubmitted(userOpInfo, transactionInfo) {
+        const { userOpHash } = userOpInfo;
+        const existingUserOpToReplace = this.store
             .dumpSubmitted()
-            .find((op) => op.userOperation.userOperationHash ===
-            userOperation.userOperationHash);
-        if (op) {
-            this.store.removeSubmitted(userOperation.userOperationHash);
+            .find((userOpInfo) => userOpInfo.userOpHash === userOpHash);
+        if (existingUserOpToReplace) {
+            this.store.removeSubmitted(userOpHash);
             this.store.addSubmitted({
-                userOperation,
+                ...userOpInfo,
                 transactionInfo
             });
-            this.monitor.setUserOperationStatus(userOperation.userOperationHash, {
+            this.monitor.setUserOperationStatus(userOpHash, {
                 status: "submitted",
                 transactionHash: transactionInfo.transactionHash
             });
         }
     }
     markSubmitted(userOpHash, transactionInfo) {
-        const op = this.store
+        const processingUserOp = this.store
             .dumpProcessing()
-            .find((op) => op.userOperationHash === userOpHash);
-        if (op) {
+            .find((userOpInfo) => userOpInfo.userOpHash === userOpHash);
+        if (processingUserOp) {
             this.store.removeProcessing(userOpHash);
             this.store.addSubmitted({
-                userOperation: op,
+                ...processingUserOp,
                 transactionInfo
             });
             this.monitor.setUserOperationStatus(userOpHash, {
@@ -61,7 +58,7 @@ export class MemoryMempool {
         }
     }
     dumpOutstanding() {
-        return this.store.dumpOutstanding();
+        return this.store.dumpOutstanding().map(({ userOp }) => userOp);
     }
     dumpProcessing() {
         return this.store.dumpProcessing();
@@ -109,19 +106,19 @@ export class MemoryMempool {
             paymasters: new Set(),
             factories: new Set()
         };
-        for (const mempoolOp of allOps) {
-            const op = mempoolOp.userOperation;
-            entities.sender.add(op.sender);
-            const isUserOpV06 = isVersion06(op);
+        for (const userOpInfo of allOps) {
+            const { userOp } = userOpInfo;
+            entities.sender.add(userOp.sender);
+            const isUserOpV06 = isVersion06(userOp);
             const paymaster = isUserOpV06
-                ? getAddressFromInitCodeOrPaymasterAndData(op.paymasterAndData)
-                : op.paymaster;
+                ? getAddressFromInitCodeOrPaymasterAndData(userOp.paymasterAndData)
+                : userOp.paymaster;
             if (paymaster) {
                 entities.paymasters.add(paymaster);
             }
             const factory = isUserOpV06
-                ? getAddressFromInitCodeOrPaymasterAndData(op.initCode)
-                : op.factory;
+                ? getAddressFromInitCodeOrPaymasterAndData(userOp.initCode)
+                : userOp.factory;
             if (factory) {
                 entities.factories.add(factory);
             }
@@ -130,66 +127,66 @@ export class MemoryMempool {
     }
     // TODO: add check for adding a userop with conflicting nonce
     // In case of concurrent requests
-    add(userOperation, entryPoint, referencedContracts) {
-        const opHash = getUserOperationHash(userOperation, entryPoint, this.config.publicClient.chain.id);
+    add(userOp, entryPoint, referencedContracts) {
+        const userOpHash = getUserOperationHash(userOp, entryPoint, this.config.publicClient.chain.id);
         const outstandingOps = [...this.store.dumpOutstanding()];
         const processedOrSubmittedOps = [
             ...this.store.dumpProcessing(),
-            ...this.store
-                .dumpSubmitted()
-                .map(({ userOperation }) => userOperation)
+            ...this.store.dumpSubmitted()
         ];
         // Check if the exact same userOperation is already in the mempool.
         const existingUserOperation = [
             ...outstandingOps,
             ...processedOrSubmittedOps
-        ].find(({ userOperationHash }) => userOperationHash === opHash);
+        ].find((userOpInfo) => userOpInfo.userOpHash === userOpHash);
         if (existingUserOperation) {
             return [false, "Already known"];
         }
-        if (processedOrSubmittedOps.find((opInfo) => {
-            const mempoolUserOp = opInfo.userOperation;
-            return (mempoolUserOp.sender === userOperation.sender &&
-                mempoolUserOp.nonce === userOperation.nonce);
+        if (processedOrSubmittedOps.find((userOpInfo) => {
+            const { userOp: mempoolUserOp } = userOpInfo;
+            return (mempoolUserOp.sender === userOp.sender &&
+                mempoolUserOp.nonce === userOp.nonce);
         })) {
             return [
                 false,
                 "AA25 invalid account nonce: User operation is already in mempool and getting processed with same nonce and sender"
             ];
         }
-        this.reputationManager.updateUserOperationSeenStatus(userOperation, entryPoint);
-        const oldUserOp = [...outstandingOps, ...processedOrSubmittedOps].find((opInfo) => {
-            const mempoolUserOp = opInfo.userOperation;
-            const isSameSender = mempoolUserOp.sender === userOperation.sender;
-            if (isSameSender &&
-                mempoolUserOp.nonce === userOperation.nonce) {
+        this.reputationManager.updateUserOperationSeenStatus(userOp, entryPoint);
+        const oldUserOpInfo = [
+            ...outstandingOps,
+            ...processedOrSubmittedOps
+        ].find((userOpInfo) => {
+            const { userOp: mempoolUserOp } = userOpInfo;
+            const isSameSender = mempoolUserOp.sender === userOp.sender;
+            if (isSameSender && mempoolUserOp.nonce === userOp.nonce) {
                 return true;
             }
             // Check if there is already a userOperation with initCode + same sender (stops rejected ops due to AA10).
             if (isVersion06(mempoolUserOp) &&
-                isVersion06(userOperation) &&
-                userOperation.initCode &&
-                userOperation.initCode !== "0x") {
+                isVersion06(userOp) &&
+                userOp.initCode &&
+                userOp.initCode !== "0x") {
                 return (isSameSender &&
                     mempoolUserOp.initCode &&
                     mempoolUserOp.initCode !== "0x");
             }
             // Check if there is already a userOperation with factory + same sender (stops rejected ops due to AA10).
             if (isVersion07(mempoolUserOp) &&
-                isVersion07(userOperation) &&
-                userOperation.factory &&
-                userOperation.factory !== "0x") {
+                isVersion07(userOp) &&
+                userOp.factory &&
+                userOp.factory !== "0x") {
                 return (isSameSender &&
                     mempoolUserOp.factory &&
                     mempoolUserOp.factory !== "0x");
             }
             return false;
         });
-        const isOldUserOpProcessingOrSubmitted = processedOrSubmittedOps.some((submittedOp) => submittedOp.userOperationHash === oldUserOp?.userOperationHash);
-        if (oldUserOp) {
-            const oldOp = oldUserOp.userOperation;
+        const isOldUserOpProcessingOrSubmitted = processedOrSubmittedOps.some((userOpInfo) => userOpInfo.userOpHash === oldUserOpInfo?.userOpHash);
+        if (oldUserOpInfo) {
+            const { userOp: oldUserOp } = oldUserOpInfo;
             let reason = "AA10 sender already constructed: A conflicting userOperation with initCode for this sender is already in the mempool. bump the gas price by minimum 10%";
-            if (oldOp.nonce === userOperation.nonce) {
+            if (oldUserOp.nonce === userOp.nonce) {
                 reason =
                     "AA25 invalid account nonce: User operation already present in mempool, bump the gas price by minimum 10%";
             }
@@ -197,25 +194,24 @@ export class MemoryMempool {
             if (isOldUserOpProcessingOrSubmitted) {
                 return [false, reason];
             }
-            const oldMaxPriorityFeePerGas = oldOp.maxPriorityFeePerGas;
-            const newMaxPriorityFeePerGas = userOperation.maxPriorityFeePerGas;
-            const oldMaxFeePerGas = oldOp.maxFeePerGas;
-            const newMaxFeePerGas = userOperation.maxFeePerGas;
-            const incrementMaxPriorityFeePerGas = (oldMaxPriorityFeePerGas * BigInt(10)) / BigInt(100);
-            const incrementMaxFeePerGas = (oldMaxFeePerGas * BigInt(10)) / BigInt(100);
-            if (newMaxPriorityFeePerGas <
-                oldMaxPriorityFeePerGas + incrementMaxPriorityFeePerGas ||
-                newMaxFeePerGas < oldMaxFeePerGas + incrementMaxFeePerGas) {
+            const oldOp = oldUserOp;
+            const newOp = userOp;
+            const hasHigherPriorityFee = newOp.maxPriorityFeePerGas >=
+                scaleBigIntByPercent(oldOp.maxPriorityFeePerGas, 110n);
+            const hasHigherMaxFee = newOp.maxFeePerGas >=
+                scaleBigIntByPercent(oldOp.maxFeePerGas, 110n);
+            const hasHigherFees = hasHigherPriorityFee || hasHigherMaxFee;
+            if (!hasHigherFees) {
                 return [false, reason];
             }
-            this.store.removeOutstanding(oldUserOp.userOperationHash);
+            this.store.removeOutstanding(oldUserOpInfo.userOpHash);
         }
         // Check if mempool already includes max amount of parallel user operations
         const parallelUserOperationsCount = this.store
             .dumpOutstanding()
             .filter((userOpInfo) => {
-            const userOp = userOpInfo.userOperation;
-            return userOp.sender === userOperation.sender;
+            const { userOp: mempoolUserOp } = userOpInfo;
+            return mempoolUserOp.sender === userOp.sender;
         }).length;
         if (parallelUserOperationsCount > this.config.mempoolMaxParallelOps) {
             return [
@@ -224,13 +220,13 @@ export class MemoryMempool {
             ];
         }
         // Check if mempool already includes max amount of queued user operations
-        const [nonceKey] = getNonceKeyAndValue(userOperation.nonce);
+        const [nonceKey] = getNonceKeyAndSequence(userOp.nonce);
         const queuedUserOperationsCount = this.store
             .dumpOutstanding()
             .filter((userOpInfo) => {
-            const userOp = userOpInfo.userOperation;
-            const [opNonceKey] = getNonceKeyAndValue(userOp.nonce);
-            return (userOp.sender === userOperation.sender &&
+            const { userOp: mempoolUserOp } = userOpInfo;
+            const [opNonceKey] = getNonceKeyAndSequence(mempoolUserOp.nonce);
+            return (mempoolUserOp.sender === userOp.sender &&
                 opNonceKey === nonceKey);
         }).length;
         if (queuedUserOperationsCount > this.config.mempoolMaxQueuedOps) {
@@ -240,23 +236,21 @@ export class MemoryMempool {
             ];
         }
         this.store.addOutstanding({
-            userOperation,
+            userOp,
             entryPoint,
-            userOperationHash: opHash,
-            firstSubmitted: oldUserOp ? oldUserOp.firstSubmitted : Date.now(),
-            lastReplaced: Date.now(),
-            referencedContracts
+            userOpHash: userOpHash,
+            referencedContracts,
+            addedToMempool: Date.now()
         });
-        this.monitor.setUserOperationStatus(opHash, {
+        this.monitor.setUserOperationStatus(userOpHash, {
             status: "not_submitted",
             transactionHash: null
         });
-        this.eventManager.emitAddedToMempool(opHash);
+        this.eventManager.emitAddedToMempool(userOpHash);
         return [true, ""];
     }
     // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
-    async shouldSkip(opInfo, paymasterDeposit, stakedEntityCount, knownEntities, senders, storageMap) {
-        const op = opInfo.userOperation;
+    async shouldSkip(userOpInfo, paymasterDeposit, stakedEntityCount, knownEntities, senders, storageMap) {
         if (!this.config.safeMode) {
             return {
                 skip: false,
@@ -267,18 +261,19 @@ export class MemoryMempool {
                 storageMap
             };
         }
-        const isUserOpV06 = isVersion06(op);
+        const { userOp, entryPoint, userOpHash, referencedContracts } = userOpInfo;
+        const isUserOpV06 = isVersion06(userOp);
         const paymaster = isUserOpV06
-            ? getAddressFromInitCodeOrPaymasterAndData(op.paymasterAndData)
-            : op.paymaster;
+            ? getAddressFromInitCodeOrPaymasterAndData(userOp.paymasterAndData)
+            : userOp.paymaster;
         const factory = isUserOpV06
-            ? getAddressFromInitCodeOrPaymasterAndData(op.initCode)
-            : op.factory;
-        const paymasterStatus = this.reputationManager.getStatus(opInfo.entryPoint, paymaster);
-        const factoryStatus = this.reputationManager.getStatus(opInfo.entryPoint, factory);
+            ? getAddressFromInitCodeOrPaymasterAndData(userOp.initCode)
+            : userOp.factory;
+        const paymasterStatus = this.reputationManager.getStatus(entryPoint, paymaster);
+        const factoryStatus = this.reputationManager.getStatus(entryPoint, factory);
         if (paymasterStatus === ReputationStatuses.banned ||
             factoryStatus === ReputationStatuses.banned) {
-            this.store.removeOutstanding(opInfo.userOperationHash);
+            this.store.removeOutstanding(userOpHash);
             return {
                 skip: true,
                 paymasterDeposit,
@@ -293,7 +288,7 @@ export class MemoryMempool {
             stakedEntityCount[paymaster] >= this.throttledEntityBundleCount) {
             this.logger.trace({
                 paymaster,
-                opHash: opInfo.userOperationHash
+                userOpHash
             }, "Throttled paymaster skipped");
             return {
                 skip: true,
@@ -309,7 +304,7 @@ export class MemoryMempool {
             stakedEntityCount[factory] >= this.throttledEntityBundleCount) {
             this.logger.trace({
                 factory,
-                opHash: opInfo.userOperationHash
+                userOpHash
             }, "Throttled factory skipped");
             return {
                 skip: true,
@@ -320,11 +315,11 @@ export class MemoryMempool {
                 storageMap
             };
         }
-        if (senders.has(op.sender) &&
+        if (senders.has(userOp.sender) &&
             this.config.enforceUniqueSendersPerBundle) {
             this.logger.trace({
-                sender: op.sender,
-                opHash: opInfo.userOperationHash
+                sender: userOp.sender,
+                userOpHash
             }, "Sender skipped because already included in bundle");
             return {
                 skip: true,
@@ -339,22 +334,22 @@ export class MemoryMempool {
         try {
             let queuedUserOperations = [];
             if (!isUserOpV06) {
-                queuedUserOperations = await this.getQueuedUserOperations(op, opInfo.entryPoint);
+                queuedUserOperations = await this.getQueuedUserOperations(userOp, entryPoint);
             }
             validationResult = await this.validator.validateUserOperation({
                 shouldCheckPrefund: false,
-                userOperation: op,
+                userOperation: userOp,
                 queuedUserOperations,
-                entryPoint: opInfo.entryPoint,
-                referencedContracts: opInfo.referencedContracts
+                entryPoint,
+                referencedContracts
             });
         }
         catch (e) {
             this.logger.error({
-                opHash: opInfo.userOperationHash,
+                userOpHash,
                 error: JSON.stringify(e)
             }, "2nd Validation error");
-            this.store.removeOutstanding(opInfo.userOperationHash);
+            this.store.removeOutstanding(userOpHash);
             return {
                 skip: true,
                 paymasterDeposit,
@@ -366,10 +361,11 @@ export class MemoryMempool {
         }
         for (const storageAddress of Object.keys(validationResult.storageMap)) {
             const address = getAddress(storageAddress);
-            if (address !== op.sender && knownEntities.sender.has(address)) {
+            if (address !== userOp.sender &&
+                knownEntities.sender.has(address)) {
                 this.logger.trace({
                     storageAddress,
-                    opHash: opInfo.userOperationHash
+                    userOpHash
                 }, "Storage address skipped");
                 return {
                     skip: true,
@@ -385,7 +381,7 @@ export class MemoryMempool {
             if (paymasterDeposit[paymaster] === undefined) {
                 const entryPointContract = getContract({
                     abi: isUserOpV06 ? EntryPointV06Abi : EntryPointV07Abi,
-                    address: opInfo.entryPoint,
+                    address: entryPoint,
                     client: {
                         public: this.config.publicClient
                     }
@@ -397,7 +393,7 @@ export class MemoryMempool {
                 validationResult.returnInfo.prefund) {
                 this.logger.trace({
                     paymaster,
-                    opHash: opInfo.userOperationHash
+                    userOpHash
                 }, "Paymaster skipped because of insufficient balance left to sponsor all user ops in the bundle");
                 return {
                     skip: true,
@@ -415,7 +411,7 @@ export class MemoryMempool {
         if (factory) {
             stakedEntityCount[factory] = (stakedEntityCount[factory] ?? 0) + 1;
         }
-        senders.add(op.sender);
+        senders.add(userOp.sender);
         return {
             skip: false,
             paymasterDeposit,
@@ -425,118 +421,153 @@ export class MemoryMempool {
             storageMap
         };
     }
-    async process(maxGasLimit, minOps) {
-        const outstandingUserOperations = this.store.dumpOutstanding().slice();
-        // Sort userops before the execution
-        // Decide the order of the userops based on the sender and nonce
-        // If sender is the same, sort by nonce key
-        outstandingUserOperations.sort((a, b) => {
-            const aUserOp = a.userOperation;
-            const bUserOp = b.userOperation;
+    async getBundles(maxBundleCount) {
+        const bundlePromises = this.config.entrypoints.map(async (entryPoint) => {
+            return await this.process({
+                entryPoint,
+                maxGasLimit: this.config.maxGasPerBundle,
+                minOpsPerBundle: 1,
+                maxBundleCount
+            });
+        });
+        const bundlesNested = await Promise.all(bundlePromises);
+        const bundles = bundlesNested.flat();
+        return bundles;
+    }
+    // Returns a bundle of userOperations in array format.
+    async process({ maxGasLimit, entryPoint, minOpsPerBundle, maxBundleCount }) {
+        let outstandingUserOps = this.store
+            .dumpOutstanding()
+            .filter((op) => op.entryPoint === entryPoint)
+            .sort((aUserOpInfo, bUserOpInfo) => {
+            // Sort userops before the execution
+            // Decide the order of the userops based on the sender and nonce
+            // If sender is the same, sort by nonce key
+            const aUserOp = aUserOpInfo.userOp;
+            const bUserOp = bUserOpInfo.userOp;
             if (aUserOp.sender === bUserOp.sender) {
-                const [aNonceKey, aNonceValue] = getNonceKeyAndValue(aUserOp.nonce);
-                const [bNonceKey, bNonceValue] = getNonceKeyAndValue(bUserOp.nonce);
+                const [aNonceKey, aNonceValue] = getNonceKeyAndSequence(aUserOp.nonce);
+                const [bNonceKey, bNonceValue] = getNonceKeyAndSequence(bUserOp.nonce);
                 if (aNonceKey === bNonceKey) {
                     return Number(aNonceValue - bNonceValue);
                 }
                 return Number(aNonceKey - bNonceKey);
             }
             return 0;
+        })
+            .slice();
+        if (outstandingUserOps.length === 0)
+            return [];
+        // Get EntryPoint version. (Ideally version should be derived from CLI flags)
+        const isV6 = isVersion06(outstandingUserOps[0].userOp);
+        const allSameVersion = outstandingUserOps.every((userOpInfo) => {
+            const { userOp } = userOpInfo;
+            return isVersion06(userOp) === isV6;
         });
-        let opsTaken = 0;
-        let gasUsed = 0n;
-        const result = [];
-        // paymaster deposit should be enough for all UserOps in the bundle.
-        let paymasterDeposit = {};
-        // throttled paymasters and factories are allowed only small UserOps per bundle.
-        let stakedEntityCount = {};
-        // each sender is allowed only once per bundle
-        let senders = new Set();
-        let knownEntities = this.getKnownEntities();
-        let storageMap = {};
-        for (const opInfo of outstandingUserOperations) {
-            const op = opInfo.userOperation;
-            gasUsed += op.callGasLimit + op.verificationGasLimit;
-            if (isVersion07(op)) {
-                gasUsed +=
-                    (op.paymasterPostOpGasLimit ?? 0n) +
-                        (op.paymasterVerificationGasLimit ?? 0n);
-            }
-            if (gasUsed > maxGasLimit && opsTaken >= (minOps || 0)) {
+        if (!allSameVersion) {
+            throw new Error("All user operations from same EntryPoint must be of the same version");
+        }
+        const bundles = [];
+        // Process all outstanding ops.
+        while (outstandingUserOps.length > 0) {
+            // If maxBundles is set and we reached the limit, break.
+            if (maxBundleCount && bundles.length >= maxBundleCount) {
                 break;
             }
-            const skipResult = await this.shouldSkip(opInfo, paymasterDeposit, stakedEntityCount, knownEntities, senders, storageMap);
-            paymasterDeposit = skipResult.paymasterDeposit;
-            stakedEntityCount = skipResult.stakedEntityCount;
-            knownEntities = skipResult.knownEntities;
-            senders = skipResult.senders;
-            storageMap = skipResult.storageMap;
-            if (skipResult.skip) {
-                continue;
+            // Setup for next bundle.
+            const currentBundle = {
+                entryPoint,
+                version: isV6 ? "0.6" : "0.7",
+                userOps: []
+            };
+            let gasUsed = 0n;
+            let paymasterDeposit = {}; // paymaster deposit should be enough for all UserOps in the bundle.
+            let stakedEntityCount = {}; // throttled paymasters and factories are allowed only small UserOps per bundle.
+            let senders = new Set(); // each sender is allowed only once per bundle
+            let knownEntities = this.getKnownEntities();
+            let storageMap = {};
+            // Keep adding ops to current bundle.
+            while (outstandingUserOps.length > 0) {
+                const userOpInfo = outstandingUserOps.shift();
+                if (!userOpInfo)
+                    break;
+                const { userOp, userOpHash } = userOpInfo;
+                // NOTE: currently if a userOp is skipped due to sender enforceUniqueSendersPerBundle it will be picked up
+                // again the next time mempool.process is called.
+                const skipResult = await this.shouldSkip(userOpInfo, paymasterDeposit, stakedEntityCount, knownEntities, senders, storageMap);
+                if (skipResult.skip)
+                    continue;
+                gasUsed +=
+                    userOp.callGasLimit +
+                        userOp.verificationGasLimit +
+                        (isVersion07(userOp)
+                            ? (userOp.paymasterPostOpGasLimit || 0n) +
+                                (userOp.paymasterVerificationGasLimit || 0n)
+                            : 0n);
+                // Only break on gas limit if we've hit minOpsPerBundle.
+                if (gasUsed > maxGasLimit &&
+                    currentBundle.userOps.length >= minOpsPerBundle) {
+                    outstandingUserOps.unshift(userOpInfo); // re-add op to front of queue
+                    break;
+                }
+                // Update state based on skip result
+                paymasterDeposit = skipResult.paymasterDeposit;
+                stakedEntityCount = skipResult.stakedEntityCount;
+                knownEntities = skipResult.knownEntities;
+                senders = skipResult.senders;
+                storageMap = skipResult.storageMap;
+                this.reputationManager.decreaseUserOperationCount(userOp);
+                this.store.removeOutstanding(userOpHash);
+                this.store.addProcessing(userOpInfo);
+                // Add op to current bundle
+                currentBundle.userOps.push(userOpInfo);
+            }
+            if (currentBundle.userOps.length > 0) {
+                bundles.push(currentBundle);
             }
-            this.reputationManager.decreaseUserOperationCount(op);
-            this.store.removeOutstanding(opInfo.userOperationHash);
-            this.store.addProcessing(opInfo);
-            result.push(opInfo);
-            opsTaken++;
-        }
-        return result;
-    }
-    get(opHash) {
-        const outstanding = this.store
-            .dumpOutstanding()
-            .find((op) => op.userOperationHash === opHash);
-        if (outstanding) {
-            return outstanding.userOperation;
-        }
-        const submitted = this.store
-            .dumpSubmitted()
-            .find((op) => op.userOperation.userOperationHash === opHash);
-        if (submitted) {
-            return submitted.userOperation.userOperation;
         }
-        return null;
+        return bundles;
     }
     // For a specfic user operation, get all the queued user operations
     // They should be executed first, ordered by nonce value
     // If cuurentNonceValue is not provided, it will be fetched from the chain
-    async getQueuedUserOperations(userOperation, entryPoint, _currentNonceValue) {
+    async getQueuedUserOperations(userOp, entryPoint, _currentNonceValue) {
         const entryPointContract = getContract({
             address: entryPoint,
-            abi: isVersion06(userOperation)
-                ? EntryPointV06Abi
-                : EntryPointV07Abi,
+            abi: isVersion06(userOp) ? EntryPointV06Abi : EntryPointV07Abi,
             client: {
                 public: this.config.publicClient
             }
         });
-        const [nonceKey, userOperationNonceValue] = getNonceKeyAndValue(userOperation.nonce);
+        const [nonceKey, nonceSequence] = getNonceKeyAndSequence(userOp.nonce);
         let currentNonceValue = BigInt(0);
         if (_currentNonceValue) {
             currentNonceValue = _currentNonceValue;
         }
         else {
-            const getNonceResult = await entryPointContract.read.getNonce([userOperation.sender, nonceKey], {
+            const getNonceResult = await entryPointContract.read.getNonce([userOp.sender, nonceKey], {
                 blockTag: "latest"
             });
-            currentNonceValue = getNonceKeyAndValue(getNonceResult)[1];
+            currentNonceValue = getNonceKeyAndSequence(getNonceResult)[1];
         }
         const outstanding = this.store
             .dumpOutstanding()
-            .map(({ userOperation }) => userOperation)
-            .filter((mempoolUserOp) => {
-            const [opNonceKey, opNonceValue] = getNonceKeyAndValue(mempoolUserOp.nonce);
-            return (mempoolUserOp.sender === userOperation.sender &&
-                opNonceKey === nonceKey &&
-                opNonceValue >= currentNonceValue &&
-                opNonceValue < userOperationNonceValue);
+            .filter((userOpInfo) => {
+            const { userOp: mempoolUserOp } = userOpInfo;
+            const [mempoolNonceKey, mempoolNonceSequence] = getNonceKeyAndSequence(mempoolUserOp.nonce);
+            return (mempoolUserOp.sender === userOp.sender &&
+                mempoolNonceKey === nonceKey &&
+                mempoolNonceSequence >= currentNonceValue &&
+                mempoolNonceSequence < nonceSequence);
         });
         outstanding.sort((a, b) => {
-            const [, aNonceValue] = getNonceKeyAndValue(a.nonce);
-            const [, bNonceValue] = getNonceKeyAndValue(b.nonce);
+            const aUserOp = a.userOp;
+            const bUserOp = b.userOp;
+            const [, aNonceValue] = getNonceKeyAndSequence(aUserOp.nonce);
+            const [, bNonceValue] = getNonceKeyAndSequence(bUserOp.nonce);
             return Number(aNonceValue - bNonceValue);
         });
-        return outstanding;
+        return outstanding.map((userOpInfo) => userOpInfo.userOp);
     }
     clear() {
         this.store.clear("outstanding");