@pimlico/alto 0.0.18 → 0.0.20

package/esm/mempool/mempool.js

@@ -1,21 +1,25 @@
-import { EntryPointV06Abi, EntryPointV07Abi, RpcError, ValidationErrors } from "../types/index.js";
-import { getAddressFromInitCodeOrPaymasterAndData, getUserOperationHash, isVersion06, isVersion07, scaleBigIntByPercent } from "../utils/index.js";
+import { ERC7769Errors, EntryPointV06Abi, EntryPointV07Abi, RpcError } from "../types/index.js";
+import { getAAError, getAddressFromInitCodeOrPaymasterAndData, getViemEntryPointVersion, isVersion06, isVersion07, jsonStringifyWithBigint, scaleBigIntByPercent } from "../utils/index.js";
 import { getAddress, getContract } from "viem";
+import { calculateAA95GasFloor } from "../executor/utils.js";
+import { getEip7702AuthAddress } from "../utils/eip7702.js";
 import { ReputationStatuses } from "./reputationManager.js";
 export class Mempool {
     config;
-    monitor;
+    metrics;
+    statusManager;
     reputationManager;
-    store;
     throttledEntityBundleCount;
     logger;
     validator;
     eventManager;
-    constructor({ config, monitor, reputationManager, validator, store, eventManager }) {
+    store;
+    constructor({ config, metrics, statusManager, reputationManager, validator, store, eventManager }) {
+        this.metrics = metrics;
         this.store = store;
         this.config = config;
         this.reputationManager = reputationManager;
-        this.monitor = monitor;
+        this.statusManager = statusManager;
         this.validator = validator;
         this.logger = config.getLogger({ module: "mempool" }, {
             level: config.logLevel
@@ -23,68 +27,105 @@ export class Mempool {
         this.throttledEntityBundleCount = 4; // we don't have any config for this as of now
         this.eventManager = eventManager;
     }
-    async replaceSubmitted({ userOpInfo, transactionInfo }) {
-        const entryPoint = transactionInfo.bundle.entryPoint;
-        const { userOpHash } = userOpInfo;
-        const sumbittedUserOps = await this.store.dumpSubmitted(entryPoint);
-        const existingUserOpToReplace = sumbittedUserOps.find((userOpInfo) => userOpInfo.userOpHash === userOpHash);
-        if (existingUserOpToReplace) {
-            await this.store.removeSubmitted({ entryPoint, userOpHash });
-            await this.store.addSubmitted({
-                entryPoint,
-                submittedUserOp: {
+    // === Methods for handling changing userOp state === //
+    async markUserOpsAsSubmitted({ userOps, transactionHash }) {
+        const userOpHashes = userOps.map((userOpInfo) => userOpInfo.userOpHash);
+        await this.statusManager.set(userOpHashes, {
+            status: "submitted",
+            transactionHash
+        });
+        this.metrics.userOpsSubmitted
+            .labels({ status: "success" })
+            .inc(userOps.length);
+    }
+    async resubmitUserOps({ userOps, entryPoint, reason }) {
+        await Promise.all(userOps.map(async (userOpInfo) => {
+            const { userOpHash, submissionAttempts } = userOpInfo;
+            const maxResubmits = this.config.maxResubmits;
+            // Check if max resubmits has been reached
+            if (maxResubmits !== undefined &&
+                submissionAttempts >= maxResubmits) {
+                this.logger.warn({
+                    userOpHash,
+                    submissionAttempts,
+                    maxResubmits
+                }, "dropping userOp: max resubmits reached");
+                const rejectedUserOp = {
                     ...userOpInfo,
-                    transactionInfo
-                }
+                    reason: "max resubmits reached"
+                };
+                await this.dropUserOps(entryPoint, [rejectedUserOp]);
+                return;
+            }
+            this.logger.warn({
+                userOpHash,
+                submissionAttempts,
+                reason
+            }, "resubmitting user operation");
+            // Complete processing before re-adding to outstanding pool.
+            await this.store.removeProcessing({
+                entryPoint,
+                userOpInfo
             });
-            await this.monitor.setUserOperationStatus(userOpHash, {
-                status: "submitted",
-                transactionHash: transactionInfo.transactionHash
+            const [success, failureReason] = await this.add({
+                userOpInfo,
+                entryPoint
             });
-        }
+            if (!success) {
+                this.logger.error({ userOpHash, failureReason }, "Failed to resubmit user operation");
+                const rejectedUserOp = {
+                    ...userOpInfo,
+                    reason: failureReason
+                };
+                this.dropUserOps(entryPoint, [rejectedUserOp]);
+            }
+        }));
+        this.metrics.userOpsResubmitted.inc(userOps.length);
     }
-    async markSubmitted({ userOpHash, transactionInfo }) {
-        const entryPoint = transactionInfo.bundle.entryPoint;
-        const processingUserOps = await this.store.dumpProcessing(entryPoint);
-        const processingUserOp = processingUserOps.find((userOpInfo) => userOpInfo.userOpHash === userOpHash);
-        if (processingUserOp) {
-            await this.store.removeProcessing({ entryPoint, userOpHash });
-            await this.store.addSubmitted({
+    async dropUserOps(entryPoint, rejectedUserOps) {
+        await Promise.all(rejectedUserOps.map(async (rejectedUserOp) => {
+            const { userOp, reason, userOpHash } = rejectedUserOp;
+            // Complete processing since userOp is dropped.
+            await this.store.removeProcessing({
                 entryPoint,
-                submittedUserOp: {
-                    ...processingUserOp,
-                    transactionInfo
-                }
+                userOpInfo: rejectedUserOp
             });
-            await this.monitor.setUserOperationStatus(userOpHash, {
-                status: "submitted",
-                transactionHash: transactionInfo.transactionHash
+            this.eventManager.emitDropped(userOpHash, reason, getAAError(reason));
+            await this.statusManager.set([userOpHash], {
+                status: "rejected",
+                transactionHash: null
             });
-        }
+            this.metrics.userOpsDropped.labels({ reason }).inc();
+            this.logger.warn({
+                userOperation: jsonStringifyWithBigint(userOp),
+                userOpHash,
+                reason
+            }, "user operation rejected");
+        }));
     }
+    // Remove userOps from processing store.
+    // should be called when userOps are included onchain.
+    async removeProcessing({ userOps, entryPoint }) {
+        await Promise.all(userOps.map(async (userOpInfo) => {
+            await this.store.removeProcessing({
+                entryPoint,
+                userOpInfo
+            });
+        }));
+    }
+    // === Methods for dropping mempool entries === //
     async dumpOutstanding(entryPoint) {
         return await this.store.dumpOutstanding(entryPoint);
     }
-    async dumpProcessing(entryPoint) {
-        return await this.store.dumpProcessing(entryPoint);
-    }
-    async dumpSubmittedOps(entryPoint) {
-        return await this.store.dumpSubmitted(entryPoint);
-    }
-    async removeSubmitted({ entryPoint, userOpHash }) {
-        await this.store.removeSubmitted({ entryPoint, userOpHash });
-    }
-    async removeProcessing({ entryPoint, userOpHash }) {
-        await this.store.removeProcessing({ entryPoint, userOpHash });
-    }
+    // === Methods for entity management === //
     async checkEntityMultipleRoleViolation(entryPoint, op) {
         if (!this.config.safeMode) {
-            return Promise.resolve();
+            return;
         }
         const knownEntities = await this.getKnownEntities(entryPoint);
         if (knownEntities.paymasters.has(op.sender) ||
             knownEntities.factories.has(op.sender)) {
-            throw new RpcError(`The sender address "${op.sender}" is used as a different entity in another UserOperation currently in mempool`, ValidationErrors.OpcodeValidation);
+            throw new RpcError(`The sender address "${op.sender}" is used as a different entity in another UserOperation currently in mempool`, ERC7769Errors.OpcodeValidation);
         }
         let paymaster = null;
         let factory = null;
@@ -97,12 +138,11 @@ export class Mempool {
             factory = op.factory;
         }
         if (paymaster && knownEntities.sender.has(paymaster)) {
-            throw new RpcError(`A Paymaster at ${paymaster} in this UserOperation is used as a sender entity in another UserOperation currently in mempool.`, ValidationErrors.OpcodeValidation);
+            throw new RpcError(`A Paymaster at ${paymaster} in this UserOperation is used as a sender entity in another UserOperation currently in mempool.`, ERC7769Errors.OpcodeValidation);
         }
         if (factory && knownEntities.sender.has(factory)) {
-            throw new RpcError(`A Factory at ${factory} in this UserOperation is used as a sender entity in another UserOperation currently in mempool.`, ValidationErrors.OpcodeValidation);
+            throw new RpcError(`A Factory at ${factory} in this UserOperation is used as a sender entity in another UserOperation currently in mempool.`, ERC7769Errors.OpcodeValidation);
         }
-        return Promise.resolve();
     }
     async getKnownEntities(entryPoint) {
         // TODO: this won't work with redis
@@ -131,21 +171,14 @@ export class Mempool {
         }
         return entities;
     }
-    async add(userOp, entryPoint, referencedContracts) {
-        const userOpHash = await getUserOperationHash({
-            userOperation: userOp,
-            entryPointAddress: entryPoint,
-            chainId: this.config.chainId,
-            publicClient: this.config.publicClient
-        });
-        // Check if the exact same userOperation is already in the mempool.
-        if (await this.store.isInMempool({ userOpHash, entryPoint })) {
-            return [false, "Already known"];
-        }
-        // Check if there is a conflicting userOp already being processed
-        const validation = await this.store.validateSubmittedOrProcessing({
+    // === Methods for adding userOps / creating bundles === //
+    async add({ userOpInfo, entryPoint }) {
+        const { userOp, userOpHash } = userOpInfo;
+        // Check if the userOp is already known or conflicts with existing operations
+        const validation = await this.store.checkDuplicatesAndConflicts({
             entryPoint,
-            userOp
+            userOp,
+            userOpHash
         });
         if (!validation.valid) {
             return [false, validation.reason];
@@ -156,7 +189,7 @@ export class Mempool {
             userOp
         });
         if (conflicting) {
-            const { userOpInfo, reason } = conflicting;
+            const { userOpInfo, conflictReason } = conflicting;
             const conflictingUserOp = userOpInfo.userOp;
             const hasHigherPriorityFee = userOp.maxPriorityFeePerGas >=
                 scaleBigIntByPercent(conflictingUserOp.maxPriorityFeePerGas, 110n);
@@ -164,37 +197,68 @@ export class Mempool {
                 scaleBigIntByPercent(conflictingUserOp.maxFeePerGas, 110n);
             const hasHigherFees = hasHigherPriorityFee && hasHigherMaxFee;
             if (!hasHigherFees) {
-                const message = reason === "conflicting_deployment"
-                    ? "AA10 sender already constructed: A conflicting userOperation with initCode for this sender is already in the mempool"
-                    : "AA25 invalid account nonce: User operation already present in mempool";
+                let message;
+                if (conflictReason === "conflicting_deployment") {
+                    message =
+                        "AA10 sender already constructed: A conflicting userOperation with initCode for this sender is already in the mempool";
+                }
+                else if (conflictReason === "conflicting_7702_auth") {
+                    message =
+                        "AA10 sender already constructed: Sender already has an inflight EIP-7702 authorization";
+                }
+                else {
+                    message =
+                        "AA25 invalid account nonce: User operation already present in mempool";
+                }
                 // Re-add to outstanding as it wasn't replaced
                 await this.store.addOutstanding({
                     entryPoint,
-                    userOpInfo: conflicting.userOpInfo
+                    userOpInfos: [conflicting.userOpInfo]
                 });
                 return [false, `${message}, bump the gas price by minimum 10%`];
             }
-            await this.reputationManager.replaceUserOperationSeenStatus(conflictingUserOp, entryPoint);
+            await this.reputationManager.replaceUserOpSeenStatus(conflictingUserOp, entryPoint);
         }
-        await this.reputationManager.increaseUserOperationSeenStatus(userOp, entryPoint);
+        await this.reputationManager.increaseUserOpSeenStatus(userOp, entryPoint);
         await this.store.addOutstanding({
             entryPoint,
-            userOpInfo: {
-                userOp,
-                userOpHash,
-                referencedContracts,
-                addedToMempool: Date.now()
-            }
+            userOpInfos: [userOpInfo]
         });
-        await this.monitor.setUserOperationStatus(userOpHash, {
+        await this.statusManager.set([userOpHash], {
             status: "not_submitted",
             transactionHash: null
         });
-        await this.eventManager.emitAddedToMempool(userOpHash);
+        this.eventManager.emitAddedToMempool(userOpHash);
         return [true, ""];
     }
     // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
-    async shouldSkip({ userOpInfo, paymasterDeposit, stakedEntityCount, knownEntities, senders, storageMap, entryPoint }) {
+    async shouldSkip({ userOpInfo, paymasterDeposit, touchedEip7702Auth, stakedEntityCount, knownEntities, senders, storageMap, entryPoint }) {
+        const { userOp, userOpHash, referencedContracts } = userOpInfo;
+        // Check conflicting EIP-7702 auths (same sender, different delegate address)
+        if (userOp.eip7702Auth) {
+            const auth = getEip7702AuthAddress(userOp.eip7702Auth);
+            const existingAuth = touchedEip7702Auth.get(userOp.sender);
+            if (existingAuth && existingAuth !== auth) {
+                this.logger.warn({
+                    userOpHash,
+                    conflictingAuth: auth,
+                    existingAuth
+                }, "Conflicting EIP-7702 auths");
+                return {
+                    skip: true,
+                    removeOutstanding: false,
+                    paymasterDeposit,
+                    touchedEip7702Auth,
+                    stakedEntityCount,
+                    knownEntities,
+                    senders,
+                    storageMap
+                };
+            }
+            if (!existingAuth) {
+                touchedEip7702Auth.set(userOp.sender, auth);
+            }
+        }
         if (!this.config.safeMode) {
             return {
                 skip: false,
@@ -202,10 +266,10 @@ export class Mempool {
                 stakedEntityCount,
                 knownEntities,
                 senders,
-                storageMap
+                storageMap,
+                touchedEip7702Auth
             };
         }
-        const { userOp, userOpHash, referencedContracts } = userOpInfo;
         const isUserOpV06 = isVersion06(userOp);
         const paymaster = isUserOpV06
             ? getAddressFromInitCodeOrPaymasterAndData(userOp.paymasterAndData)
@@ -224,7 +288,8 @@ export class Mempool {
                 stakedEntityCount,
                 knownEntities,
                 senders,
-                storageMap
+                storageMap,
+                touchedEip7702Auth
             };
         }
         if (paymasterStatus === ReputationStatuses.throttled &&
@@ -240,7 +305,8 @@ export class Mempool {
                 stakedEntityCount,
                 knownEntities,
                 senders,
-                storageMap
+                storageMap,
+                touchedEip7702Auth
             };
         }
         if (factoryStatus === ReputationStatuses.throttled &&
@@ -256,7 +322,8 @@ export class Mempool {
                 stakedEntityCount,
                 knownEntities,
                 senders,
-                storageMap
+                storageMap,
+                touchedEip7702Auth
             };
         }
         if (senders.has(userOp.sender) &&
@@ -271,22 +338,22 @@ export class Mempool {
                 stakedEntityCount,
                 knownEntities,
                 senders,
-                storageMap
+                storageMap,
+                touchedEip7702Auth
             };
         }
         let validationResult;
         try {
-            let queuedUserOperations = [];
+            let queuedUserOps = [];
             if (!isUserOpV06) {
-                queuedUserOperations = await this.getQueuedOustandingUserOps({
+                queuedUserOps = await this.getQueuedOutstandingUserOps({
                     userOp,
                     entryPoint
                 });
             }
-            validationResult = await this.validator.validateUserOperation({
-                shouldCheckPrefund: false,
-                userOperation: userOp,
-                queuedUserOperations,
+            validationResult = await this.validator.validateUserOp({
+                userOp,
+                queuedUserOps,
                 entryPoint,
                 referencedContracts
             });
@@ -296,15 +363,16 @@ export class Mempool {
                 userOpHash,
                 error: JSON.stringify(e)
             }, "2nd Validation error");
-            this.store.removeOutstanding({ entryPoint, userOpHash });
-            this.reputationManager.decreaseUserOperationSeenStatus(userOp, entryPoint, e instanceof RpcError ? e.message : JSON.stringify(e));
+            await this.store.removeOutstanding({ entryPoint, userOpHash });
+            this.reputationManager.decreaseUserOpSeenStatus(userOp, entryPoint, e instanceof RpcError ? e.message : JSON.stringify(e));
             return {
                 skip: true,
                 paymasterDeposit,
                 stakedEntityCount,
                 knownEntities,
                 senders,
-                storageMap
+                storageMap,
+                touchedEip7702Auth
             };
         }
         for (const storageAddress of Object.keys(validationResult.storageMap)) {
@@ -321,7 +389,8 @@ export class Mempool {
                     stakedEntityCount,
                     knownEntities,
                     senders,
-                    storageMap
+                    storageMap,
+                    touchedEip7702Auth
                 };
             }
         }
@@ -349,7 +418,8 @@ export class Mempool {
                     stakedEntityCount,
                     knownEntities,
                     senders,
-                    storageMap
+                    storageMap,
+                    touchedEip7702Auth
                 };
             }
             stakedEntityCount[paymaster] =
@@ -366,7 +436,8 @@ export class Mempool {
             stakedEntityCount,
             knownEntities,
             senders,
-            storageMap
+            storageMap,
+            touchedEip7702Auth
         };
     }
     async getBundles(maxBundleCount) {
@@ -374,7 +445,6 @@ export class Mempool {
             return await this.process({
                 entryPoint,
                 maxGasLimit: this.config.maxGasPerBundle,
-                minOpsPerBundle: 1,
                 maxBundleCount
             });
         });
@@ -383,57 +453,56 @@ export class Mempool {
         return bundles;
     }
     // Returns a bundle of userOperations in array format.
-    async process({ maxGasLimit, entryPoint, minOpsPerBundle, maxBundleCount }) {
-        // Check if there are any operations in the store
-        const firstOp = await this.store.peekOutstanding(entryPoint);
-        if (!firstOp) {
+    async process({ maxGasLimit, entryPoint, maxBundleCount }) {
+        const bundles = [];
+        const batchSize = this.config.mempoolPopBatchSize;
+        // Pop batch of userOps.
+        const poppedUserOps = await this.store.popOutstanding(entryPoint, batchSize);
+        if (poppedUserOps.length === 0) {
             return [];
         }
-        // Get EntryPoint version
-        const isV6 = isVersion06(firstOp.userOp);
-        const bundles = [];
-        const seenOps = new Set();
-        let breakLoop = false;
-        // Process operations until no more are available or we hit maxBundleCount
-        while (await this.store.peekOutstanding(entryPoint)) {
-            // If maxBundles is set and we reached the limit, break
+        // Keep track of unused ops from the batch
+        const unusedUserOps = [...poppedUserOps];
+        while (unusedUserOps.length > 0) {
+            // If maxBundles is set and we reached the limit, put back all unused ops and break.
             if (maxBundleCount && bundles.length >= maxBundleCount) {
+                if (unusedUserOps.length > 0) {
+                    await this.store.addOutstanding({
+                        entryPoint,
+                        userOpInfos: unusedUserOps
+                    });
+                }
                 break;
             }
-            // Setup for next bundle
+            // Peek next userOp from unused batch.
+            const nextUserOp = unusedUserOps[0];
+            if (!nextUserOp)
+                break;
+            // Derive version.
+            const version = getViemEntryPointVersion(nextUserOp.userOp, entryPoint);
+            // Setup next bundle.
             const currentBundle = {
                 entryPoint,
-                version: isV6 ? "0.6" : "0.7",
-                userOps: []
+                version,
+                userOps: [],
+                submissionAttempts: 0
             };
             let gasUsed = 0n;
+            let touchedEip7702Auth = new Map();
             let paymasterDeposit = {};
             let stakedEntityCount = {};
             let senders = new Set();
             let knownEntities = await this.getKnownEntities(entryPoint);
             let storageMap = {};
-            if (breakLoop) {
-                break;
-            }
-            // Keep adding ops to current bundle
-            while (await this.store.peekOutstanding(entryPoint)) {
-                const userOpInfo = await this.store.popOutstanding(entryPoint);
-                if (!userOpInfo) {
+            while (unusedUserOps.length > 0) {
+                const currentUserOp = unusedUserOps.shift();
+                if (!currentUserOp)
                     break;
-                }
-                if (seenOps.has(userOpInfo.userOpHash)) {
-                    breakLoop = true;
-                    await this.store.addOutstanding({
-                        entryPoint,
-                        userOpInfo
-                    });
-                    break;
-                }
-                seenOps.add(userOpInfo.userOpHash);
-                const { userOp } = userOpInfo;
+                const { userOp } = currentUserOp;
                 // Check if we should skip this operation
                 const skipResult = await this.shouldSkip({
-                    userOpInfo,
+                    userOpInfo: currentUserOp,
+                    touchedEip7702Auth,
                     paymasterDeposit,
                     stakedEntityCount,
                     knownEntities,
@@ -446,23 +515,20 @@ export class Mempool {
                     if (!skipResult.removeOutstanding) {
                         await this.store.addOutstanding({
                             entryPoint,
-                            userOpInfo
+                            userOpInfos: [currentUserOp]
                         });
                     }
+                    // Continue with next op from batch
                     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) {
-                    // Put the operation back in the store
-                    await this.store.addOutstanding({ entryPoint, userOpInfo });
+                gasUsed += calculateAA95GasFloor({
+                    userOps: [userOp],
+                    beneficiary: this.config.utilityWalletAddress
+                });
+                // Check bundle gasLimit if bundle is not empty
+                if (currentBundle.userOps.length > 0 && gasUsed > maxGasLimit) {
+                    // Put current op back to front of unused for next bundle
+                    unusedUserOps.unshift(currentUserOp);
                     break;
                 }
                 // Update state based on skip result
@@ -471,10 +537,20 @@ export class Mempool {
                 knownEntities = skipResult.knownEntities;
                 senders = skipResult.senders;
                 storageMap = skipResult.storageMap;
-                this.reputationManager.decreaseUserOperationCount(userOp);
-                this.store.addProcessing({ entryPoint, userOpInfo });
-                // Add op to current bundle
-                currentBundle.userOps.push(userOpInfo);
+                touchedEip7702Auth = skipResult.touchedEip7702Auth;
+                this.reputationManager.decreaseUserOpCount(userOp);
+                // Track the operation as active (being bundled).
+                await this.store.addProcessing({
+                    entryPoint,
+                    userOpInfo: currentUserOp
+                });
+                // Add userOp to current bundle.
+                currentBundle.userOps.push(currentUserOp);
+                // Try to fetch more userOps if we've exhausted this batch.
+                if (unusedUserOps.length === 0) {
+                    const morePoppedOps = await this.store.popOutstanding(entryPoint, batchSize);
+                    unusedUserOps.push(...morePoppedOps);
+                }
             }
             if (currentBundle.userOps.length > 0) {
                 bundles.push(currentBundle);
@@ -487,7 +563,7 @@ export class Mempool {
             this.store.clearOutstanding(entryPoint);
         }
     }
-    async getQueuedOustandingUserOps(args) {
+    async getQueuedOutstandingUserOps(args) {
         return await this.store.getQueuedOutstandingUserOps(args);
     }
 }