@aztec/pxe 3.0.0-nightly.20251222 → 3.0.0-nightly.20251224

package/src/storage/capsule_data_provider/capsule_data_provider.ts

@@ -19,10 +19,26 @@ export class CapsuleDataProvider {
     this.logger = createLogger('pxe:capsule-data-provider');
   }
 
+  /**
+   * Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `loadCapsule`.
+   * * If data was already stored at this slot, it is overwritten.
+   * @param contractAddress - The contract address to scope the data under.
+   * @param slot - The slot in the database in which to store the value. Slots need not be contiguous.
+   * @param capsule - An array of field elements representing the capsule.
+   * @remarks A capsule is a "blob" of data that is passed to the contract through an oracle. It works similarly
+   * to public contract storage in that it's indexed by the contract address and storage slot but instead of the global
+   * network state it's backed by local PXE db.
+   */
   async storeCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[]): Promise<void> {
     await this.#capsules.set(dbSlotToKey(contractAddress, slot), Buffer.concat(capsule.map(value => value.toBuffer())));
   }
 
+  /**
+   * Returns data previously stored via `storeCapsule` in the per-contract non-volatile database.
+   * @param contractAddress - The contract address under which the data is scoped.
+   * @param slot - The slot in the database to read.
+   * @returns The stored data or `null` if no data is stored under the slot.
+   */
   async loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
     const dataBuffer = await this.#capsules.getAsync(dbSlotToKey(contractAddress, slot));
     if (!dataBuffer) {
@@ -36,10 +52,26 @@ export class CapsuleDataProvider {
     return capsule;
   }
 
+  /**
+   * Deletes data in the per-contract non-volatile database. Does nothing if no data was present.
+   * @param contractAddress - The contract address under which the data is scoped.
+   * @param slot - The slot in the database to delete.
+   */
   async deleteCapsule(contractAddress: AztecAddress, slot: Fr): Promise<void> {
     await this.#capsules.delete(dbSlotToKey(contractAddress, slot));
   }
 
+  /**
+   * Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data
+   * structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.
+   * Supports overlapping source and destination regions (which will result in the overlapped source values being
+   * overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)
+   *
+   * @param contractAddress - The contract address under which the data is scoped.
+   * @param srcSlot - The first slot to copy from.
+   * @param dstSlot - The first slot to copy to.
+   * @param numEntries - The number of entries to copy.
+   */
   copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void> {
     return this.#store.transactionAsync(async () => {
       // In order to support overlapping source and destination regions, we need to check the relative positions of source

package/src/storage/contract_data_provider/contract_data_provider.ts

@@ -178,6 +178,21 @@ export class ContractDataProvider {
     return fnArtifact && { ...fnArtifact, contractName: artifact.name };
   }
 
+  public async getFunctionArtifactWithDebugMetadata(
+    contractAddress: AztecAddress,
+    selector: FunctionSelector,
+  ): Promise<FunctionArtifactWithContractName> {
+    const artifact = await this.getFunctionArtifact(contractAddress, selector);
+    if (!artifact) {
+      throw new Error(`Function artifact not found for contract ${contractAddress} and selector ${selector}.`);
+    }
+    const debug = await this.getFunctionDebugMetadata(contractAddress, selector);
+    return {
+      ...artifact,
+      debug,
+    };
+  }
+
   public async getPublicFunctionArtifact(
     contractAddress: AztecAddress,
   ): Promise<FunctionArtifactWithContractName | undefined> {

package/src/storage/tagging_data_provider/sender_tagging_data_provider.ts

@@ -3,7 +3,7 @@ import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
 import { TxHash } from '@aztec/stdlib/tx';
 
-import { WINDOW_LEN as SENDER_TAGGING_INDEXES_SYNC_WINDOW_LEN } from '../../tagging/sync/sync_sender_tagging_indexes.js';
+import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/sync/sync_sender_tagging_indexes.js';
 
 /**
  * Data provider of tagging data used when syncing the sender tagging indexes. The recipient counterpart of this class
@@ -68,10 +68,10 @@ export class SenderTaggingDataProvider {
       // First we check that for any secret the highest used index in tx is not further than window length from
       // the highest finalized index.
       const finalizedIndex = (await this.getLastFinalizedIndex(secret)) ?? 0;
-      if (index > finalizedIndex + SENDER_TAGGING_INDEXES_SYNC_WINDOW_LEN) {
+      if (index > finalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN) {
         throw new Error(
           `Highest used index ${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
+          Tagging window length ${UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN} is configured too low. Contact the Aztec team
           to increase it!`,
         );
       }

package/src/tagging/index.ts

@@ -1,6 +1,4 @@
-export * from './tag.js';
 export * from './constants.js';
-export * from './siloed_tag.js';
 export * from './utils.js';
-export { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+export { DirectionalAppTaggingSecret, 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

@@ -0,0 +1,129 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { DirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
+
+import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../sync/sync_sender_tagging_indexes.js';
+import type { NewRecipientTaggingDataProvider } from './new_recipient_tagging_data_provider.js';
+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
+ * 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,
+  aztecNode: AztecNode,
+  taggingDataProvider: NewRecipientTaggingDataProvider,
+  anchorBlockNumber: BlockNumber,
+): Promise<TxScopedL2Log[]> {
+  // # Explanation of how the algorithm works
+  // When we perform the sync we will look at logs that correspond to the tagging index range
+  // (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.
+  // 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.
+  // "]" denotes a closed end of the range - the index is included in the range.
+  //
+  // ## Explanation of highestAgedIndex
+  //
+  // highestAgedIndex is chosen such that for all tagging indexes `i <= highestAgedIndex` we know that no new logs can
+  // 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
+  //   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
+  // 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`
+  // seconds old, we can safely stop syncing logs for all indexes <= `I` and set highestAgedIndex = `I`.
+  //
+  // ## Explanation of the upper bound `highestFinalizedIndex + WINDOW_LEN`
+  //
+  // When a sender chooses a tagging index, they will select an index that is at most `WINDOW_LEN` greater than
+  // the highest finalized index. If that index was already used, they will throw an error. For this reason we
+  // don't have to look further than `highestFinalizedIndex + WINDOW_LEN`.
+
+  let finalizedBlockNumber: number, currentTimestamp: bigint;
+  {
+    const [l2Tips, latestBlockHeader] = await Promise.all([aztecNode.getL2Tips(), aztecNode.getBlockHeader('latest')]);
+
+    if (!latestBlockHeader) {
+      throw new Error('Node failed to return latest block header when syncing logs');
+    }
+
+    [finalizedBlockNumber, currentTimestamp] = [l2Tips.finalized.number, latestBlockHeader.globalVariables.timestamp];
+  }
+
+  let start: number, end: number;
+  {
+    const currentHighestAgedIndex = await taggingDataProvider.getHighestAgedIndex(secret);
+    const currentHighestFinalizedIndex = await taggingDataProvider.getHighestFinalizedIndex(secret);
+
+    // We don't want to include the highest aged index so we start from `currentHighestAgedIndex + 1` (or 0 if not set)
+    start = currentHighestAgedIndex === undefined ? 0 : currentHighestAgedIndex + 1;
+
+    // The highest index a sender can choose is "highest finalized index + window length" but given that
+    // `loadLogsForRange` expects an exclusive `end` we add 1.
+    end = (currentHighestFinalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
+  }
+
+  const logs: TxScopedL2Log[] = [];
+
+  while (true) {
+    // Get private logs with their block timestamps and corresponding tagging indexes
+    const privateLogsWithIndexes = await loadLogsForRange(secret, app, aztecNode, start, end, anchorBlockNumber);
+
+    if (privateLogsWithIndexes.length === 0) {
+      break;
+    }
+
+    logs.push(...privateLogsWithIndexes.map(({ log }) => log));
+
+    const { highestAgedIndex, highestFinalizedIndex } = findHighestIndexes(
+      privateLogsWithIndexes,
+      currentTimestamp,
+      finalizedBlockNumber,
+    );
+
+    // Store updates in data provider and update local variables
+    if (highestAgedIndex !== undefined) {
+      await taggingDataProvider.updateHighestAgedIndex(secret, highestAgedIndex);
+    }
+
+    if (highestFinalizedIndex === undefined) {
+      // We have not found a new highest finalized index, so there is no need to move the window forward.
+      break;
+    }
+
+    if (highestAgedIndex !== undefined && highestAgedIndex > highestFinalizedIndex) {
+      // This is just a sanity check as this should never happen.
+      throw new Error('Highest aged index lower than highest finalized index invariant violated');
+    }
+
+    await taggingDataProvider.updateHighestFinalizedIndex(secret, highestFinalizedIndex);
+
+    // For the next iteration we want to look only at indexes for which we have not attempted to load logs yet while
+    // ensuring that we do not look further than WINDOW_LEN ahead of the highest finalized index.
+    start = end;
+    end = highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1; // `end` is exclusive so we add 1.
+  }
+
+  return logs;
+}

package/src/tagging/recipient_sync/new_recipient_tagging_data_provider.ts

@@ -0,0 +1,53 @@
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+
+/**
+ * Data provider of tagging data used when syncing the logs as a recipient. The sender counterpart of this class
+ * is called SenderTaggingDataProvider. We have the providers separate for the sender and recipient because
+ * the algorithms are completely disjoint and there is not data reuse between the two.
+ *
+ * @dev Chain reorgs do not need to be handled here because both the finalized and aged indexes refer to finalized
+ * blocks, which by definition cannot be affected by reorgs.
+ *
+ * TODO(benesjan): Rename as to RecipientTaggingDataProvider and relocate once the old tagging sync is purged.
+ */
+export class NewRecipientTaggingDataProvider {
+  #store: AztecAsyncKVStore;
+
+  #highestAgedIndex: AztecAsyncMap<string, number>;
+  #highestFinalizedIndex: AztecAsyncMap<string, number>;
+
+  constructor(store: AztecAsyncKVStore) {
+    this.#store = store;
+
+    this.#highestAgedIndex = this.#store.openMap('highest_aged_index');
+    this.#highestFinalizedIndex = this.#store.openMap('highest_finalized_index');
+  }
+
+  getHighestAgedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined> {
+    return this.#highestAgedIndex.getAsync(secret.toString());
+  }
+
+  async updateHighestAgedIndex(secret: DirectionalAppTaggingSecret, index: number): Promise<void> {
+    const currentIndex = await this.#highestAgedIndex.getAsync(secret.toString());
+    if (currentIndex !== undefined && index <= currentIndex) {
+      // Log sync should never set a lower highest aged index.
+      throw new Error(`New highest aged index (${index}) must be higher than the current one (${currentIndex})`);
+    }
+    await this.#highestAgedIndex.set(secret.toString(), index);
+  }
+
+  getHighestFinalizedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined> {
+    return this.#highestFinalizedIndex.getAsync(secret.toString());
+  }
+
+  async updateHighestFinalizedIndex(secret: DirectionalAppTaggingSecret, index: number): Promise<void> {
+    const currentIndex = await this.#highestFinalizedIndex.getAsync(secret.toString());
+    if (currentIndex !== undefined && index < currentIndex) {
+      // Log sync should never set a lower highest finalized index but it can happen that it would try to set the same
+      // one because we are loading logs from highest aged index + 1 and not from the highest finalized index.
+      throw new Error(`New highest finalized index (${index}) must be higher than the current one (${currentIndex})`);
+    }
+    await this.#highestFinalizedIndex.set(secret.toString(), index);
+  }
+}

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

@@ -0,0 +1,34 @@
+import { MAX_INCLUDE_BY_TIMESTAMP_DURATION } from '@aztec/constants';
+import type { TxScopedL2Log } from '@aztec/stdlib/logs';
+
+/**
+ * Finds the highest aged and the highest finalized tagging indexes.
+ */
+export function findHighestIndexes(
+  privateLogsWithIndexes: Array<{ log: TxScopedL2Log; taggingIndex: number }>,
+  currentTimestamp: bigint,
+  finalizedBlockNumber: number,
+): { highestAgedIndex: number | undefined; highestFinalizedIndex: number | undefined } {
+  let highestAgedIndex = undefined;
+  let highestFinalizedIndex = undefined;
+
+  for (const { log, taggingIndex } of privateLogsWithIndexes) {
+    const ageInSeconds = currentTimestamp - log.blockTimestamp;
+
+    if (
+      ageInSeconds >= BigInt(MAX_INCLUDE_BY_TIMESTAMP_DURATION) &&
+      (highestAgedIndex === undefined || taggingIndex > highestAgedIndex)
+    ) {
+      highestAgedIndex = taggingIndex;
+    }
+
+    if (
+      log.blockNumber <= finalizedBlockNumber &&
+      (highestFinalizedIndex === undefined || taggingIndex > highestFinalizedIndex)
+    ) {
+      highestFinalizedIndex = taggingIndex;
+    }
+  }
+
+  return { highestAgedIndex, highestFinalizedIndex };
+}

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

@@ -0,0 +1,43 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { DirectionalAppTaggingSecret, PreTag, TxScopedL2Log } from '@aztec/stdlib/logs';
+import { SiloedTag, Tag } from '@aztec/stdlib/logs';
+
+/**
+ * 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`. `start` is inclusive and `end` is
+ * exclusive.
+ */
+export async function loadLogsForRange(
+  secret: DirectionalAppTaggingSecret,
+  app: AztecAddress,
+  aztecNode: AztecNode,
+  start: number,
+  end: number,
+  anchorBlockNumber: BlockNumber,
+): Promise<Array<{ log: TxScopedL2Log; taggingIndex: number }>> {
+  // Derive tags for the window
+  const preTags: PreTag[] = Array(end - start)
+    .fill(0)
+    .map((_, i) => ({ secret, index: start + i }));
+  const siloedTags = await Promise.all(preTags.map(preTag => Tag.compute(preTag))).then(tags =>
+    Promise.all(tags.map(tag => SiloedTag.compute(tag, app))),
+  );
+
+  const logs = await aztecNode.getPrivateLogsByTags(siloedTags);
+
+  // Pair logs with their corresponding tagging indexes
+  const logsWithIndexes: Array<{ log: TxScopedL2Log; taggingIndex: number }> = [];
+  for (let i = 0; i < logs.length; i++) {
+    const logsForTag = logs[i];
+    const taggingIndex = preTags[i].index;
+    for (const log of logsForTag) {
+      if (log.blockNumber <= anchorBlockNumber) {
+        logsWithIndexes.push({ log, taggingIndex });
+      }
+    }
+  }
+
+  return logsWithIndexes;
+}

package/src/tagging/sync/sync_sender_tagging_indexes.ts

@@ -21,7 +21,7 @@ import { loadAndStoreNewTaggingIndexes } from './utils/load_and_store_new_taggin
 // - This value is below MAX_RPC_LEN (100) which is the limit for array parameters in the JSON RPC schema for
 //   `getLogsByTags`. Any test that would perform sync over JSON RPC (not by having access to the Aztec node instance
 //   directly) would error out if that maximum was hit (docs_examples.test.ts is an example of this).
-export const WINDOW_LEN = 95;
+export const UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN = 95;
 
 /**
  * Syncs tagging indexes. This function needs to be called whenever a private log is being sent.
@@ -64,7 +64,7 @@ export async function syncSenderTaggingIndexes(
   const finalizedIndex = await taggingDataProvider.getLastFinalizedIndex(secret);
 
   let start = finalizedIndex === undefined ? 0 : finalizedIndex + 1;
-  let end = start + WINDOW_LEN;
+  let end = start + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN;
 
   let previousFinalizedIndex = finalizedIndex;
   let newFinalizedIndex = undefined;
@@ -101,7 +101,7 @@ export async function syncSenderTaggingIndexes(
 
       const previousEnd = end;
       // Add 1 because `end` is exclusive and the known finalized index is not included in the window.
-      end = newFinalizedIndex! + WINDOW_LEN + 1;
+      end = newFinalizedIndex! + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
       start = previousEnd;
       previousFinalizedIndex = newFinalizedIndex;
     } else {

package/src/tagging/sync/utils/load_and_store_new_tagging_indexes.ts

@@ -1,11 +1,10 @@
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
+import { SiloedTag, Tag } from '@aztec/stdlib/logs';
 import { TxHash } from '@aztec/stdlib/tx';
 
 import type { SenderTaggingDataProvider } from '../../../storage/tagging_data_provider/sender_tagging_data_provider.js';
-import { SiloedTag } from '../../siloed_tag.js';
-import { Tag } from '../../tag.js';
 
 /**
  * Loads tagging indexes from the Aztec node and stores them in the tagging data provider.
@@ -48,9 +47,8 @@ export async function loadAndStoreNewTaggingIndexes(
 // Returns txs that used the given tags. A tag might have been used in multiple txs and for this reason we return
 // an array for each tag.
 async function getTxsContainingTags(tags: SiloedTag[], aztecNode: AztecNode): Promise<TxHash[][]> {
-  const tagsAsFr = tags.map(tag => tag.value);
-  const allLogs = await aztecNode.getLogsByTags(tagsAsFr);
-  return allLogs.map(logs => logs.filter(log => !log.isFromPublic).map(log => log.txHash));
+  const allLogs = await aztecNode.getPrivateLogsByTags(tags);
+  return allLogs.map(logs => logs.map(log => log.txHash));
 }
 
 // Returns a map of txHash to the highest index for that txHash.

package/src/tree_membership/tree_membership_service.ts

@@ -0,0 +1,112 @@
+import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { SiblingPath } from '@aztec/foundation/trees';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockParameter } from '@aztec/stdlib/block';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
+import { MerkleTreeId, NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
+
+import type { AnchorBlockDataProvider } from '../storage/anchor_block_data_provider/anchor_block_data_provider.js';
+
+export class TreeMembershipService {
+  constructor(
+    private readonly aztecNode: AztecNode,
+    private readonly anchorBlockDataProvider: AnchorBlockDataProvider,
+  ) {}
+
+  /**
+   * Gets the index of a nullifier in the nullifier tree.
+   * @returns - The index of the nullifier. Undefined if it does not exist in the tree.
+   */
+  public getNullifierIndex(nullifier: Fr) {
+    return this.#findLeafIndex('latest', MerkleTreeId.NULLIFIER_TREE, nullifier);
+  }
+
+  /**
+   * Fetches the index and sibling path of a leaf at a given block from a given tree.
+   * @param blockNumber - The block number at which to get the membership witness.
+   * @param treeId - Id of the tree to get the sibling path from.
+   * @param leafValue - The leaf value
+   * @returns The index and sibling path concatenated [index, sibling_path]
+   */
+  public async getMembershipWitness(blockNumber: BlockParameter, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]> {
+    const witness = await this.#tryGetMembershipWitness(blockNumber, treeId, leafValue);
+    if (!witness) {
+      throw new Error(`Leaf value ${leafValue} not found in tree ${MerkleTreeId[treeId]} at block ${blockNumber}`);
+    }
+    return witness;
+  }
+
+  /**
+   * Returns a low nullifier membership witness for a given nullifier at a given block.
+   * @param blockNumber - The block number at which to get the index.
+   * @param nullifier - Nullifier we try to find the low nullifier witness for.
+   * @returns The low nullifier membership witness (if found).
+   * @remarks Low nullifier witness can be used to perform a nullifier non-inclusion proof by leveraging the "linked
+   * list structure" of leaves and proving that a lower nullifier is pointing to a bigger next value than the nullifier
+   * we are trying to prove non-inclusion for.
+   */
+  public async getLowNullifierMembershipWitness(
+    blockNumber: BlockParameter,
+    nullifier: Fr,
+  ): Promise<NullifierMembershipWitness | undefined> {
+    const anchorBlockNumber = (await this.anchorBlockDataProvider.getBlockHeader()).getBlockNumber();
+    if (blockNumber !== 'latest' && blockNumber > anchorBlockNumber) {
+      throw new Error(`Block number ${blockNumber} is higher than current block ${anchorBlockNumber}`);
+    }
+    return this.aztecNode.getLowNullifierMembershipWitness(blockNumber, nullifier);
+  }
+
+  /**
+   * Returns a witness for a given slot of the public data tree at a given block.
+   * @param blockNumber - The block number at which to get the witness.
+   * @param leafSlot - The slot of the public data in the public data tree.
+   */
+  public async getPublicDataWitness(blockNumber: BlockParameter, leafSlot: Fr): Promise<PublicDataWitness | undefined> {
+    const anchorBlockNumber = (await this.anchorBlockDataProvider.getBlockHeader()).getBlockNumber();
+    if (blockNumber !== 'latest' && blockNumber > anchorBlockNumber) {
+      throw new Error(`Block number ${blockNumber} is higher than current block ${anchorBlockNumber}`);
+    }
+    return await this.aztecNode.getPublicDataWitness(blockNumber, leafSlot);
+  }
+
+  /**
+   * Looks for the L1 to L2 membership witness of a message at the Aztec node, given its hash.
+   * @param contractAddress - Address of a contract by which the message was emitted.
+   * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages.
+   * The message nullifier is computed locally, so the secret is not sent to the node.
+   * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
+   */
+  public getL1ToL2MembershipWitness(
+    contractAddress: AztecAddress,
+    messageHash: Fr,
+    secret: Fr,
+  ): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>]> {
+    return getNonNullifiedL1ToL2MessageWitness(this.aztecNode, contractAddress, messageHash, secret);
+  }
+
+  async #tryGetMembershipWitness(
+    blockNumber: BlockParameter,
+    treeId: MerkleTreeId,
+    value: Fr,
+  ): Promise<Fr[] | undefined> {
+    switch (treeId) {
+      case MerkleTreeId.NULLIFIER_TREE:
+        return (await this.aztecNode.getNullifierMembershipWitness(blockNumber, value))?.withoutPreimage().toFields();
+      case MerkleTreeId.NOTE_HASH_TREE:
+        return (await this.aztecNode.getNoteHashMembershipWitness(blockNumber, value))?.toFields();
+      case MerkleTreeId.PUBLIC_DATA_TREE:
+        return (await this.aztecNode.getPublicDataWitness(blockNumber, value))?.withoutPreimage().toFields();
+      case MerkleTreeId.ARCHIVE:
+        return (await this.aztecNode.getArchiveMembershipWitness(blockNumber, value))?.toFields();
+      default:
+        throw new Error('Not implemented');
+    }
+  }
+
+  async #findLeafIndex(blockNumber: BlockParameter, treeId: MerkleTreeId, leafValue: Fr): Promise<bigint | undefined> {
+    const [leafIndex] = await this.aztecNode.findLeavesIndexes(blockNumber, treeId, [leafValue]);
+    return leafIndex?.data;
+  }
+}