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

package/lib/mempool/mempool.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryMempool = void 0;
-// import { MongoClient, Collection, Filter } from "mongodb"
-// import { PublicClient, getContract } from "viem"
-// import { EntryPointAbi } from "../types/EntryPoint"
 const types_1 = require("../types/index.js");
 const utils_1 = require("../utils/index.js");
 const viem_1 = require("viem");
@@ -30,31 +27,31 @@ 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, {
@@ -64,7 +61,7 @@ class MemoryMempool {
         }
     }
     dumpOutstanding() {
-        return this.store.dumpOutstanding();
+        return this.store.dumpOutstanding().map(({ userOp }) => userOp);
     }
     dumpProcessing() {
         return this.store.dumpProcessing();
@@ -112,19 +109,19 @@ class MemoryMempool {
             paymasters: new Set(),
             factories: new Set()
         };
-        for (const mempoolOp of allOps) {
-            const op = mempoolOp.userOperation;
-            entities.sender.add(op.sender);
-            const isUserOpV06 = (0, utils_1.isVersion06)(op);
+        for (const userOpInfo of allOps) {
+            const { userOp } = userOpInfo;
+            entities.sender.add(userOp.sender);
+            const isUserOpV06 = (0, utils_1.isVersion06)(userOp);
             const paymaster = isUserOpV06
-                ? (0, utils_1.getAddressFromInitCodeOrPaymasterAndData)(op.paymasterAndData)
-                : op.paymaster;
+                ? (0, utils_1.getAddressFromInitCodeOrPaymasterAndData)(userOp.paymasterAndData)
+                : userOp.paymaster;
             if (paymaster) {
                 entities.paymasters.add(paymaster);
             }
             const factory = isUserOpV06
-                ? (0, utils_1.getAddressFromInitCodeOrPaymasterAndData)(op.initCode)
-                : op.factory;
+                ? (0, utils_1.getAddressFromInitCodeOrPaymasterAndData)(userOp.initCode)
+                : userOp.factory;
             if (factory) {
                 entities.factories.add(factory);
             }
@@ -133,66 +130,66 @@ class MemoryMempool {
     }
     // TODO: add check for adding a userop with conflicting nonce
     // In case of concurrent requests
-    add(userOperation, entryPoint, referencedContracts) {
-        const opHash = (0, utils_1.getUserOperationHash)(userOperation, entryPoint, this.config.publicClient.chain.id);
+    add(userOp, entryPoint, referencedContracts) {
+        const userOpHash = (0, utils_1.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 ((0, utils_1.isVersion06)(mempoolUserOp) &&
-                (0, utils_1.isVersion06)(userOperation) &&
-                userOperation.initCode &&
-                userOperation.initCode !== "0x") {
+                (0, utils_1.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 ((0, utils_1.isVersion07)(mempoolUserOp) &&
-                (0, utils_1.isVersion07)(userOperation) &&
-                userOperation.factory &&
-                userOperation.factory !== "0x") {
+                (0, utils_1.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%";
             }
@@ -200,25 +197,24 @@ 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 >=
+                (0, utils_1.scaleBigIntByPercent)(oldOp.maxPriorityFeePerGas, 110n);
+            const hasHigherMaxFee = newOp.maxFeePerGas >=
+                (0, utils_1.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 [
@@ -227,13 +223,13 @@ class MemoryMempool {
             ];
         }
         // Check if mempool already includes max amount of queued user operations
-        const [nonceKey] = (0, utils_1.getNonceKeyAndValue)(userOperation.nonce);
+        const [nonceKey] = (0, utils_1.getNonceKeyAndSequence)(userOp.nonce);
         const queuedUserOperationsCount = this.store
             .dumpOutstanding()
             .filter((userOpInfo) => {
-            const userOp = userOpInfo.userOperation;
-            const [opNonceKey] = (0, utils_1.getNonceKeyAndValue)(userOp.nonce);
-            return (userOp.sender === userOperation.sender &&
+            const { userOp: mempoolUserOp } = userOpInfo;
+            const [opNonceKey] = (0, utils_1.getNonceKeyAndSequence)(mempoolUserOp.nonce);
+            return (mempoolUserOp.sender === userOp.sender &&
                 opNonceKey === nonceKey);
         }).length;
         if (queuedUserOperationsCount > this.config.mempoolMaxQueuedOps) {
@@ -243,23 +239,21 @@ 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,
@@ -270,18 +264,19 @@ class MemoryMempool {
                 storageMap
             };
         }
-        const isUserOpV06 = (0, utils_1.isVersion06)(op);
+        const { userOp, entryPoint, userOpHash, referencedContracts } = userOpInfo;
+        const isUserOpV06 = (0, utils_1.isVersion06)(userOp);
         const paymaster = isUserOpV06
-            ? (0, utils_1.getAddressFromInitCodeOrPaymasterAndData)(op.paymasterAndData)
-            : op.paymaster;
+            ? (0, utils_1.getAddressFromInitCodeOrPaymasterAndData)(userOp.paymasterAndData)
+            : userOp.paymaster;
         const factory = isUserOpV06
-            ? (0, utils_1.getAddressFromInitCodeOrPaymasterAndData)(op.initCode)
-            : op.factory;
-        const paymasterStatus = this.reputationManager.getStatus(opInfo.entryPoint, paymaster);
-        const factoryStatus = this.reputationManager.getStatus(opInfo.entryPoint, factory);
+            ? (0, utils_1.getAddressFromInitCodeOrPaymasterAndData)(userOp.initCode)
+            : userOp.factory;
+        const paymasterStatus = this.reputationManager.getStatus(entryPoint, paymaster);
+        const factoryStatus = this.reputationManager.getStatus(entryPoint, factory);
         if (paymasterStatus === reputationManager_1.ReputationStatuses.banned ||
             factoryStatus === reputationManager_1.ReputationStatuses.banned) {
-            this.store.removeOutstanding(opInfo.userOperationHash);
+            this.store.removeOutstanding(userOpHash);
             return {
                 skip: true,
                 paymasterDeposit,
@@ -296,7 +291,7 @@ class MemoryMempool {
             stakedEntityCount[paymaster] >= this.throttledEntityBundleCount) {
             this.logger.trace({
                 paymaster,
-                opHash: opInfo.userOperationHash
+                userOpHash
             }, "Throttled paymaster skipped");
             return {
                 skip: true,
@@ -312,7 +307,7 @@ class MemoryMempool {
             stakedEntityCount[factory] >= this.throttledEntityBundleCount) {
             this.logger.trace({
                 factory,
-                opHash: opInfo.userOperationHash
+                userOpHash
             }, "Throttled factory skipped");
             return {
                 skip: true,
@@ -323,11 +318,11 @@ 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,
@@ -342,22 +337,22 @@ 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,
@@ -369,10 +364,11 @@ class MemoryMempool {
         }
         for (const storageAddress of Object.keys(validationResult.storageMap)) {
             const address = (0, viem_1.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,
@@ -388,7 +384,7 @@ class MemoryMempool {
             if (paymasterDeposit[paymaster] === undefined) {
                 const entryPointContract = (0, viem_1.getContract)({
                     abi: isUserOpV06 ? types_1.EntryPointV06Abi : types_1.EntryPointV07Abi,
-                    address: opInfo.entryPoint,
+                    address: entryPoint,
                     client: {
                         public: this.config.publicClient
                     }
@@ -400,7 +396,7 @@ 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,
@@ -418,7 +414,7 @@ class MemoryMempool {
         if (factory) {
             stakedEntityCount[factory] = (stakedEntityCount[factory] ?? 0) + 1;
         }
-        senders.add(op.sender);
+        senders.add(userOp.sender);
         return {
             skip: false,
             paymasterDeposit,
@@ -428,118 +424,153 @@ 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] = (0, utils_1.getNonceKeyAndValue)(aUserOp.nonce);
-                const [bNonceKey, bNonceValue] = (0, utils_1.getNonceKeyAndValue)(bUserOp.nonce);
+                const [aNonceKey, aNonceValue] = (0, utils_1.getNonceKeyAndSequence)(aUserOp.nonce);
+                const [bNonceKey, bNonceValue] = (0, utils_1.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 = (0, utils_1.isVersion06)(outstandingUserOps[0].userOp);
+        const allSameVersion = outstandingUserOps.every((userOpInfo) => {
+            const { userOp } = userOpInfo;
+            return (0, utils_1.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 ((0, utils_1.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 +
+                        ((0, utils_1.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 = (0, viem_1.getContract)({
             address: entryPoint,
-            abi: (0, utils_1.isVersion06)(userOperation)
-                ? types_1.EntryPointV06Abi
-                : types_1.EntryPointV07Abi,
+            abi: (0, utils_1.isVersion06)(userOp) ? types_1.EntryPointV06Abi : types_1.EntryPointV07Abi,
             client: {
                 public: this.config.publicClient
             }
         });
-        const [nonceKey, userOperationNonceValue] = (0, utils_1.getNonceKeyAndValue)(userOperation.nonce);
+        const [nonceKey, nonceSequence] = (0, utils_1.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 = (0, utils_1.getNonceKeyAndValue)(getNonceResult)[1];
+            currentNonceValue = (0, utils_1.getNonceKeyAndSequence)(getNonceResult)[1];
         }
         const outstanding = this.store
             .dumpOutstanding()
-            .map(({ userOperation }) => userOperation)
-            .filter((mempoolUserOp) => {
-            const [opNonceKey, opNonceValue] = (0, utils_1.getNonceKeyAndValue)(mempoolUserOp.nonce);
-            return (mempoolUserOp.sender === userOperation.sender &&
-                opNonceKey === nonceKey &&
-                opNonceValue >= currentNonceValue &&
-                opNonceValue < userOperationNonceValue);
+            .filter((userOpInfo) => {
+            const { userOp: mempoolUserOp } = userOpInfo;
+            const [mempoolNonceKey, mempoolNonceSequence] = (0, utils_1.getNonceKeyAndSequence)(mempoolUserOp.nonce);
+            return (mempoolUserOp.sender === userOp.sender &&
+                mempoolNonceKey === nonceKey &&
+                mempoolNonceSequence >= currentNonceValue &&
+                mempoolNonceSequence < nonceSequence);
         });
         outstanding.sort((a, b) => {
-            const [, aNonceValue] = (0, utils_1.getNonceKeyAndValue)(a.nonce);
-            const [, bNonceValue] = (0, utils_1.getNonceKeyAndValue)(b.nonce);
+            const aUserOp = a.userOp;
+            const bUserOp = b.userOp;
+            const [, aNonceValue] = (0, utils_1.getNonceKeyAndSequence)(aUserOp.nonce);
+            const [, bNonceValue] = (0, utils_1.getNonceKeyAndSequence)(bUserOp.nonce);
             return Number(aNonceValue - bNonceValue);
         });
-        return outstanding;
+        return outstanding.map((userOpInfo) => userOpInfo.userOp);
     }
     clear() {
         this.store.clear("outstanding");