wip

Author: benesjan

yarn-project/pxe/src/tagging/recipient_sync/utils/load_logs_for_range.test.ts

@@ -29,8 +29,8 @@ describe('loadLogsForRange', () => {
     return SiloedTag.compute(tag, app);
   }
 
-  function makeLog(txHash: TxHash, blockHash: L2BlockHash, blockNumber: number, tag: Fr) {
-    return new TxScopedL2Log(txHash, 0, 0, BlockNumber(blockNumber), blockHash, PrivateLog.random(tag));
+  function makeLog(txHash: TxHash, blockHash: L2BlockHash, blockNumber: number, tag: SiloedTag) {
+    return new TxScopedL2Log(txHash, 0, 0, BlockNumber(blockNumber), blockHash, PrivateLog.random(tag.value));
   }
 
   beforeAll(async () => {
@@ -64,7 +64,7 @@ describe('loadLogsForRange', () => {
 
     aztecNode.getLogsByTags.mockImplementation((tags: Fr[]) => {
       return Promise.resolve(
-        tags.map((t: Fr) => (t.equals(tag.value) ? [makeLog(txHash, blockHash, blockNumber, tag.value)] : [])),
+        tags.map((t: Fr) => (t.equals(tag.value) ? [makeLog(txHash, blockHash, blockNumber, tag)] : [])),
       );
     });
 
@@ -92,7 +92,7 @@ describe('loadLogsForRange', () => {
     const tag = await computeSiloedTagForIndex(index);
     const blockHeader = makeBlockHeader(0, { timestamp });
 
-    const privateLog = makeLog(txHash, blockHash, blockNumber, tag.value);
+    const privateLog = makeLog(txHash, blockHash, blockNumber, tag);
     const publicLog = new TxScopedL2Log(
       TxHash.random(),
       0,
@@ -140,9 +140,9 @@ describe('loadLogsForRange', () => {
       return Promise.resolve(
         tags.map((t: Fr) => {
           if (t.equals(tag1.value)) {
-            return [makeLog(txHash1, blockHash1, blockNumber1, tag1.value)];
+            return [makeLog(txHash1, blockHash1, blockNumber1, tag1)];
           } else if (t.equals(tag2.value)) {
-            return [makeLog(txHash2, blockHash2, blockNumber2, tag2.value)];
+            return [makeLog(txHash2, blockHash2, blockNumber2, tag2)];
           }
           return [];
         }),
@@ -186,9 +186,9 @@ describe('loadLogsForRange', () => {
       return Promise.resolve(
         tags.map((t: Fr) => {
           if (t.equals(tag1.value)) {
-            return [makeLog(txHash1, blockHash, blockNumber, tag1.value)];
+            return [makeLog(txHash1, blockHash, blockNumber, tag1)];
           } else if (t.equals(tag2.value)) {
-            return [makeLog(txHash2, blockHash, blockNumber, tag2.value)];
+            return [makeLog(txHash2, blockHash, blockNumber, tag2)];
           }
           return [];
         }),
@@ -230,9 +230,9 @@ describe('loadLogsForRange', () => {
       return Promise.resolve(
         tags.map((t: Fr) => {
           if (t.equals(tagAtStart.value)) {
-            return [makeLog(txHashAtStart, blockHash, 5, tagAtStart.value)];
+            return [makeLog(txHashAtStart, blockHash, 5, tagAtStart)];
           } else if (t.equals(tagAtEnd.value)) {
-            return [makeLog(txHashAtEnd, blockHash, 6, tagAtEnd.value)];
+            return [makeLog(txHashAtEnd, blockHash, 6, tagAtEnd)];
           }
           return [];
         }),
@@ -254,26 +254,49 @@ describe('loadLogsForRange', () => {
     expect(result[0].log.txHash.equals(txHashAtStart)).toBe(true);
   });
 
-  it('throws error when block header is not found', async () => {
-    const txHash = TxHash.random();
-    const blockHash = L2BlockHash.random();
-    const blockNumber = 5;
-    const index = 3;
-    const tag = await computeSiloedTagForIndex(index);
+  it('ignores logs from reorged blocks', async () => {
+    const txHashReorged = TxHash.random();
+    const txHashValid = TxHash.random();
+    const blockHashReorged = L2BlockHash.random();
+    const blockHashValid = L2BlockHash.random();
+    const blockNumberReorged = 5;
+    const blockNumberValid = 6;
+    const index1 = 3;
+    const index2 = 4;
+    const timestamp = 2000n;
+    const tag1 = await computeSiloedTagForIndex(index1);
+    const tag2 = await computeSiloedTagForIndex(index2);
+    const blockHeaderValid = makeBlockHeader(1, { timestamp });
 
     aztecNode.getLogsByTags.mockImplementation((tags: Fr[]) => {
       return Promise.resolve(
-        tags.map((t: Fr) => (t.equals(tag.value) ? [makeLog(txHash, blockHash, blockNumber, tag.value)] : [])),
+        tags.map((t: Fr) => {
+          if (t.equals(tag1.value)) {
+            return [makeLog(txHashReorged, blockHashReorged, blockNumberReorged, tag1)];
+          } else if (t.equals(tag2.value)) {
+            return [makeLog(txHashValid, blockHashValid, blockNumberValid, tag2)];
+          }
+          return [];
+        }),
       );
     });
 
-    aztecNode.getBlockHeaderByHash.mockImplementation(() => {
+    aztecNode.getBlockHeaderByHash.mockImplementation((hash: Fr) => {
+      // Block header for reorged block is not found (returns undefined)
+      if (hash.toBigInt() === blockHashReorged.toBigInt()) {
+        return Promise.resolve(undefined);
+      } else if (hash.toBigInt() === blockHashValid.toBigInt()) {
+        return Promise.resolve(blockHeaderValid);
+      }
       return Promise.resolve(undefined);
     });
 
-    await expect(loadLogsForRange(secret, app, aztecNode, 0, 10, NON_INTERFERING_ANCHOR_BLOCK_NUMBER)).rejects.toThrow(
-      'not found when syncing logs. This could be a reorg.',
-    );
+    const result = await loadLogsForRange(secret, app, aztecNode, 0, 10, NON_INTERFERING_ANCHOR_BLOCK_NUMBER);
+
+    // Should only include the log from the valid block, ignoring the log from the reorged block
+    expect(result).toHaveLength(1);
+    expect(result[0].log.txHash.equals(txHashValid)).toBe(true);
+    expect(result[0].taggingIndex).toBe(index2);
   });
 
   it('handles multiple logs at the same index', async () => {
@@ -294,10 +317,7 @@ describe('loadLogsForRange', () => {
       return Promise.resolve(
         tags.map((t: Fr) =>
           t.equals(tag.value)
-            ? [
-                makeLog(txHash1, blockHash1, blockNumber1, tag.value),
-                makeLog(txHash2, blockHash2, blockNumber2, tag.value),
-              ]
+            ? [makeLog(txHash1, blockHash1, blockNumber1, tag), makeLog(txHash2, blockHash2, blockNumber2, tag)]
             : [],
         ),
       );
@@ -340,9 +360,9 @@ describe('loadLogsForRange', () => {
         tags.map((t: Fr) =>
           t.equals(tag.value)
             ? [
-                makeLog(TxHash.random(), blockHashBefore, anchorBlockNumber - 1, tag.value),
-                makeLog(TxHash.random(), blockHashAtAnchor, anchorBlockNumber, tag.value),
-                makeLog(TxHash.random(), blockHashAfter, anchorBlockNumber + 1, tag.value),
+                makeLog(TxHash.random(), blockHashBefore, anchorBlockNumber - 1, tag),
+                makeLog(TxHash.random(), blockHashAtAnchor, anchorBlockNumber, tag),
+                makeLog(TxHash.random(), blockHashAfter, anchorBlockNumber + 1, tag),
               ]
             : [],
         ),

yarn-project/pxe/src/tagging/recipient_sync/utils/load_logs_for_range.ts

@@ -10,6 +10,8 @@ import { Tag } from '../../tag.js';
 /**
  * Gets private logs with their corresponding block timestamps and tagging indexes for the given index range, `app` and
  * `secret`. At most load logs from blocks up to and including `anchorBlockNumber`.
+ *
+ * TODO: Optimize Aztec Node API such that this function performs only a single call.
  */
 export async function loadLogsForRange(
   secret: DirectionalAppTaggingSecret,