feat: chunk genesis sync

packages/query/src/block-processor.ts

@@ -74,6 +74,12 @@
   skipTrialDecrypt?: boolean;
 }
 
+interface ProcessGenesisBlockParams {
+  start: number;
+  compactBlock: CompactBlock;
+  skipTrialDecrypt?: boolean;
+}
+
 const POSITION_STATES: PositionState[] = [
   new PositionState({ state: PositionState_PositionStateEnum.OPENED }),
   new PositionState({ state: PositionState_PositionStateEnum.CLOSED }),
@@ -145,6 +151,7 @@
    */
   private async syncAndStore() {
     const PRE_GENESIS_SYNC_HEIGHT = -1n;
+    const GENESIS_CHUNK_SIZE = 500;
 
     // start at next block, or genesis if height is undefined
     let currentHeight = (await this.indexedDb.getFullSyncHeight()) ?? PRE_GENESIS_SYNC_HEIGHT;
@@ -177,17 +184,46 @@
       if (this.genesisBlock?.height === currentHeight + 1n) {
         currentHeight = this.genesisBlock.height;
 
-        // Set the trial decryption flag for the genesis compact block
+        // determine whether to skip trial decryption at genesis
         const skipTrialDecrypt = shouldSkipTrialDecrypt(
           this.walletCreationBlockHeight,
           currentHeight,
         );
 
-        await this.processBlock({
-          compactBlock: this.genesisBlock,
-          latestKnownBlockHeight: latestKnownBlockHeight,
-          skipTrialDecrypt,
-        });
+        // to prevent blocking the single-threaded service worker environment, iterate through
+        // the genesis block's state payloads in manageable chunks to prevent blocking the
+        // single threaded service worker runtime. This approach segments the computationally
+        // intensive tasks of trial decryption and merkle poseidon hashing.
+        for (
+          let start = 0;
+          start < this.genesisBlock.statePayloads.length;
+          start += GENESIS_CHUNK_SIZE
+        ) {
+          // slice out a subset of state payloads
+          const chunkedPayloads = this.genesisBlock.statePayloads.slice(
+            start,
+            start + GENESIS_CHUNK_SIZE,
+          );
+
+          const chunkedBlock = new CompactBlock({
+            ...toPlainMessage(this.genesisBlock),
+            statePayloads: chunkedPayloads,
+          });
+
+          await this.trialDecryptGenesisChunk({
+            start,
+            compactBlock: chunkedBlock,
+            skipTrialDecrypt,
+          });
+
+          // check if this is the last chunk
+          if (start + GENESIS_CHUNK_SIZE >= this.genesisBlock.statePayloads.length) {
+            await this.genesisAdvice(this.genesisBlock);
+          }
+
+          // critically, we yield the event loop after each chunk
+          await new Promise(r => setTimeout(r, 0));
+        }
       }
     }
 
@@ -205,7 +241,7 @@
         throw new Error(`Unexpected block height: ${compactBlock.height} at ${currentHeight}`);
       }
 
-      // Set the trial decryption flag for all other compact blocks
+      // set the trial decryption flag for all other compact blocks
       const skipTrialDecrypt = shouldSkipTrialDecrypt(
         this.walletCreationBlockHeight,
         currentHeight,
@@ -228,7 +264,67 @@
     }
   }
 
-  // logic for processing a compact block
+  /**
+   * Trial decrypts a chunk of the genesis block for notes owned by the wallet.
+   */
+  private async trialDecryptGenesisChunk({
+    start,
+    compactBlock,
+    skipTrialDecrypt = false,
+  }: ProcessGenesisBlockParams) {
+    if (compactBlock.appParametersUpdated) {
+      await this.indexedDb.saveAppParams(await this.querier.app.appParams());
+    }
+    if (compactBlock.fmdParameters) {
+      await this.indexedDb.saveFmdParams(compactBlock.fmdParameters);
+    }
+    if (compactBlock.gasPrices) {
+      await this.indexedDb.saveGasPrices({
+        ...toPlainMessage(compactBlock.gasPrices),
+        assetId: toPlainMessage(this.stakingAssetId),
+      });
+    }
+    if (compactBlock.altGasPrices.length) {
+      for (const altGas of compactBlock.altGasPrices) {
+        await this.indexedDb.saveGasPrices({
+          ...toPlainMessage(altGas),
+          assetId: getAssetIdFromGasPrices(altGas),
+        });
+      }
+    }
+
+    await this.viewServer.trialDecryptGenesisChunk(BigInt(start), compactBlock, skipTrialDecrypt);
+  }
+
+  /**
+   * Processes accumulated genesis notes by constructing the state commitment tree (SCT)
+   * and saving relevant transaction data.
+   */
+  private async genesisAdvice(compactBlock: CompactBlock) {
+    const scannerWantsFlush = await this.viewServer.genesisAdvice(compactBlock);
+
+    const recordsByCommitment = new Map<StateCommitment, SpendableNoteRecord | SwapRecord>();
+    let flush: ScanBlockResult | undefined;
+    if (Object.values(scannerWantsFlush).some(Boolean)) {
+      flush = this.viewServer.flushUpdates();
+
+      // in an atomic query, this
+      // - saves 'sctUpdates'
+      // - saves new decrypted notes
+      // - saves new decrypted swaps
+      // - updates last block synced
+      await this.indexedDb.saveScanResult(flush);
+
+      for (const spendableNoteRecord of flush.newNotes) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- TODO: justify non-null assertion
+        recordsByCommitment.set(spendableNoteRecord.noteCommitment!, spendableNoteRecord);
+      }
+    }
+  }
+
+  /**
+   * Logic for processing a compact block.
+   */
   private async processBlock({
     compactBlock,
     latestKnownBlockHeight,