@aztec/pxe 0.0.1-commit.1bb068fb5 → 0.0.1-commit.1de2a32

package/src/storage/contract_store/contract_store.ts

@@ -1,6 +1,7 @@
 import type { FUNCTION_TREE_HEIGHT } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/curves/bn254';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
+import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { MembershipWitness } from '@aztec/foundation/trees';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 import {
@@ -19,7 +20,8 @@ import {
 } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
-  type ContractClass,
+  type ContractClassIdPreimage,
+  type ContractClassWithId,
   type ContractInstanceWithAddress,
   SerializableContractInstance,
   getContractClassFromArtifact,
@@ -27,6 +29,68 @@ import {
 
 import { PrivateFunctionsTree } from './private_functions_tree.js';
 
+const VERSION = 1 as const;
+
+/**
+ * All contract class data except the large packedBytecode.
+ * The expensive data from the ContractClass is precomputed and stored in this format to avoid redundant hashing.
+ * Since we have to store the artifacts anyway, the final ContractClass is reconstructed by combining this data
+ * with the packedBytecode obtained from the former. That way we can have quick class lookups without wasted storage.
+ */
+export class SerializableContractClassData {
+  public readonly version = VERSION;
+  public readonly id: Fr;
+  public readonly artifactHash: Fr;
+  public readonly privateFunctionsRoot: Fr;
+  public readonly publicBytecodeCommitment: Fr;
+  public readonly privateFunctions: { selector: FunctionSelector; vkHash: Fr }[];
+
+  constructor(
+    data: ContractClassIdPreimage & {
+      id: Fr;
+      privateFunctions: { selector: FunctionSelector; vkHash: Fr }[];
+    },
+  ) {
+    this.id = data.id;
+    this.artifactHash = data.artifactHash;
+    this.privateFunctionsRoot = data.privateFunctionsRoot;
+    this.publicBytecodeCommitment = data.publicBytecodeCommitment;
+    this.privateFunctions = data.privateFunctions;
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(
+      numToUInt8(this.version),
+      this.id,
+      this.artifactHash,
+      this.privateFunctionsRoot,
+      this.publicBytecodeCommitment,
+      this.privateFunctions.length,
+      ...this.privateFunctions.map(fn => serializeToBuffer(fn.selector, fn.vkHash)),
+    );
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): SerializableContractClassData {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const version = reader.readUInt8();
+    if (version !== VERSION) {
+      throw new Error(`Unexpected contract class data version ${version}`);
+    }
+    return new SerializableContractClassData({
+      id: reader.readObject(Fr),
+      artifactHash: reader.readObject(Fr),
+      privateFunctionsRoot: reader.readObject(Fr),
+      publicBytecodeCommitment: reader.readObject(Fr),
+      privateFunctions: reader.readVector({
+        fromBuffer: (r: BufferReader) => ({
+          selector: r.readObject(FunctionSelector),
+          vkHash: r.readObject(Fr),
+        }),
+      }),
+    });
+  }
+}
+
 /**
  * ContractStore serves as a data manager and retriever for Aztec.nr contracts.
  * It provides methods to obtain contract addresses, function ABI, bytecode, and membership witnesses
@@ -39,42 +103,68 @@ export class ContractStore {
   // TODO: Update it to be LRU cache so that it doesn't keep all the data all the time.
   #privateFunctionTrees: Map<string, PrivateFunctionsTree> = new Map();
 
-  /** Map from contract address to contract class id */
+  /**
+   * In-memory cache of deserialized ContractArtifact objects, keyed by class id string.
+   * Avoids repeated LMDB reads + JSON.parse + Zod validation on every oracle call.
+   * Artifacts are large but immutable after registration — safe to cache for the lifetime of the store.
+   */
+  // TODO: Update it to be LRU cache so that it doesn't keep all the data all the time.
+  #contractArtifactCache: Map<string, ContractArtifact> = new Map();
+
+  /** Map from contract address to contract class id (avoids KV round-trip on hot path). */
   #contractClassIdMap: Map<string, Fr> = new Map();
 
   #store: AztecAsyncKVStore;
   #contractArtifacts: AztecAsyncMap<string, Buffer>;
+  #contractClassData: AztecAsyncMap<string, Buffer>;
   #contractInstances: AztecAsyncMap<string, Buffer>;
 
   constructor(store: AztecAsyncKVStore) {
     this.#store = store;
     this.#contractArtifacts = store.openMap('contract_artifacts');
+    this.#contractClassData = store.openMap('contract_classes');
     this.#contractInstances = store.openMap('contracts_instances');
   }
 
   // Setters
 
-  public async addContractArtifact(id: Fr, contract: ContractArtifact): Promise<void> {
-    // Validation outside transactionAsync - these are not DB operations
+  /**
+   * Registers a new contract artifact and its corresponding class data.
+   * IMPORTANT: This method does not verify that the provided artifact matches the class data or that the class id matches the artifact.
+   * It is the caller's responsibility to ensure the consistency and correctness of the provided data.
+   * This is done to avoid redundant, expensive contract class computations
+   */
+  public async addContractArtifact(
+    contract: ContractArtifact,
+    contractClassWithIdAndPreimage?: ContractClassWithId & ContractClassIdPreimage,
+  ): Promise<Fr> {
+    const contractClass = contractClassWithIdAndPreimage ?? (await getContractClassFromArtifact(contract));
+    const key = contractClass.id.toString();
+
+    if (this.#contractArtifactCache.has(key)) {
+      return contractClass.id;
+    }
+
     const privateFunctions = contract.functions.filter(
       functionArtifact => functionArtifact.functionType === FunctionType.PRIVATE,
     );
-
     const privateSelectors = await Promise.all(
-      privateFunctions.map(async privateFunctionArtifact =>
-        (
-          await FunctionSelector.fromNameAndParameters(privateFunctionArtifact.name, privateFunctionArtifact.parameters)
-        ).toString(),
+      privateFunctions.map(async fn =>
+        (await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters)).toString(),
       ),
     );
-
     if (privateSelectors.length !== new Set(privateSelectors).size) {
       throw new Error('Repeated function selectors of private functions');
     }
 
-    await this.#store.transactionAsync(() =>
-      this.#contractArtifacts.set(id.toString(), contractArtifactToBuffer(contract)),
-    );
+    this.#contractArtifactCache.set(key, contract);
+
+    await this.#store.transactionAsync(async () => {
+      await this.#contractArtifacts.set(key, contractArtifactToBuffer(contract));
+      await this.#contractClassData.set(key, new SerializableContractClassData(contractClass).toBuffer());
+    });
+
+    return contractClass.id;
   }
 
   async addContractInstance(contract: ContractInstanceWithAddress): Promise<void> {
@@ -89,26 +179,17 @@ export class ContractStore {
   // Private getters
 
   async #getContractClassId(contractAddress: AztecAddress): Promise<Fr | undefined> {
-    if (!this.#contractClassIdMap.has(contractAddress.toString())) {
+    const key = contractAddress.toString();
+    if (!this.#contractClassIdMap.has(key)) {
       const instance = await this.getContractInstance(contractAddress);
       if (!instance) {
         return;
       }
-      this.#contractClassIdMap.set(contractAddress.toString(), instance.currentContractClassId);
+      this.#contractClassIdMap.set(key, instance.currentContractClassId);
     }
-    return this.#contractClassIdMap.get(contractAddress.toString());
+    return this.#contractClassIdMap.get(key);
   }
 
-  /**
-   * Retrieve or create a ContractTree instance based on the provided class id.
-   * If an existing tree with the same class id is found in the cache, it will be returned.
-   * Otherwise, a new ContractTree instance will be created using the contract data from the database
-   * and added to the cache before returning.
-   *
-   * @param classId - The class id of the contract for which the ContractTree is required.
-   * @returns A ContractTree instance associated with the specified contract address.
-   * @throws An Error if the contract is not found in the ContractDatabase.
-   */
   async #getPrivateFunctionTreeForClassId(classId: Fr): Promise<PrivateFunctionsTree | undefined> {
     if (!this.#privateFunctionTrees.has(classId.toString())) {
       const artifact = await this.getContractArtifact(classId);
@@ -121,9 +202,9 @@ export class ContractStore {
     return this.#privateFunctionTrees.get(classId.toString())!;
   }
 
-  async #getContractArtifactByAddress(contractAddress: AztecAddress): Promise<ContractArtifact | undefined> {
-    const contractClassId = await this.#getContractClassId(contractAddress);
-    return contractClassId && this.getContractArtifact(contractClassId);
+  async #getArtifactByAddress(contractAddress: AztecAddress): Promise<ContractArtifact | undefined> {
+    const classId = await this.#getContractClassId(contractAddress);
+    return classId && this.getContractArtifact(classId);
   }
 
   // Public getters
@@ -135,7 +216,7 @@ export class ContractStore {
     });
   }
 
