@aztec/pxe 0.0.1-commit.4ad48494d → 0.0.1-commit.4eabbdb

package/src/notes/note_service.ts

@@ -7,6 +7,7 @@ import { Note, NoteDao, NoteStatus } from '@aztec/stdlib/note';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import type { BlockHeader, TxHash } from '@aztec/stdlib/tx';
 
+import type { AccessScopes } from '../access_scopes.js';
 import type { NoteStore } from '../storage/note_store/note_store.js';
 
 export class NoteService {
@@ -31,7 +32,7 @@ export class NoteService {
     owner: AztecAddress | undefined,
     storageSlot: Fr,
     status: NoteStatus,
-    scopes?: AztecAddress[],
+    scopes: AccessScopes,
   ) {
     const noteDaos = await this.noteStore.getNotes(
       {
@@ -70,10 +71,10 @@ export class NoteService {
    *
    * @param contractAddress - The contract whose notes should be checked and nullified.
    */
-  public async syncNoteNullifiers(contractAddress: AztecAddress): Promise<void> {
+  public async syncNoteNullifiers(contractAddress: AztecAddress, scopes: AccessScopes): Promise<void> {
     const anchorBlockHash = await this.anchorBlockHeader.hash();
 
-    const contractNotes = await this.noteStore.getNotes({ contractAddress }, this.jobId);
+    const contractNotes = await this.noteStore.getNotes({ contractAddress, scopes }, this.jobId);
 
     if (contractNotes.length === 0) {
       return;

package/src/notes_filter.ts

@@ -0,0 +1,26 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { NoteStatus } from '@aztec/stdlib/note';
+
+import type { AccessScopes } from './access_scopes.js';
+
+/**
+ * A filter used to fetch notes.
+ * @remarks This filter is applied as an intersection of all its params.
+ */
+export type NotesFilter = {
+  /**
+   * The contract address the note belongs to.
+   * @remarks Providing a contract address is required as we need that information to trigger private state sync.
+   */
+  contractAddress: AztecAddress;
+  /** The owner of the note. */
+  owner?: AztecAddress;
+  /** The specific storage location of the note on the contract. */
+  storageSlot?: Fr;
+  /** The status of the note. Defaults to 'ACTIVE'. */
+  status?: NoteStatus;
+  /** The siloed nullifier for the note. */
+  siloedNullifier?: Fr;
+  scopes: AccessScopes;
+};

package/src/private_kernel/hints/{compute_tx_include_by_timestamp.ts → compute_tx_expiration_timestamp.ts}

@@ -1,4 +1,4 @@
-import { MAX_INCLUDE_BY_TIMESTAMP_DURATION } from '@aztec/constants';
+import { MAX_TX_LIFETIME } from '@aztec/constants';
 import type { PrivateKernelCircuitPublicInputs } from '@aztec/stdlib/kernel';
 import type { UInt64 } from '@aztec/stdlib/types';
 
@@ -8,12 +8,12 @@ const ROUNDED_DURATIONS = [
   1, // 1 second
 ];
 
-function roundTimestamp(blockTimestamp: bigint, includeByTimestamp: bigint): UInt64 {
+function roundTimestamp(blockTimestamp: bigint, expirationTimestamp: bigint): UInt64 {
   return ROUNDED_DURATIONS.reduce((timestamp, duration) => {
     if (timestamp <= blockTimestamp) {
       // The timestamp must be greater than the block timestamp.
       // If it is too small, round it down again using a smaller duration.
-      const totalDuration = includeByTimestamp - blockTimestamp;
+      const totalDuration = expirationTimestamp - blockTimestamp;
       const roundedDuration = totalDuration - (totalDuration % BigInt(duration));
       return blockTimestamp + roundedDuration;
     }
@@ -21,36 +21,36 @@ function roundTimestamp(blockTimestamp: bigint, includeByTimestamp: bigint): UIn
   }, 0n);
 }
 
-export function computeTxIncludeByTimestamp(
+export function computeTxExpirationTimestamp(
   previousKernel: PrivateKernelCircuitPublicInputs,
-  maxDuration = MAX_INCLUDE_BY_TIMESTAMP_DURATION,
+  txLifetime = MAX_TX_LIFETIME,
 ): UInt64 {
-  if (maxDuration > MAX_INCLUDE_BY_TIMESTAMP_DURATION) {
+  if (txLifetime > MAX_TX_LIFETIME) {
     throw new Error(
-      `Custom max duration cannot be greater than the max allowed. Max allowed: ${MAX_INCLUDE_BY_TIMESTAMP_DURATION}. Custom value: ${maxDuration}.`,
+      `Custom tx lifetime cannot be greater than the max allowed. Max allowed: ${MAX_TX_LIFETIME}. Custom value: ${txLifetime}.`,
     );
   }
 
   const anchorBlockTimestamp = previousKernel.constants.anchorBlockHeader.globalVariables.timestamp;
-  const maxTimestamp = anchorBlockTimestamp + BigInt(maxDuration);
-  const includeByTimestamp = previousKernel.includeByTimestamp;
+  const maxTimestamp = anchorBlockTimestamp + BigInt(txLifetime);
+  const expirationTimestamp = previousKernel.expirationTimestamp;
 
-  // If the includeByTimestamp set during the tx execution is greater than or equal to the max allowed duration,
+  // If the expirationTimestamp set during the tx execution is greater than or equal to the max allowed duration,
   // use the maximum allowed timestamp.
   // Note: It shouldn't be larger than the max allowed duration, but we check for it anyway.
-  if (includeByTimestamp >= maxTimestamp) {
+  if (expirationTimestamp >= maxTimestamp) {
     return maxTimestamp;
   }
 
   // Round it down to the nearest hour/min/second to reduce precision and avoid revealing the exact value.
   // This makes it harder for others to infer what function calls may have been used to produce a specific timestamp.
-  const roundedTimestamp = roundTimestamp(anchorBlockTimestamp, includeByTimestamp);
+  const roundedTimestamp = roundTimestamp(anchorBlockTimestamp, expirationTimestamp);
 
   // The tx can't be published if the timestamp is the same or less than the anchor block's timestamp.
   // Future blocks will have a greater timestamp, so the tx would never be included.
   if (roundedTimestamp <= anchorBlockTimestamp) {
     throw new Error(
-      `Include-by timestamp must be greater than the anchor block timestamp. Anchor block timestamp: ${anchorBlockTimestamp}. Include-by timestamp: ${includeByTimestamp}.`,
+      `Include-by timestamp must be greater than the anchor block timestamp. Anchor block timestamp: ${anchorBlockTimestamp}. Include-by timestamp: ${expirationTimestamp}.`,
     );
   }
 

package/src/private_kernel/hints/index.ts

@@ -1,2 +1,2 @@
 export * from './private_kernel_reset_private_inputs_builder.js';
-export * from './compute_tx_include_by_timestamp.js';
+export * from './compute_tx_expiration_timestamp.js';

package/src/private_kernel/hints/private_kernel_reset_private_inputs_builder.ts

@@ -26,7 +26,7 @@ import {
   type PrivateKernelSimulateOutput,
   ReadRequestActionEnum,
   ReadRequestResetActions,
-  type ScopedKeyValidationRequestAndGenerator,
+  type ScopedKeyValidationRequestAndSeparator,
   ScopedNoteHash,
   ScopedNullifier,
   ScopedReadRequest,
@@ -68,9 +68,9 @@ function getNullifierMembershipWitnessResolver(oracle: PrivateKernelOracle) {
   };
 }
 
-async function getMasterSecretKeysAndAppKeyGenerators(
+async function getMasterSecretKeysAndKeyTypeDomainSeparators(
   keyValidationRequests: ClaimedLengthArray<
-    ScopedKeyValidationRequestAndGenerator,
+    ScopedKeyValidationRequestAndSeparator,
     typeof MAX_KEY_VALIDATION_REQUESTS_PER_TX
   >,
   numRequestsToVerify: number,
@@ -189,8 +189,8 @@ export class PrivateKernelResetPrivateInputsBuilder {
           this.previousKernel.validationRequests.nullifierReadRequests,
           this.nullifierResetActions,
         ),
-        getMasterSecretKeysAndAppKeyGenerators(
-          this.previousKernel.validationRequests.scopedKeyValidationRequestsAndGenerators,
+        getMasterSecretKeysAndKeyTypeDomainSeparators(
+          this.previousKernel.validationRequests.scopedKeyValidationRequestsAndSeparators,
           dimensions.KEY_VALIDATION,
           oracle,
         ),
@@ -357,8 +357,8 @@ export class PrivateKernelResetPrivateInputsBuilder {
   }
 
   private needsResetNullifierKeys() {
-    const numCurr = this.previousKernel.validationRequests.scopedKeyValidationRequestsAndGenerators.claimedLength;
-    const numNext = this.nextIteration ? this.nextIteration.keyValidationRequestsAndGenerators.claimedLength : 0;
+    const numCurr = this.previousKernel.validationRequests.scopedKeyValidationRequestsAndSeparators.claimedLength;
+    const numNext = this.nextIteration ? this.nextIteration.keyValidationRequestsAndSeparators.claimedLength : 0;
     const maxAmountToKeep = !this.nextIteration ? 0 : MAX_KEY_VALIDATION_REQUESTS_PER_TX;
     if (numCurr + numNext <= maxAmountToKeep) {
       return false;

package/src/private_kernel/private_kernel_execution_prover.ts

@@ -260,20 +260,20 @@ export class PrivateKernelExecutionProver {
     // TODO: Enable padding once we better understand the final amounts to pad to.
     const paddedSideEffectAmounts = PaddedSideEffectAmounts.empty();
 
-    // Use the aggregated includeByTimestamp set throughout the tx execution.
-    // TODO: Call `computeTxIncludeByTimestamp` to round the value down and reduce precision, improving privacy.
-    const includeByTimestampUpperBound = previousKernelData.publicInputs.includeByTimestamp;
+    // Use the aggregated expirationTimestamp set throughout the tx execution.
+    // TODO: Call `computeTxExpirationTimestamp` to round the value down and reduce precision, improving privacy.
+    const expirationTimestampUpperBound = previousKernelData.publicInputs.expirationTimestamp;
     const anchorBlockTimestamp = previousKernelData.publicInputs.constants.anchorBlockHeader.globalVariables.timestamp;
-    if (includeByTimestampUpperBound <= anchorBlockTimestamp) {
+    if (expirationTimestampUpperBound <= anchorBlockTimestamp) {
       throw new Error(
-        `Include-by timestamp must be greater than the anchor block timestamp. Anchor block timestamp: ${anchorBlockTimestamp}. Include-by timestamp: ${includeByTimestampUpperBound}.`,
+        `Include-by timestamp must be greater than the anchor block timestamp. Anchor block timestamp: ${anchorBlockTimestamp}. Include-by timestamp: ${expirationTimestampUpperBound}.`,
       );
     }
 
     const privateInputs = new PrivateKernelTailCircuitPrivateInputs(
       previousKernelData,
       paddedSideEffectAmounts,
-      includeByTimestampUpperBound,
+      expirationTimestampUpperBound,
     );
 
     const witgenTimer = new Timer();

package/src/pxe.ts

@@ -47,11 +47,12 @@ import {
   TxProfileResult,
   TxProvingResult,
   TxSimulationResult,
-  UtilitySimulationResult,
+  UtilityExecutionResult,
 } from '@aztec/stdlib/tx';
 
 import { inspect } from 'util';
 
+import type { AccessScopes } from './access_scopes.js';
 import { BlockSynchronizer } from './block_synchronizer/index.js';
 import type { PXEConfig } from './config/index.js';
 import { BenchmarkedNodeFactory } from './contract_function_simulator/benchmarked_node.js';
@@ -93,7 +94,7 @@ export type ProfileTxOpts = {
   /** If true, proof generation is skipped during profiling. Defaults to true. */
   skipProofGeneration?: boolean;
   /** Addresses whose private state and keys are accessible during private execution. */
-  scopes?: AztecAddress[];
+  scopes: AccessScopes;
 };
 
 /** Options for PXE.simulateTx. */
@@ -106,16 +107,16 @@ export type SimulateTxOpts = {
   skipFeeEnforcement?: boolean;
   /** State overrides for the simulation, such as contract instances and artifacts. */
   overrides?: SimulationOverrides;
-  /** Addresses whose private state and keys are accessible during private execution. Defaults to all. */
-  scopes?: AztecAddress[];
+  /** Addresses whose private state and keys are accessible during private execution */
+  scopes: AccessScopes;
 };
 
-/** Options for PXE.simulateUtility. */
-export type SimulateUtilityOpts = {
+/** Options for PXE.executeUtility. */
+export type ExecuteUtilityOpts = {
   /** The authentication witnesses required for the function call. */
   authwits?: AuthWitness[];
-  /** The accounts whose notes we can access in this call. Defaults to all. */
-  scopes?: AztecAddress[];
+  /** The accounts whose notes we can access in this call */
+  scopes: AccessScopes;
 };
 
 /** Args for PXE.create. */
@@ -263,7 +264,7 @@ export class PXE {
     debugUtils.setPXEHelpers(
       pxe.#putInJobQueue.bind(pxe),
       pxe.#getSimulatorForTx.bind(pxe),
-      pxe.#simulateUtility.bind(pxe),
+      pxe.#executeUtility.bind(pxe),
     );
 
     pxe.jobQueue.start();
@@ -357,7 +358,7 @@ export class PXE {
   async #executePrivate(
     contractFunctionSimulator: ContractFunctionSimulator,
     txRequest: TxExecutionRequest,
-    scopes: AztecAddress[] | undefined,
+    scopes: AccessScopes,
     jobId: string,
   ): Promise<PrivateExecutionResult> {
     const { origin: contractAddress, functionSelector } = txRequest;
@@ -369,7 +370,7 @@ export class PXE {
         contractAddress,
         functionSelector,
         (privateSyncCall, execScopes) =>
-          this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], execScopes, jobId),
+          this.#executeUtility(contractFunctionSimulator, privateSyncCall, [], execScopes, jobId),
         anchorBlockHeader,
         jobId,
         scopes,
@@ -393,20 +394,20 @@ export class PXE {
   }
 
   /**
-   * Simulate a utility function call on the given contract.
+   * Execute a utility function call on the given contract.
    * @param contractFunctionSimulator - The simulator to use for the function call.
    * @param call - The function call to execute.
    * @param authWitnesses - Authentication witnesses required for the function call.
    * @param scopes - Optional array of account addresses whose notes can be accessed in this call. Defaults to all
    * accounts if not specified.
    * @param jobId - The job ID for staged writes.
-   * @returns The simulation result containing the outputs of the utility function.
+   * @returns The execution result containing the outputs of the utility function.
    */
-  async #simulateUtility(
+  async #executeUtility(
     contractFunctionSimulator: ContractFunctionSimulator,
     call: FunctionCall,
     authWitnesses: AuthWitness[] | undefined,
-    scopes: AztecAddress[] | undefined,
+    scopes: AccessScopes,
     jobId: string,
   ) {
     try {
@@ -1005,23 +1006,23 @@ export class PXE {
           inspect(txRequest),
           `simulatePublic=${simulatePublic}`,
           `skipTxValidation=${skipTxValidation}`,
-          `scopes=${scopes?.map(s => s.toString()).join(', ') ?? 'undefined'}`,
+          `scopes=${scopes === 'ALL_SCOPES' ? scopes : scopes.map(s => s.toString()).join(', ')}`,
         );
       }
     });
   }
 
   /**
-   * Simulates the execution of a contract utility function.
+   * Executes a contract utility function.
    * @param call - The function call containing the function details, arguments, and target contract address.
    */
-  public simulateUtility(
+  public executeUtility(
     call: FunctionCall,
-    { authwits, scopes }: SimulateUtilityOpts = {},
-  ): Promise<UtilitySimulationResult> {
-    // We disable concurrent simulations since those might execute oracles which read and write to the PXE stores (e.g.
+    { authwits, scopes }: ExecuteUtilityOpts = { scopes: 'ALL_SCOPES' },
+  ): Promise<UtilityExecutionResult> {
+    // We disable concurrent executions since those might execute oracles which read and write to the PXE stores (e.g.
     // to the capsules), and we need to prevent concurrent runs from interfering with one another (e.g. attempting to
-    // delete the same read value, or reading values that another simulation is currently modifying).
+    // delete the same read value, or reading values that another execution is currently modifying).
     return this.#putInJobQueue(async jobId => {
       try {
         const totalTimer = new Timer();
@@ -1036,13 +1037,13 @@ export class PXE {
           call.to,
           call.selector,
           (privateSyncCall, execScopes) =>
-            this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], execScopes, jobId),
+            this.#executeUtility(contractFunctionSimulator, privateSyncCall, [], execScopes, jobId),
           anchorBlockHeader,
           jobId,
           scopes,
         );
 
-        const executionResult = await this.#simulateUtility(
+        const executionResult = await this.#executeUtility(
           contractFunctionSimulator,
           call,
           authwits ?? [],
@@ -1069,8 +1070,8 @@ export class PXE {
         const stringifiedArgs = args.map(arg => arg.toString()).join(', ');
         throw this.#contextualizeError(
           err,
-          `simulateUtility ${to}:${name}(${stringifiedArgs})`,
-          `scopes=${scopes?.map(s => s.toString()).join(', ') ?? 'undefined'}`,
+          `executeUtility ${to}:${name}(${stringifiedArgs})`,
+          `scopes=${scopes === 'ALL_SCOPES' ? scopes : scopes.map(s => s.toString()).join(', ')}`,
         );
       }
     });
@@ -1107,7 +1108,7 @@ export class PXE {
         filter.contractAddress,
         null,
         async (privateSyncCall, execScopes) =>
-          await this.#simulateUtility(contractFunctionSimulator, privateSyncCall, [], execScopes, jobId),
+          await this.#executeUtility(contractFunctionSimulator, privateSyncCall, [], execScopes, jobId),
         anchorBlockHeader,
         jobId,
         filter.scopes,

package/src/storage/note_store/note_store.ts

@@ -3,9 +3,10 @@ import type { Fr } from '@aztec/foundation/schemas';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { DataInBlock } from '@aztec/stdlib/block';
-import { NoteDao, NoteStatus, type NotesFilter } from '@aztec/stdlib/note';
+import { NoteDao, NoteStatus } from '@aztec/stdlib/note';
 
 import type { StagedStore } from '../../job_coordinator/job_coordinator.js';
+import type { NotesFilter } from '../../notes_filter.js';
 import { StoredNote } from './stored_note.js';
 
 /**
@@ -105,7 +106,7 @@ export class NoteStore implements StagedStore {
    * returned once if this is the case)
    */
   getNotes(filter: NotesFilter, jobId: string): Promise<NoteDao[]> {
-    if (filter.scopes !== undefined && filter.scopes.length === 0) {
+    if (filter.scopes !== 'ALL_SCOPES' && filter.scopes.length === 0) {
       return Promise.resolve([]);
     }
 
@@ -179,7 +180,10 @@ export class NoteStore implements StagedStore {
           continue;
         }
 
-        if (filter.scopes && note.scopes.intersection(new Set(filter.scopes.map(s => s.toString()))).size === 0) {
+        if (
+          filter.scopes !== 'ALL_SCOPES' &&
+          note.scopes.intersection(new Set(filter.scopes.map(s => s.toString()))).size === 0
+        ) {
           continue;
         }
 

package/src/tagging/get_all_logs_by_tags.ts

@@ -1,6 +1,6 @@
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { BlockHash } from '@aztec/stdlib/block';
-import { MAX_LOGS_PER_TAG } from '@aztec/stdlib/interfaces/api-limit';
+import { MAX_LOGS_PER_TAG, MAX_RPC_LEN } from '@aztec/stdlib/interfaces/api-limit';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { SiloedTag, Tag, TxScopedL2Log } from '@aztec/stdlib/logs';
 
@@ -31,6 +31,26 @@ async function getAllPages<T>(numTags: number, fetchPage: (page: number) => Prom
   return allResultsPerTag;
 }
 
+/**
+ * Splits tags into chunks of MAX_RPC_LEN, fetches logs for each chunk using getAllPages, then stitches the results
+ * back into a single array preserving the original tag order.
+ */
+async function getAllPagesInBatches<Tag, T>(
+  tags: Tag[],
+  fetchAllPagesForBatch: (batch: Tag[]) => Promise<T[][]>,
+): Promise<T[][]> {
+  if (tags.length <= MAX_RPC_LEN) {
+    return fetchAllPagesForBatch(tags);
+  }
+
+  const batches: Tag[][] = [];
+  for (let i = 0; i < tags.length; i += MAX_RPC_LEN) {
+    batches.push(tags.slice(i, i + MAX_RPC_LEN));
+  }
+  const batchResults = await Promise.all(batches.map(fetchAllPagesForBatch));
+  return batchResults.flat();
+}
+
 /**
  * Fetches all private logs for the given tags, automatically paginating through all pages.
  * @param aztecNode - The Aztec node to query.
@@ -44,7 +64,9 @@ export function getAllPrivateLogsByTags(
   tags: SiloedTag[],
   anchorBlockHash: BlockHash,
 ): Promise<TxScopedL2Log[][]> {
-  return getAllPages(tags.length, page => aztecNode.getPrivateLogsByTags(tags, page, anchorBlockHash));
+  return getAllPagesInBatches(tags, batch =>
+    getAllPages(batch.length, page => aztecNode.getPrivateLogsByTags(batch, page, anchorBlockHash)),
+  );
 }
 
 /**
@@ -62,7 +84,9 @@ export function getAllPublicLogsByTagsFromContract(
   tags: Tag[],
   anchorBlockHash: BlockHash,
 ): Promise<TxScopedL2Log[][]> {
-  return getAllPages(tags.length, page =>
-    aztecNode.getPublicLogsByTagsFromContract(contractAddress, tags, page, anchorBlockHash),
+  return getAllPagesInBatches(tags, batch =>
+    getAllPages(batch.length, page =>
+      aztecNode.getPublicLogsByTagsFromContract(contractAddress, batch, page, anchorBlockHash),
+    ),
   );
 }

package/src/tagging/recipient_sync/load_private_logs_for_sender_recipient_pair.ts

@@ -30,7 +30,7 @@ export async function loadPrivateLogsForSenderRecipientPair(
   // (highestAgedIndex, highestFinalizedIndex + WINDOW_LEN]
   //
   // highestAgedIndex is the highest index that was used in a tx that is included in a block at least
-  //                  `MAX_INCLUDE_BY_TIMESTAMP_DURATION` seconds ago.
+  //                  `MAX_TX_LIFETIME` seconds ago.
   // highestFinalizedIndex is the highest index that was used in a tx that is included in a finalized block.
   //
   // "(" denotes an open end of the range - the index is not included in the range.
@@ -42,19 +42,19 @@ export async function loadPrivateLogsForSenderRecipientPair(
   // ever appear.
   //
   // This relies on the "maximum inclusion timestamp" rule enforced by the kernel and rollup circuits:
-  // - a transaction's maximum inclusion timestamp is at most `MAX_INCLUDE_BY_TIMESTAMP_DURATION` seconds after
+  // - a transaction's maximum inclusion timestamp is at most `MAX_TX_LIFETIME` seconds after
   //   the timestamp of its anchor block; and
   // - a rollup only includes transactions whose inclusion timestamp is >= the L2 block's timestamp.
   //
   // Suppose some device used index `I` in a transaction anchored to block `B_N` at time `N`, and that block is now at
-  // least `MAX_INCLUDE_BY_TIMESTAMP_DURATION` seconds in the past. Then there is no possibility of any *other* device
+  // least `MAX_TX_LIFETIME` seconds in the past. Then there is no possibility of any *other* device
   // trying to use an index <= `I` while anchoring to a *newer* block than `B_N` because if we were anchoring to
   // a newer block than `B_N` then we would already have seen the log with index `I` and hence the device would have
   // chosen a larger index.
   //    If that *other* device would anchor to a block older than `B_N` then that tx could never be included in a block
   // because it would already have been expired.
   //
-  // Therefore, once we see that index `I` has been used in a block that is at least `MAX_INCLUDE_BY_TIMESTAMP_DURATION`
+  // Therefore, once we see that index `I` has been used in a block that is at least `MAX_TX_LIFETIME`
   // seconds old, we can safely stop syncing logs for all indexes <= `I` and set highestAgedIndex = `I`.
   //
   // ## Explanation of the upper bound `highestFinalizedIndex + WINDOW_LEN`

package/src/tagging/recipient_sync/utils/find_highest_indexes.ts

@@ -1,4 +1,4 @@
-import { MAX_INCLUDE_BY_TIMESTAMP_DURATION } from '@aztec/constants';
+import { MAX_TX_LIFETIME } from '@aztec/constants';
 import type { TxScopedL2Log } from '@aztec/stdlib/logs';
 
 /**
@@ -16,7 +16,7 @@ export function findHighestIndexes(
     const ageInSeconds = currentTimestamp - log.blockTimestamp;
 
     if (
-      ageInSeconds >= BigInt(MAX_INCLUDE_BY_TIMESTAMP_DURATION) &&
+      ageInSeconds >= BigInt(MAX_TX_LIFETIME) &&
       (highestAgedIndex === undefined || taggingIndex > highestAgedIndex)
     ) {
       highestAgedIndex = taggingIndex;

package/dest/private_kernel/hints/compute_tx_include_by_timestamp.d.ts

@@ -1,4 +0,0 @@
-import type { PrivateKernelCircuitPublicInputs } from '@aztec/stdlib/kernel';
-import type { UInt64 } from '@aztec/stdlib/types';
-export declare function computeTxIncludeByTimestamp(previousKernel: PrivateKernelCircuitPublicInputs, maxDuration?: number): UInt64;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcHV0ZV90eF9pbmNsdWRlX2J5X3RpbWVzdGFtcC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3ByaXZhdGVfa2VybmVsL2hpbnRzL2NvbXB1dGVfdHhfaW5jbHVkZV9ieV90aW1lc3RhbXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsZ0NBQWdDLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUM3RSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQXFCbEQsd0JBQWdCLDJCQUEyQixDQUN6QyxjQUFjLEVBQUUsZ0NBQWdDLEVBQ2hELFdBQVcsU0FBb0MsR0FDOUMsTUFBTSxDQStCUiJ9

package/dest/private_kernel/hints/compute_tx_include_by_timestamp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compute_tx_include_by_timestamp.d.ts","sourceRoot":"","sources":["../../../src/private_kernel/hints/compute_tx_include_by_timestamp.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAC;AAC7E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAqBlD,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,gCAAgC,EAChD,WAAW,SAAoC,GAC9C,MAAM,CA+BR"}