removes loops from getNewBlockTransactions

when creating a new block template the mining manager collects a list of
transactions to include in the block.

the mining manager iterates over transactions in the mempool, verifies the
spends in the transactions, and tracks the total size and total fee from
included transactions.

we currently iterate over the spends in each transaction twice: once to ensure
that two transactions included in the block do not include the same spend and
again to verify each spend in the included transaction.

we also iterate over the list of included transactions twice after collecting
them: once to read the fee from the transaction and again to sum the fees.

these changes remove the extra iteration over spends and included transactions.
performance gains will likely be neglible.

ironfish/src/consensus/verifier.ts

@@ -329,16 +329,28 @@ export class Verifier {
         if (reason) {
           return { valid: false, reason }
         }
-
-        if (await this.chain.nullifiers.contains(spend.nullifier, tx)) {
-          return { valid: false, reason: VerificationResultReason.DOUBLE_SPEND }
-        }
       }
 
       return { valid: true }
     })
   }
 
+  async verifySpend(
+    spend: Spend,
+    notesSize: number,
+    tx?: IDatabaseTransaction,
+  ): Promise<VerificationResultReason | undefined> {
+    const reason = await this.verifySpendCommitment(spend, notesSize, tx)
+
+    if (reason) {
+      return reason
+    }
+
+    if (await this.chain.nullifiers.contains(spend.nullifier, tx)) {
+      return VerificationResultReason.DOUBLE_SPEND
+    }
+  }
+
   async verifyTransactionAdd(
     transaction: Transaction,
     tx?: IDatabaseTransaction,
@@ -409,7 +421,7 @@ export class Verifier {
       Assert.isNotNull(previousNotesSize)
 
       for (const spend of block.spends()) {
-        const verificationError = await this.verifySpend(spend, previousNotesSize, tx)
+        const verificationError = await this.verifySpendCommitment(spend, previousNotesSize, tx)
         if (verificationError) {
           return { valid: false, reason: verificationError }
         }
@@ -454,7 +466,7 @@ export class Verifier {
    * @param notesSize the size of the notes tree
    * @param tx optional transaction context within which to check the spends.
    */
-  async verifySpend(
+  async verifySpendCommitment(
     spend: Spend,
     notesSize: number,
     tx?: IDatabaseTransaction,

ironfish/src/mining/manager.ts

@@ -71,9 +71,12 @@ export class MiningManager {
   }> {
     const startTime = BenchUtils.start()
 
+    const notesSize = await this.chain.notes.size()
+
     // Fetch pending transactions
     const blockTransactions: Transaction[] = []
     const nullifiers = new BufferSet()
+    let totalTransactionFees = BigInt(0)
     for (const transaction of this.memPool.orderedTransactions()) {
       // Skip transactions that would cause the block to exceed the max size
       const transactionSize = getTransactionSize(transaction)
@@ -85,31 +88,27 @@ export class MiningManager {
         continue
       }
 
-      const isConflicted = transaction.spends.find((spend) => nullifiers.has(spend.nullifier))
-      if (isConflicted) {
-        continue
-      }
+      for (const spend of transaction.spends) {
+        if (nullifiers.has(spend.nullifier)) {
+          continue
+        }
 
-      const { valid: isValid } = await this.chain.verifier.verifyTransactionSpends(transaction)
-      if (!isValid) {
-        continue
+        const reason = await this.chain.verifier.verifySpend(spend, notesSize)
+
+        if (reason) {
+          continue
+        }
       }
 
       for (const spend of transaction.spends) {
         nullifiers.add(spend.nullifier)
       }
 
       currBlockSize += transactionSize
+      totalTransactionFees += transaction.fee()
       blockTransactions.push(transaction)
     }
 
-    // Sum the transaction fees
-    let totalTransactionFees = BigInt(0)
-    const transactionFees = await Promise.all(blockTransactions.map((t) => t.fee()))
-    for (const transactionFee of transactionFees) {
-      totalTransactionFees += transactionFee
-    }
-
     this.metrics.mining_newBlockTransactions.add(BenchUtils.end(startTime))
 
     return {