-  /** Returns a contract instance for a given address. Throws if not found. */
+  /** Returns a contract instance for a given address. */
   public getContractInstance(contractAddress: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
     return this.#store.transactionAsync(async () => {
       const contract = await this.#contractInstances.getAsync(contractAddress.toString());
@@ -143,18 +224,39 @@ export class ContractStore {
     });
   }
 
-  public getContractArtifact(contractClassId: Fr): Promise<ContractArtifact | undefined> {
-    return this.#store.transactionAsync(async () => {
-      const contract = await this.#contractArtifacts.getAsync(contractClassId.toString());
-      // TODO(@spalladino): AztecAsyncMap lies and returns Uint8Arrays instead of Buffers, hence the extra Buffer.from.
-      return contract && contractArtifactFromBuffer(Buffer.from(contract));
+  /** Returns the raw contract artifact for a given class id. */
+  public async getContractArtifact(contractClassId: Fr): Promise<ContractArtifact | undefined> {
+    const key = contractClassId.toString();
+    const cached = this.#contractArtifactCache.get(key);
+    if (cached) {
+      return cached;
+    }
+    const artifact = await this.#store.transactionAsync(async () => {
+      const buf = await this.#contractArtifacts.getAsync(key);
+      return buf && contractArtifactFromBuffer(buf);
     });
