Refactorings

Author: rpanic

packages/protocol/test/prover/block/BlockProver.test.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-len */
 /**
  * Testing strategy:
  *
@@ -9,3 +10,5 @@
  * - Test correct integration of the STProof - both defer and notDefer
  * - proveBlock: correct blockNumber progression, closed flag (doesn't accepts closed proofs as tx proofs)
  */
+
+/* eslint-enable max-len */

packages/protocol/test/prover/statetransition/StateTransitionProver.test.ts

@@ -44,19 +44,19 @@ describe("StateTransitionProver", () => {
     });
   }
 
-  function applyToTree(
-    tree: RollupMerkleTree,
-    batches: StateTransitionProvableBatch[],
-    indizes: number[]
-  ) {
-    const flat = batches.flatMap((batch) => batch.batch);
-    indizes.forEach((index) => {
-      const st = flat[index].stateTransition;
-      if (st.to.isSome) {
-        tree.setLeaf(st.path.toBigInt(), st.to.value);
-      }
-    });
-  }
+  // function applyToTree(
+  //   tree: RollupMerkleTree,
+  //   batches: StateTransitionProvableBatch[],
+  //   indizes: number[]
+  // ) {
+  //   const flat = batches.flatMap((batch) => batch.batch);
+  //   indizes.forEach((index) => {
+  //     const st = flat[index].stateTransition;
+  //     if (st.to.isSome) {
+  //       tree.setLeaf(st.path.toBigInt(), st.to.value);
+  //     }
+  //   });
+  // }
 
   describe("currentBatchHash", () => {
     it.each([

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

@@ -119,6 +119,8 @@ export class PrivateMempool extends SequencerModule implements Mempool {
   // 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.
+  // TODO Refactor
+  // eslint-disable-next-line sonarjs/cognitive-complexity
   private async checkTxValid(
     transactions: PendingTransaction[],
     baseService: CachedStateService,

packages/sequencer/src/protocol/production/tracing/BlockTracingService.ts

@@ -43,10 +43,6 @@ export type BlockTrace = {
 export class BlockTracingService {
   public constructor(
     private readonly transactionTracing: TransactionTracingService
-    // TODO Think about remove the state service for tracing
-    // TODO Properly replace AsyncStateService by masking
-    // @inject("AsyncStateService")
-    // stateService: AsyncStateService
   ) {}
 
   public async traceBlock(

packages/sequencer/src/protocol/production/tracing/StateTransitionTracingService.ts

@@ -155,8 +155,10 @@ export class StateTransitionTracingService {
 
               finalizedStateRoot = danglingStateRoot;
 
+              // We can reuse the batchMerkleStore here, since mergeIntoParent()
+              // resets the only state that the store has, therefore its equivalent
+              // to creating a new one
               batchMerkleStore.mergeIntoParent();
-              // TODO See if reusing the existing store works
             } else if (
               type.type
                 .equals(StateTransitionType.closeAndThrowAway)

packages/sequencer/test/integration/StorageIntegration.test.ts

@@ -149,18 +149,17 @@ describe.each([["InMemory", InMemoryDatabase]])(
 
       expect(blocks).toHaveLength(1);
 
-      const { lastBlockResult, block } = blocks[0];
+      const { block } = blocks[0];
 
-      expect(lastBlockResult).toBeUndefined();
-      expect(block.block.hash.toBigInt()).toStrictEqual(
+      expect(block.hash.toBigInt()).toStrictEqual(
         generatedBlock.hash.toBigInt()
       );
 
       const blockStorage = sequencer.resolve(
         "BlockStorage"
       ) as HistoricalBlockStorage & BlockStorage;
       const block2 = await blockStorage.getBlockAt(
-        Number(blocks[0].block.block.height.toString())
+        Number(blocks[0].block.height.toString())
       );
 
       expectDefined(block2);
@@ -169,7 +168,7 @@ describe.each([["InMemory", InMemoryDatabase]])(
       );
 
       const stateDiff = collectStateDiff(
-        block.block.transactions.flatMap((tx) =>
+        block.transactions.flatMap((tx) =>
           tx.stateTransitions.flatMap((batch) => batch.stateTransitions)
         )
       );