wip

Author: benesjan

yarn-project/pxe/src/contract_function_simulator/execution_data_provider.ts

@@ -227,17 +227,7 @@ export interface ExecutionDataProvider {
     recipient: AztecAddress,
   ): Promise<DirectionalAppTaggingSecret>;
 
-  /**
-   * Updates the highest finalized tagging index and pending tagging indexes for a given secret.
-   * @param secret - The secret that's unique for (sender, recipient, contract) tuple while the direction
-   * of sender -> recipient matters.
-   * @param contractAddress - The address of the contract that the logs are tagged for. Needs to be provided to store
-   * because the function performs second round of siloing which is necessary because kernels do it as well (they silo
-   * first field of the private log which corresponds to the tag).
-   * @remarks When syncing the indexes as sender we don't care about the log contents - we only care about the
-   * highest pending and highest finalized indexes as that guides the next index choice when sending a log. The next
-   * index choice is simply the highest pending index plus one (or finalized if pending is undefined).
-   */
+  // docs available in sync_sender_tagging_indexes.ts
   syncTaggedLogsAsSender(secret: DirectionalAppTaggingSecret, contractAddress: AztecAddress): Promise<void>;
 
   /**

yarn-project/pxe/src/pxe.ts

@@ -78,7 +78,7 @@ import { PrivateEventDataProvider } from './storage/private_event_data_provider/
 import { SyncDataProvider } from './storage/sync_data_provider/sync_data_provider.js';
 import { TaggingDataProvider } from './storage/tagging_data_provider/tagging_data_provider.js';
 import { Synchronizer } from './synchronizer/index.js';
-import { WINDOW_SIZE as SENDER_TAGGING_INDEXES_SYNC_WINDOW_SIZE } from './tagging/sync_sender_tagging_indexes.js';
+import { WINDOW_LEN as SENDER_TAGGING_INDEXES_SYNC_WINDOW_LEN } from './tagging/sync_sender_tagging_indexes.js';
 
 /**
  * Private eXecution Environment (PXE) is a library used by wallets to simulate private phase of transactions and to
@@ -768,9 +768,9 @@ export class PXE {
           // the highest finalized index.
           for (const preTag of preTagsUsedInTheTx) {
             const finalizedIndex = (await this.taggingDataProvider.getHighestFinalizedIndex(preTag.secret)) ?? 0;
-            if (preTag.index > finalizedIndex + SENDER_TAGGING_INDEXES_SYNC_WINDOW_SIZE) {
+            if (preTag.index > finalizedIndex + SENDER_TAGGING_INDEXES_SYNC_WINDOW_LEN) {
               throw new Error(
-                `Highest used index ${preTag.index} is further than window length from the highest finalized index ${finalizedIndex}. Tagging window length ${SENDER_TAGGING_INDEXES_SYNC_WINDOW_SIZE} is configured too low. Contact the Aztec team to increase it!`,
+                `Highest used index ${preTag.index} is further than window length from the highest finalized index ${finalizedIndex}. Tagging window length ${SENDER_TAGGING_INDEXES_SYNC_WINDOW_LEN} is configured too low. Contact the Aztec team to increase it!`,
               );
             }
           }

yarn-project/pxe/src/tagging/sync_sender_tagging_indexes.test.ts

@@ -9,7 +9,7 @@ import { type MockProxy, mock } from 'jest-mock-extended';
 
 import { TaggingDataProvider } from '../storage/tagging_data_provider/tagging_data_provider.js';
 import { DirectionalAppTaggingSecret, SiloedTag, Tag } from './index.js';
-import { WINDOW_SIZE, syncSenderTaggingIndexes } from './sync_sender_tagging_indexes.js';
+import { WINDOW_LEN, syncSenderTaggingIndexes } from './sync_sender_tagging_indexes.js';
 
 describe('syncSenderTaggingIndexes', () => {
   // Contract address and secret to be used on the input of the syncSenderTaggingIndexes function.
@@ -127,7 +127,7 @@ describe('syncSenderTaggingIndexes', () => {
       // Move finalized block into the future
       const newFinalizedBlockNumber = finalizedBlockNumberStep1 + 5;
       const newHighestFinalizedIndex = finalizedIndexStep1 + 4;
-      const newHighestUsedIndex = newHighestFinalizedIndex + WINDOW_SIZE;
+      const newHighestUsedIndex = newHighestFinalizedIndex + WINDOW_LEN;
 
       // Create tx hashes for new logs
       const newHighestFinalizedTxHash = TxHash.random();

yarn-project/pxe/src/tagging/sync_sender_tagging_indexes.ts

@@ -8,27 +8,38 @@ import { SiloedTag } from './siloed_tag.js';
 import { Tag } from './tag.js';
 
 // This window has to be larger than the largest expected number of logs emitted in a tx for a given directional app
-// tagging secret. If we get more logs than this window size, an error is thrown in `PXE::proveTx` function.
-export const WINDOW_SIZE = 30;
-
+// tagging secret. If we get more logs than this window length, an error is thrown in `PXE::proveTx` function.
+export const WINDOW_LEN = 30;
+
+/**
+ * Syncs the highest finalized tagging index and pending tagging indexes for a given secret.
+ * @param secret - The secret that's unique for (sender, recipient, contract) tuple while the direction of
+ * sender -> recipient matters.
+ * @param app - The address of the contract that the logs are tagged for. Needs to be provided because we perform
+ * second round of siloing in this function which is necessary because kernels do it as well (they silo first field
+ * of the private log which corresponds to the tag).
+ * @remarks When syncing the indexes as sender we don't care about the log contents - we only care about the highest
+ * pending and highest finalized indexes as that guides the next index choice when sending a log. The next index choice
+ * is simply the highest pending index plus one (or finalized if pending is undefined).
+ */
 export async function syncSenderTaggingIndexes(
   secret: DirectionalAppTaggingSecret,
-  contractAddress: AztecAddress,
+  app: AztecAddress,
   aztecNode: AztecNode,
   taggingDataProvider: TaggingDataProvider,
 ): Promise<void> {
   const finalizedIndex = await taggingDataProvider.getHighestFinalizedIndex(secret);
 
   let start = finalizedIndex === undefined ? 0 : finalizedIndex + 1;
-  let end = start + WINDOW_SIZE;
+  let end = start + WINDOW_LEN;
 
   let previousFinalizedIndex = finalizedIndex;
   let newFinalizedIndex = undefined;
 
   while (true) {
     // Load and store indexes for the current window. These indexes may already exist in the database if txs using
     // them were previously sent from this PXE. Any duplicates are handled by the tagging data provider.
-    await loadAndStoreNewTaggingIndexes(secret, contractAddress, start, end, aztecNode, taggingDataProvider);
+    await loadAndStoreNewTaggingIndexes(secret, app, start, end, aztecNode, taggingDataProvider);
 
     // We get all the indexes for a given window from the store.
     const pendingTxHashes = await taggingDataProvider.getTxHashesOfPendingIndexesForRangeForSecretAsSender(
@@ -83,7 +94,7 @@ export async function syncSenderTaggingIndexes(
       //    New window:                                             [21, 22, 23]
 
       const previousEnd = end;
-      end = newFinalizedIndex! + 1 + WINDOW_SIZE;
+      end = newFinalizedIndex! + 1 + WINDOW_LEN;
       start = previousEnd;
       previousFinalizedIndex = newFinalizedIndex;
     } else {
@@ -94,7 +105,7 @@ export async function syncSenderTaggingIndexes(
 
 async function loadAndStoreNewTaggingIndexes(
   secret: DirectionalAppTaggingSecret,
-  contractAddress: AztecAddress,
+  app: AztecAddress,
   start: number,
   end: number,
   aztecNode: AztecNode,
@@ -105,7 +116,7 @@ async function loadAndStoreNewTaggingIndexes(
     .fill(0)
     .map((_, i) => ({ secret, index: start + i }));
   const siloedTagsForWindow = await Promise.all(
-    preTagsForWindow.map(async preTag => SiloedTag.compute(await Tag.compute(preTag), contractAddress)),
+    preTagsForWindow.map(async preTag => SiloedTag.compute(await Tag.compute(preTag), app)),
   );
 
   const possibleLogs = await getPrivateLogsByTags(siloedTagsForWindow, aztecNode);