+    if (artifact) {
+      this.#contractArtifactCache.set(key, artifact);
+    }
+    return artifact;
   }
 
-  /** Returns a contract class for a given class id. Throws if not found. */
-  public async getContractClass(contractClassId: Fr): Promise<ContractClass | undefined> {
+  /** Returns a contract class for a given class id. */
+  public async getContractClassWithPreimage(
+    contractClassId: Fr,
+  ): Promise<(ContractClassWithId & ContractClassIdPreimage) | undefined> {
+    const key = contractClassId.toString();
+    const buf = await this.#contractClassData.getAsync(key);
+    if (!buf) {
+      return undefined;
+    }
+    const classData = SerializableContractClassData.fromBuffer(buf);
     const artifact = await this.getContractArtifact(contractClassId);
-    return artifact && getContractClassFromArtifact(artifact);
+    if (!artifact) {
+      return undefined;
+    }
+    const packedBytecode = artifact.functions.find(f => f.name === 'public_dispatch')?.bytecode ?? Buffer.alloc(0);
+    return { ...classData, packedBytecode };
   }
 
   public async getContract(
@@ -173,8 +275,6 @@ export class ContractStore {
 
   /**
    * Retrieves the artifact of a specified function within a given contract.
-   * The function is identified by its selector, which is a unique code generated from the function's signature.
-   * Throws an error if the contract address or function selector are invalid or not found.
    *
    * @param contractAddress - The AztecAddress representing the contract containing the function.
    * @param selector - The function selector.
@@ -184,9 +284,12 @@ export class ContractStore {
     contractAddress: AztecAddress,
     selector: FunctionSelector,
   ): Promise<FunctionArtifactWithContractName | undefined> {
-    const artifact = await this.#getContractArtifactByAddress(contractAddress);
-    const fnArtifact = artifact && (await this.#findFunctionArtifactBySelector(artifact, selector));
-    return fnArtifact && { ...fnArtifact, contractName: artifact.name };
+    const artifact = await this.#getArtifactByAddress(contractAddress);
+    if (!artifact) {
+      return undefined;
+    }
+    const fn = await this.#findFunctionArtifactBySelector(artifact, selector);
+    return fn && { ...fn, contractName: artifact.name };
   }
 
   public async getFunctionArtifactWithDebugMetadata(
@@ -207,50 +310,48 @@ export class ContractStore {
   public async getPublicFunctionArtifact(
     contractAddress: AztecAddress,
   ): Promise<FunctionArtifactWithContractName | undefined> {
-    const artifact = await this.#getContractArtifactByAddress(contractAddress);
-    const fnArtifact = artifact && artifact.functions.find(fn => fn.functionType === FunctionType.PUBLIC);
-    return fnArtifact && { ...fnArtifact, contractName: artifact.name };
+    const artifact = await this.#getArtifactByAddress(contractAddress);
+    const fn = artifact && artifact.functions.find(f => f.functionType === FunctionType.PUBLIC);
+    return fn && { ...fn, contractName: artifact.name };
   }
 
   public async getFunctionAbi(
     contractAddress: AztecAddress,
     selector: FunctionSelector,
   ): Promise<FunctionAbi | undefined> {
-    const artifact = await this.#getContractArtifactByAddress(contractAddress);
+    const artifact = await this.#getArtifactByAddress(contractAddress);
     return artifact && (await this.#findFunctionAbiBySelector(artifact, selector));
   }
 
   /**
    * Retrieves the debug metadata of a specified function within a given contract.
-   * The function is identified by its selector, which is a unique code generated from the function's signature.
-   * Returns undefined if the debug metadata for the given function is not found.
-   * Throws if the contract has not been added to the database.
    *
    * @param contractAddress - The AztecAddress representing the contract containing the function.
    * @param selector - The function selector.
-   * @returns The corresponding function's artifact as an object.
+   * @returns The corresponding function's debug metadata, or undefined.
    */
   public async getFunctionDebugMetadata(
     contractAddress: AztecAddress,
     selector: FunctionSelector,
   ): Promise<FunctionDebugMetadata | undefined> {
-    const artifact = await this.#getContractArtifactByAddress(contractAddress);
-    const fnArtifact = artifact && (await this.#findFunctionArtifactBySelector(artifact, selector));
-    return fnArtifact && getFunctionDebugMetadata(artifact, fnArtifact);
+    const artifact = await this.#getArtifactByAddress(contractAddress);
+    if (!artifact) {
+      return undefined;
+    }
+    const fn = await this.#findFunctionArtifactBySelector(artifact, selector);
+    return fn && getFunctionDebugMetadata(artifact, fn);
   }
 
   public async getPublicFunctionDebugMetadata(
     contractAddress: AztecAddress,
   ): Promise<FunctionDebugMetadata | undefined> {
-    const artifact = await this.#getContractArtifactByAddress(contractAddress);
-    const fnArtifact = artifact && artifact.functions.find(fn => fn.functionType === FunctionType.PUBLIC);
-    return fnArtifact && getFunctionDebugMetadata(artifact, fnArtifact);
+    const artifact = await this.#getArtifactByAddress(contractAddress);
+    const fn = artifact && artifact.functions.find(f => f.functionType === FunctionType.PUBLIC);
+    return fn && getFunctionDebugMetadata(artifact, fn);
   }
 
   /**
    * Retrieve the function membership witness for the given contract class and function selector.
-   * The function membership witness represents a proof that the function belongs to the specified contract.
-   * Throws an error if the contract address or function selector is unknown.
    *
    * @param contractClassId - The id of the class.
    * @param selector - The function selector.
@@ -265,23 +366,21 @@ export class ContractStore {
   }
 
   public async getDebugContractName(contractAddress: AztecAddress) {
-    const artifact = await this.#getContractArtifactByAddress(contractAddress);
+    const artifact = await this.#getArtifactByAddress(contractAddress);
     return artifact?.name;
   }
 
   public async getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector) {
-    const artifact = await this.#getContractArtifactByAddress(contractAddress);
-    const fnArtifact = artifact && (await this.#findFunctionAbiBySelector(artifact, selector));
-    return `${artifact?.name ?? contractAddress}:${fnArtifact?.name ?? selector}`;
+    const artifact = await this.#getArtifactByAddress(contractAddress);
+    const fn = artifact && (await this.#findFunctionAbiBySelector(artifact, selector));
+    return `${artifact?.name ?? contractAddress}:${fn?.name ?? selector}`;
   }
 
   async #findFunctionArtifactBySelector(
     artifact: ContractArtifact,
     selector: FunctionSelector,
   ): Promise<FunctionArtifact | undefined> {
-    const functions = artifact.functions;
-    for (let i = 0; i < functions.length; i++) {
-      const fn = functions[i];
+    for (const fn of artifact.functions) {
       const fnSelector = await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters);
       if (fnSelector.equals(selector)) {
         return fn;
@@ -293,9 +392,7 @@ export class ContractStore {
     artifact: ContractArtifact,
     selector: FunctionSelector,
   ): Promise<FunctionAbi | undefined> {
-    const functions = [...artifact.functions, ...(artifact.nonDispatchPublicFunctions ?? [])];
-    for (let i = 0; i < functions.length; i++) {
-      const fn = functions[i];
+    for (const fn of [...artifact.functions, ...(artifact.nonDispatchPublicFunctions ?? [])]) {
       const fnSelector = await FunctionSelector.fromNameAndParameters(fn.name, fn.parameters);
       if (fnSelector.equals(selector)) {
         return fn;
@@ -316,10 +413,12 @@ export class ContractStore {
       throw new Error(`Unknown function ${functionName} in contract ${contract.name}.`);
     }
 
+    const selector = await FunctionSelector.fromNameAndParameters(functionDao.name, functionDao.parameters);
+
     return FunctionCall.from({
       name: functionDao.name,
       to,
-      selector: await FunctionSelector.fromNameAndParameters(functionDao.name, functionDao.parameters),
+      selector,
       type: functionDao.functionType,
       hideMsgSender: false,
       isStatic: functionDao.isStatic,

package/src/storage/tagging_store/recipient_tagging_store.ts

@@ -1,5 +1,5 @@
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+import type { ExtendedDirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
 
 import type { StagedStore } from '../../job_coordinator/job_coordinator.js';
 
@@ -106,11 +106,11 @@ export class RecipientTaggingStore implements StagedStore {
     return Promise.resolve();
   }
 
-  getHighestAgedIndex(secret: DirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
+  getHighestAgedIndex(secret: ExtendedDirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
     return this.#store.transactionAsync(() => this.#readHighestAgedIndex(jobId, secret.toString()));
   }
 
-  updateHighestAgedIndex(secret: DirectionalAppTaggingSecret, index: number, jobId: string): Promise<void> {
+  updateHighestAgedIndex(secret: ExtendedDirectionalAppTaggingSecret, index: number, jobId: string): Promise<void> {
     return this.#store.transactionAsync(async () => {
       const currentIndex = await this.#readHighestAgedIndex(jobId, secret.toString());
       if (currentIndex !== undefined && index <= currentIndex) {
@@ -121,11 +121,15 @@ export class RecipientTaggingStore implements StagedStore {
     });
   }
 
-  getHighestFinalizedIndex(secret: DirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
+  getHighestFinalizedIndex(secret: ExtendedDirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
     return this.#store.transactionAsync(() => this.#readHighestFinalizedIndex(jobId, secret.toString()));
   }
 
-  updateHighestFinalizedIndex(secret: DirectionalAppTaggingSecret, index: number, jobId: string): Promise<void> {
+  updateHighestFinalizedIndex(
+    secret: ExtendedDirectionalAppTaggingSecret,
+    index: number,
+    jobId: string,
+  ): Promise<void> {
     return this.#store.transactionAsync(async () => {
       const currentIndex = await this.#readHighestFinalizedIndex(jobId, secret.toString());
       if (currentIndex !== undefined && index < currentIndex) {

package/src/storage/tagging_store/sender_tagging_store.ts

@@ -1,5 +1,5 @@
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
+import type { ExtendedDirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
 import { TxHash } from '@aztec/stdlib/tx';
 
 import type { StagedStore } from '../../job_coordinator/job_coordinator.js';
@@ -154,7 +154,7 @@ export class SenderTaggingStore implements StagedStore {
 
     // The secrets in pre-tags should be unique because we always store just the highest index per given secret-txHash
     // pair. Below we check that this is the case.
-    const secretsSet = new Set(preTags.map(preTag => preTag.secret.toString()));
+    const secretsSet = new Set(preTags.map(preTag => preTag.extendedSecret.toString()));
     if (secretsSet.size !== preTags.length) {
       return Promise.reject(new Error(`Duplicate secrets found when storing pending indexes`));
     }
@@ -163,10 +163,10 @@ export class SenderTaggingStore implements StagedStore {
 
     return this.#store.transactionAsync(async () => {
       // Prefetch all data, start reads during iteration to keep IndexedDB transaction alive
-      const preTagReadPromises = preTags.map(({ secret, index }) => {
-        const secretStr = secret.toString();
+      const preTagReadPromises = preTags.map(({ extendedSecret, index }) => {
+        const secretStr = extendedSecret.toString();
         return {
-          secret,
+          extendedSecret,
           secretStr,
           index,
           pending: this.#readPendingIndexes(jobId, secretStr),
@@ -233,7 +233,7 @@ export class SenderTaggingStore implements StagedStore {
    * [startIndex, endIndex). Returns an empty array if no pending indexes exist in the range.
    */
   getTxHashesOfPendingIndexes(
-    secret: DirectionalAppTaggingSecret,
+    secret: ExtendedDirectionalAppTaggingSecret,
     startIndex: number,
     endIndex: number,
     jobId: string,
@@ -252,7 +252,7 @@ export class SenderTaggingStore implements StagedStore {
    * @param secret - The secret to get the last finalized index for.
    * @returns The last (highest) finalized index for the given secret.
    */
-  getLastFinalizedIndex(secret: DirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
+  getLastFinalizedIndex(secret: ExtendedDirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
     return this.#store.transactionAsync(() => this.#readLastFinalizedIndex(jobId, secret.toString()));
   }
 
@@ -262,7 +262,7 @@ export class SenderTaggingStore implements StagedStore {
    * @param secret - The directional app tagging secret to query the last used index for.
    * @returns The last used index.
    */
-  getLastUsedIndex(secret: DirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
+  getLastUsedIndex(secret: ExtendedDirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
     const secretStr = secret.toString();
 
     return this.#store.transactionAsync(async () => {

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/index.ts

@@ -15,5 +15,5 @@ export { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from './constants.js';
 export { getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract } from './get_all_logs_by_tags.js';
 
 // Re-export tagging-related types from stdlib
-export { DirectionalAppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
+export { ExtendedDirectionalAppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
 export { type PreTag } from '@aztec/stdlib/logs';

package/src/tagging/recipient_sync/load_private_logs_for_sender_recipient_pair.ts

@@ -1,8 +1,7 @@
 import type { BlockNumber } from '@aztec/foundation/branded-types';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { DirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
+import type { ExtendedDirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
 
 import type { RecipientTaggingStore } from '../../storage/tagging_store/recipient_tagging_store.js';
 import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
@@ -10,15 +9,14 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
 import { loadLogsForRange } from './utils/load_logs_for_range.js';
 
 /**
- * Loads private logs for `app` and  sender-recipient pair defined by `secret` and updates the highest aged and
+ * Loads private logs for the app-sender-recipient triplet defined by `secret` and updates the highest aged and
  * finalized indexes in the db. At most load logs from blocks up to and including `anchorBlockNumber`.
  *
  * @dev This function can be safely executed "in parallel" for other sender-recipient pairs because the data in
  * in the tagging data provider is indexed by the secret and hence completely disjoint.
  */
 export async function loadPrivateLogsForSenderRecipientPair(
-  secret: DirectionalAppTaggingSecret,
-  app: AztecAddress,
+  secret: ExtendedDirectionalAppTaggingSecret,
   aztecNode: AztecNode,
   taggingStore: RecipientTaggingStore,
   anchorBlockNumber: BlockNumber,
@@ -30,7 +28,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 +40,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`
@@ -96,7 +94,6 @@ export async function loadPrivateLogsForSenderRecipientPair(
     // Get private logs with their block timestamps and corresponding tagging indexes
     const privateLogsWithIndexes = await loadLogsForRange(
       secret,
-      app,
       aztecNode,
       start,
       end,

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;