Process blocks in turn

example/src/Client/utils/BlockCache.ts

@@ -56,8 +56,9 @@ export class BlockCache {
     return Number(key);
   }
 
-  public getBlockBySequence(sequence: number): Promise<LightBlock> {
-    return this.db.get(this.encodeKey(sequence));
+  public async getBlockBySequence(sequence: number): Promise<LightBlock> {
+    const blockData = await this.db.get(this.encodeKey(sequence));
+    return LightBlock.decode(blockData);
   }
 
   public async handleReorg(lastValidBlock: LightBlock) {

example/src/Client/utils/BlockProcessor.ts

@@ -126,8 +126,10 @@ export class BlockProcessor {
 
     try {
       await new Promise((res) => {
-        stream.on("data", (block: LightBlock) => {
-          this._processBlock(block);
+        stream.on("data", async (block: LightBlock) => {
+          stream.pause();
+          await this._processBlock(block);
+          stream.resume();
           blocksProcessed++;
 
           logThrottled(
@@ -156,7 +158,7 @@ export class BlockProcessor {
       return;
     }
 
-    this.blockCache.cacheBlock(block);
+    await this.blockCache.cacheBlock(block);
 
     const notes: Buffer[] = [];
 
@@ -175,13 +177,13 @@ export class BlockProcessor {
       return false;
     }
 
-    const prevBlock = await this.blockCache.getBlockBySequence(
+    const prevCachedBlock = await this.blockCache.getBlockBySequence(
       block.sequence - 1,
     );
 
     // If the incoming block's previous block hash matches the previous block's hash,
-    // there is no reorg.
-    if (block.previousBlockHash === prevBlock.hash) {
+    // there is no reorg. Note that Buffer.compare returns 0 if the two buffers are equal.
+    if (block.previousBlockHash.compare(prevCachedBlock.hash) === 0) {
       return false;
     }