remove from outstanding when found conflicting

Author: mouseless0x

src/mempool/mempool.ts

@@ -287,40 +287,39 @@ export class Mempool {
         })
 
         if (conflicting) {
-            const oldOp = conflicting.userOp
-            const newOp = userOp
+            const { userOpInfo, reason } = conflicting
+            const conflictingUserOp = userOpInfo.userOp
 
             const hasHigherPriorityFee =
-                newOp.maxPriorityFeePerGas >=
-                scaleBigIntByPercent(oldOp.maxPriorityFeePerGas, 110n)
+                userOp.maxPriorityFeePerGas >=
+                scaleBigIntByPercent(
+                    conflictingUserOp.maxPriorityFeePerGas,
+                    110n
+                )
 
             const hasHigherMaxFee =
-                newOp.maxFeePerGas >=
-                scaleBigIntByPercent(oldOp.maxFeePerGas, 110n)
+                userOp.maxFeePerGas >=
+                scaleBigIntByPercent(conflictingUserOp.maxFeePerGas, 110n)
 
             const hasHigherFees = hasHigherPriorityFee && hasHigherMaxFee
 
             if (!hasHigherFees) {
-                const reason =
-                    conflicting.reason === "conflicting_deployment"
+                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"
 
-                await this.store.addOutstanding(conflicting)
-                return [false, `${reason}, bump the gas price by minimum 10%`]
-            }
-
-            await this.store.removeOutstanding({
-                entryPoint,
-                userOpHash: getUserOperationHash(
-                    conflicting.userOp,
+                // Re-add to outstanding as it wasn't replaced
+                await this.store.addOutstanding({
                     entryPoint,
-                    this.config.chainId
-                )
-            })
+                    userOpInfo: conflicting.userOpInfo
+                })
+
+                return [false, `${message}, bump the gas price by minimum 10%`]
+            }
 
             await this.reputationManager.replaceUserOperationSeenStatus(
-                oldOp,
+                conflictingUserOp,
                 entryPoint
             )
         }

src/store/createMemoryOutstandingStore.ts

@@ -5,7 +5,7 @@ import {
 } from "../utils/userop"
 import { AltoConfig } from "../createConfig"
 import { HexData32, UserOpInfo, UserOperation } from "@alto/types"
-import { ConflictingType, OutstandingStore } from "."
+import { ConflictingOutstandingType, OutstandingStore } from "."
 import { Logger } from "@alto/utils"
 
 const senderNonceSlot = (userOp: UserOperation) => {
@@ -82,10 +82,12 @@ export class MemoryOutstanding implements OutstandingStore {
         return true
     }
 
-    async popConflicting(userOp: UserOperation): Promise<ConflictingType> {
+    async popConflicting(
+        userOp: UserOperation
+    ): Promise<ConflictingOutstandingType> {
         const outstandingOps = this.dump()
 
-        let conflictingReason: ConflictingType = undefined
+        let conflictingReason: ConflictingOutstandingType = undefined
 
         for (const userOpInfo of outstandingOps) {
             const { userOp: mempoolUserOp } = userOpInfo
@@ -95,7 +97,7 @@ export class MemoryOutstanding implements OutstandingStore {
                 this.remove(userOpInfo.userOpHash)
                 conflictingReason = {
                     reason: "conflicting_nonce",
-                    userOp: userOpInfo.userOp
+                    userOpInfo
                 }
                 break
             }
@@ -125,7 +127,7 @@ export class MemoryOutstanding implements OutstandingStore {
                 this.remove(userOpInfo.userOpHash)
                 conflictingReason = {
                     reason: "conflicting_deployment",
-                    userOp: userOpInfo.userOp
+                    userOpInfo
                 }
                 break
             }
@@ -305,7 +307,9 @@ export class MemoryOutstanding implements OutstandingStore {
     }
 
     // Adding findConflicting method to maintain compatibility with Store interface
-    async findConflicting(userOp: UserOperation): Promise<ConflictingType> {
+    async findConflicting(
+        userOp: UserOperation
+    ): Promise<ConflictingOutstandingType> {
         return this.popConflicting(userOp)
     }
 }

src/store/createRedisOutstandingStore.ts

@@ -237,7 +237,7 @@ class RedisOutstandingQueue implements OutstandingStore {
             await this.remove(conflicting.userOpHash)
             return {
                 reason: "conflicting_nonce" as const,
-                userOp: conflicting.userOp
+                userOpInfo: conflicting
             }
         }
 
@@ -271,7 +271,7 @@ class RedisOutstandingQueue implements OutstandingStore {
                         await this.remove(conflictingUserOp.userOpHash)
                         return {
                             reason: "conflicting_deployment" as const,
-                            userOp: conflictingUserOp.userOp
+                            userOpInfo: conflictingUserOp
                         }
                     }
                 }

src/store/index.ts

@@ -10,7 +10,14 @@ import type {
 export type StoreType = "outstanding" | "processing" | "submitted"
 export type UserOpType = UserOpInfo | SubmittedUserOp
 
-export type ConflictingType =
+export type ConflictingOutstandingType =
+    | {
+          reason: "conflicting_nonce" | "conflicting_deployment"
+          userOpInfo: UserOpInfo
+      }
+    | undefined
+
+export type ConflictingStoreType =
     | {
           reason: "conflicting_nonce" | "conflicting_deployment"
           userOp: UserOperation
@@ -70,7 +77,7 @@ export type MempoolStore = {
     popConflictingOustanding: (args: {
         entryPoint: Address
         userOp: UserOperation
-    }) => Promise<ConflictingType>
+    }) => Promise<ConflictingOutstandingType>
     validateSubmittedOrProcessing: (
         args: EntryPointUserOpParam
     ) => Promise<ValidationResult>
@@ -95,13 +102,13 @@ export type BaseStore<T extends UserOpType = UserOpType> = {
 }
 
 export type Store<T extends UserOpType> = BaseStore<T> & {
-    findConflicting: (args: UserOperation) => Promise<ConflictingType>
+    findConflicting: (args: UserOperation) => Promise<ConflictingStoreType>
 }
 
 export type OutstandingStore = BaseStore<UserOpInfo> & {
     clear: () => Promise<void>
     // Will remove and return the first conflicting userOpInfo
-    popConflicting: (args: UserOperation) => Promise<ConflictingType>
+    popConflicting: (args: UserOperation) => Promise<ConflictingOutstandingType>
     validateQueuedLimit: (userOp: UserOperation) => boolean
     validateParallelLimit: (userOp: UserOperation) => boolean
     getQueuedUserOps: (userOp: UserOperation) => Promise<UserOperation[]>