Fixed execution context not cleared after getTxs invocation

Author: rpanic

packages/sequencer/src/mempool/private/PrivateMempool.ts

@@ -94,55 +94,49 @@ export class PrivateMempool extends SequencerModule implements Mempool {
 
   public async getTxs(): Promise<PendingTransaction[]> {
     const txs = await this.transactionStorage.getPendingUserTransactions();
-    const sortedTxs: PendingTransaction[] = [];
-    const skippedTxs: Record<string, MempoolTransactionPaths> = {};
-    const executionContext = container.resolve<RuntimeMethodExecutionContext>(
-      RuntimeMethodExecutionContext
-    );
+
     const baseCachedStateService = new CachedStateService(this.stateService);
 
     const networkState =
       (await this.getStagedNetworkState()) ?? NetworkState.empty();
 
-    await this.checkTxValid(
+    const sortedTxs = await this.checkTxValid(
       txs,
-      sortedTxs,
-      skippedTxs,
       baseCachedStateService,
       this.protocol.stateServiceProvider,
-      networkState,
-      executionContext
+      networkState
     );
     this.protocol.stateServiceProvider.popCurrentStateService();
     return sortedTxs;
   }
 
-  public async start(): Promise<void> {
-    noop();
-  }
-
   // We iterate through the transactions. For each tx we run the account state hook.
   // If the txs succeeds then it can be returned. If it fails then we keep track of it
   // in the skipped txs list and when later txs succeed we check to see if any state transition
   // paths are shared between the just succeeded tx and any of the skipped txs. This is
   // because a failed tx may succeed now if the failure was to do with a nonce issue, say.
   private async checkTxValid(
     transactions: PendingTransaction[],
-    sortedTransactions: PendingTransaction[],
-    skippedTransactions: Record<string, MempoolTransactionPaths>,
     baseService: CachedStateService,
     stateServiceProvider: StateServiceProvider,
-    networkState: NetworkState,
-    executionContext: RuntimeMethodExecutionContext
+    networkState: NetworkState
   ) {
+    const executionContext = container.resolve<RuntimeMethodExecutionContext>(
+      RuntimeMethodExecutionContext
+    );
+    executionContext.clear();
+
+    // Initialize starting state
+    const sortedTransactions: PendingTransaction[] = [];
+    const skippedTransactions: Record<string, MempoolTransactionPaths> = {};
+
     for (const [index, tx] of transactions.entries()) {
       const txStateService = new CachedStateService(baseService);
       stateServiceProvider.setCurrentStateService(txStateService);
       const contextInputs: RuntimeMethodExecutionData = {
         networkState: networkState,
         transaction: tx.toProtocolTransaction().transaction,
       };
-      executionContext.clear();
       executionContext.setup(contextInputs);
 
       const signedTransaction = tx.toProtocolTransaction();
@@ -155,6 +149,7 @@ export class PrivateMempool extends SequencerModule implements Mempool {
       delete transactions[index];
       const { status, statusMessage, stateTransitions } =
         executionContext.current().result;
+
       if (status.toBoolean()) {
         log.info(`Accepted tx ${tx.hash().toString()}`);
         sortedTransactions.push(tx);
@@ -191,6 +186,13 @@ export class PrivateMempool extends SequencerModule implements Mempool {
           };
         }
       }
+
+      executionContext.clear();
     }
+    return sortedTransactions;
+  }
+
+  public async start(): Promise<void> {
+    noop();
   }
 }