@aztec/stdlib 0.0.1-commit.a89ec08 → 0.0.1-commit.aa0c64f

package/src/logs/pending_tagged_log.ts

@@ -1,39 +1,12 @@
-import { PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/curves/bn254';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
-import type { TxHash } from '../tx/tx_hash.js';
-import { MessageContext } from './message_context.js';
+import type { MessageContext } from './message_context.js';
 
 /**
  * Represents a pending tagged log as it is stored in the pending tagged log array to which the fetchTaggedLogs oracle
  * inserts found private logs. A TS version of `pending_tagged_log.nr`.
  */
-export class PendingTaggedLog {
-  private context: MessageContext;
-
-  constructor(
-    public log: Fr[],
-    txHash: TxHash,
-    uniqueNoteHashesInTx: Fr[],
-    firstNullifierInTx: Fr,
-  ) {
-    this.context = new MessageContext(txHash, uniqueNoteHashesInTx, firstNullifierInTx);
-  }
-
-  toFields(): Fr[] {
-    return [...serializeBoundedVec(this.log, PRIVATE_LOG_SIZE_IN_FIELDS), ...this.context.toFields()];
-  }
-}
-
-/**
- * Helper function to serialize a bounded vector according to Noir's BoundedVec format
- * @param values - The values to serialize
- * @param maxLength - The maximum length of the bounded vector
- * @returns The serialized bounded vector as Fr[]
- */
-function serializeBoundedVec(values: Fr[], maxLength: number): Fr[] {
-  const lengthDiff = maxLength - values.length;
-  const zeroPaddingArray = Array(lengthDiff).fill(Fr.ZERO);
-  const storage = values.concat(zeroPaddingArray);
-  return [...storage, new Fr(values.length)];
-}
+export type PendingTaggedLog = {
+  log: Fr[];
+  context: MessageContext;
+};

package/src/logs/pre_tag.ts

@@ -2,10 +2,7 @@ import { schemas } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
-import {
-  type ExtendedDirectionalAppTaggingSecret,
-  ExtendedDirectionalAppTaggingSecretSchema,
-} from './extended_directional_app_tagging_secret.js';
+import { type AppTaggingSecret, AppTaggingSecretSchema } from './app_tagging_secret.js';
 
 /**
  * Represents a preimage of a private log tag (see `Tag` in `pxe/src/tagging`).
@@ -15,11 +12,11 @@ import {
  * around this.
  */
 export type PreTag = {
-  extendedSecret: ExtendedDirectionalAppTaggingSecret;
+  extendedSecret: AppTaggingSecret;
   index: number;
 };
 
 export const PreTagSchema = z.object({
-  extendedSecret: ExtendedDirectionalAppTaggingSecretSchema,
+  extendedSecret: AppTaggingSecretSchema,
   index: schemas.Integer,
 });

package/src/logs/private_log.ts

@@ -5,10 +5,11 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import {
   BufferReader,
+  BufferSink,
   FieldReader,
   type Tuple,
-  serializeToBuffer,
   serializeToFields,
+  serializeToSink,
 } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
@@ -67,13 +68,18 @@ export class PrivateLog {
     return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.zero), 0);
   }
 
-  toBuffer(): Buffer {
-    return serializeToBuffer(this.fields, this.emittedLength);
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, this.fields, this.emittedLength);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new PrivateLog(reader.readTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr), reader.readNumber());
+    return new PrivateLog(reader.readArray(PRIVATE_LOG_SIZE_IN_FIELDS, Fr), reader.readNumber());
   }
 
   static random(tag = Fr.random()) {

package/src/logs/public_log.ts

@@ -1,8 +1,4 @@
-import {
-  FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH,
-  MAX_PUBLIC_LOG_SIZE_IN_FIELDS,
-  PUBLIC_LOG_HEADER_LENGTH,
-} from '@aztec/constants';
+import { FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH, PUBLIC_LOG_HEADER_LENGTH } from '@aztec/constants';
 import type { FieldsOf } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
@@ -80,9 +76,6 @@ export class FlatPublicLogs {
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     const length = reader.readNumber();
-    if (length > FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH) {
-      throw new Error(`FlatPublicLogs length ${length} exceeds maximum ${FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH}`);
-    }
     return this.fromUnpaddedPayload(reader.readArray(length, Fr));
   }
 
@@ -178,9 +171,6 @@ export class PublicLog {
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     const fieldsLength = reader.readNumber();
-    if (fieldsLength > MAX_PUBLIC_LOG_SIZE_IN_FIELDS) {
-      throw new Error(`PublicLog fields length ${fieldsLength} exceeds maximum ${MAX_PUBLIC_LOG_SIZE_IN_FIELDS}`);
-    }
     return new PublicLog(reader.readObject(AztecAddress), reader.readArray(fieldsLength, Fr));
   }
 

package/src/logs/query_all_logs_by_tags.ts

@@ -0,0 +1,98 @@
+import { MAX_LOGS_PER_TAG } from '../interfaces/api_limit.js';
+import { LogCursor } from './log_cursor.js';
+import type { LogResult } from './log_result.js';
+import type { PrivateLogsQuery, PublicLogsQuery, TagQuery } from './logs_query.js';
+import type { SiloedTag } from './siloed_tag.js';
+import type { Tag } from './tag.js';
+
+/** Minimal node surface needed by {@link queryAllPrivateLogsByTags}. */
+export type PrivateLogsByTagsFetcher = {
+  getPrivateLogsByTags(query: PrivateLogsQuery): Promise<LogResult[][]>;
+};
+
+/** Minimal node surface needed by {@link queryAllPublicLogsByTags}. */
+export type PublicLogsByTagsFetcher = {
+  getPublicLogsByTags(query: PublicLogsQuery): Promise<LogResult[][]>;
+};
+
+/**
+ * Drives the per-tag `afterLog` cursor loop for {@link PrivateLogsByTagsFetcher.getPrivateLogsByTags}.
+ *
+ * Each round re-queries only the tags whose previous page was full (`length === effective limit`), passing
+ * the cursor of the last seen log. Tags drop out as soon as they return a short page. Results are stitched
+ * back into one inner array per input tag, preserving the original input order.
+ *
+ * Honors {@link PrivateLogsQuery.limitPerTag} when set (caller is responsible for keeping it `<=`
+ * {@link MAX_LOGS_PER_TAG}; the query schema enforces this on the RPC boundary).
+ */
+export function queryAllPrivateLogsByTags(
+  node: PrivateLogsByTagsFetcher,
+  query: PrivateLogsQuery,
+): Promise<LogResult[][]> {
+  return queryAllByTags(
+    query.tags,
+    tagQueries => node.getPrivateLogsByTags({ ...query, tags: tagQueries }),
+    query.limitPerTag,
+  );
+}
+
+/** {@inheritDoc queryAllPrivateLogsByTags} */
+export function queryAllPublicLogsByTags(
+  node: PublicLogsByTagsFetcher,
+  query: PublicLogsQuery,
+): Promise<LogResult[][]> {
+  return queryAllByTags(
+    query.tags,
+    tagQueries => node.getPublicLogsByTags({ ...query, tags: tagQueries }),
+    query.limitPerTag,
+  );
+}
+
+/**
+ * Generic per-tag pagination loop, abstracted over the query shape (private vs public). Caller supplies
+ * a `fetchPage` that runs one round against the node with the still-active subset of tag queries.
+ *
+ * @param tags - Input tag queries in original order. Returned outer array has the same length and order.
+ * @param fetchPage - Per-round fetch hook; receives the active subset and returns one page per active tag.
+ * @param limitPerTag - Effective page cap used to detect "full page" → keep paginating; defaults to
+ *   {@link MAX_LOGS_PER_TAG} (the server-side cap when the query doesn't override).
+ */
+async function queryAllByTags<T extends Tag | SiloedTag>(
+  tags: TagQuery<T>[],
+  fetchPage: (tagQueries: TagQuery<T>[]) => Promise<LogResult[][]>,
+  limitPerTag: number | undefined,
+): Promise<LogResult[][]> {
+  const effectiveLimit = limitPerTag ?? MAX_LOGS_PER_TAG;
+  const allResultsPerTag: LogResult[][] = tags.map(() => []);
+  let activeIndexes = tags.map((_, i) => i);
+  let nextQueries: TagQuery<T>[] = tags.slice();
+
+  while (activeIndexes.length > 0) {
+    const pageResults = await fetchPage(nextQueries);
+
+    const stillActive: number[] = [];
+    const followups: TagQuery<T>[] = [];
+    for (let i = 0; i < activeIndexes.length; i++) {
+      const originalIdx = activeIndexes[i];
+      const pageForTag = pageResults[i];
+      allResultsPerTag[originalIdx].push(...pageForTag);
+      if (pageForTag.length === effectiveLimit) {
+        const lastLog = pageForTag[pageForTag.length - 1];
+        stillActive.push(originalIdx);
+        followups.push({ tag: tagOf(tags[originalIdx]), afterLog: LogCursor.fromLog(lastLog) });
+      }
+    }
+    activeIndexes = stillActive;
+    nextQueries = followups;
+  }
+
+  return allResultsPerTag;
+}
+
+/** Unwraps a `TagQuery` to its underlying `Tag` / `SiloedTag` regardless of the bare-vs-object form. */
+function tagOf<T extends Tag | SiloedTag>(entry: TagQuery<T>): T {
+  if (typeof entry === 'object' && entry !== null && 'tag' in entry) {
+    return entry.tag;
+  }
+  return entry as T;
+}

package/src/logs/shared_secret_derivation.ts

@@ -2,16 +2,28 @@ import { DomainSeparator } from '@aztec/constants';
 import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import type { Fr } from '@aztec/foundation/curves/bn254';
-import type { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
+import { GrumpkinScalar, type Point } from '@aztec/foundation/curves/grumpkin';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 import type { PublicKey } from '../keys/public_key.js';
 
 /**
- * Derives an app-siloed ECDH shared secret.
+ * Derives the raw ECDH shared secret point `S = secretKey * publicKey`.
  *
- * Computes the raw ECDH shared secret `S = secretKey * publicKey`, then app-silos it:
- * `s_app = h(DOM_SEP__APP_SILOED_ECDH_SHARED_SECRET, S.x, S.y, contractAddress)`
+ * @throws If the publicKey is zero.
+ */
+export function deriveEcdhSharedSecretPoint(secretKey: GrumpkinScalar, publicKey: PublicKey): Promise<Point> {
+  if (publicKey.isZero()) {
+    throw new Error(
+      `Attempting to derive a shared secret with a zero public key. You have probably passed a zero public key in your Noir code somewhere thinking that the note won't be broadcast... but it was.`,
+    );
+  }
+  return Grumpkin.mul(publicKey, secretKey);
+}
+
+/**
+ * Derives an app-siloed ECDH shared secret from keys: ECDHs `S = secretKey * publicKey` via
+ * {@link deriveEcdhSharedSecretPoint}, then app-silos it via {@link appSiloEcdhSharedSecretPoint}.
  *
  * @param secretKey - The secret key used to derive shared secret.
  * @param publicKey - The public key used to derive shared secret.
@@ -19,19 +31,40 @@ import type { PublicKey } from '../keys/public_key.js';
  * @returns The app-siloed shared secret as a Field.
  * @throws If the publicKey is zero.
  */
-export async function deriveAppSiloedSharedSecret(
+export async function appSiloEcdhSharedSecret(
   secretKey: GrumpkinScalar,
   publicKey: PublicKey,
   contractAddress: AztecAddress,
 ): Promise<Fr> {
-  if (publicKey.isZero()) {
-    throw new Error(
-      `Attempting to derive a shared secret with a zero public key. You have probably passed a zero public key in your Noir code somewhere thinking that the note won't be broadcast... but it was.`,
-    );
-  }
-  const rawSharedSecret = await Grumpkin.mul(publicKey, secretKey);
-  return poseidon2HashWithSeparator(
-    [rawSharedSecret.x, rawSharedSecret.y, contractAddress],
-    DomainSeparator.APP_SILOED_ECDH_SHARED_SECRET,
+  const rawSharedSecret = await deriveEcdhSharedSecretPoint(secretKey, publicKey);
+  return appSiloEcdhSharedSecretPoint(rawSharedSecret, contractAddress);
+}
+
+/**
+ * App-silos a shared secret point: `s_app = h(DOM_SEP__APP_SILOED_ECDH_SHARED_SECRET, S.x, S.y, app)`.
+ *
+ * Mirrors `compute_app_siloed_shared_secret` in aztec-nr.
+ *
+ * @param point - The raw shared secret point `S`.
+ * @param app - The contract address to silo to.
+ */
+export function appSiloEcdhSharedSecretPoint(point: Point, app: AztecAddress): Promise<Fr> {
+  return poseidon2HashWithSeparator([point.x, point.y, app], DomainSeparator.APP_SILOED_ECDH_SHARED_SECRET);
+}
+
+/**
+ * Protects a handshake's shared secret from being forged by the recipient: `S' = hash(ephPk, recipientPoint) * S`.
+ *
+ * Mirrors aztec-nr's `protect_from_forgery` and must stay byte-compatible with it.
+ *
+ * @param secret - The raw shared secret `S` to protect.
+ * @param ephPk - The handshake's ephemeral public key.
+ * @param recipientPoint - The recipient's address point.
+ */
+export async function protectFromForgery(secret: Point, ephPk: Point, recipientPoint: Point): Promise<Point> {
+  const scalar = await poseidon2HashWithSeparator(
+    [ephPk.x, ephPk.y, recipientPoint.x, recipientPoint.y],
+    DomainSeparator.HANDSHAKE_FORGERY_PROTECTION,
   );
+  return Grumpkin.mul(secret, new GrumpkinScalar(scalar.toBigInt()));
 }

package/src/logs/siloed_tag.ts

@@ -1,31 +1,31 @@
 import { DomainSeparator } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/curves/bn254';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ZodFor } from '@aztec/foundation/schemas';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 import { computeLogTag, computeSiloedPrivateLogFirstField } from '../hash/hash.js';
 import { schemas } from '../schemas/schemas.js';
+import { AppTaggingSecretKind } from './app_tagging_secret_kind.js';
 import type { PreTag } from './pre_tag.js';
 import { Tag } from './tag.js';
 
-/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
-
-/** Branding to ensure fields are not interchangeable types. */
-export interface SiloedTag {
-  /** Brand. */
-  _branding: 'SiloedTag';
-}
-
 /**
  * Represents a tag used in private log as it "appears on the chain" - that is the tag is siloed with a contract
  * address that emitted the log.
  */
 export class SiloedTag {
+  /** Branding for nominal typing. */
+  declare private readonly _branding: 'SiloedTag';
+
   constructor(public readonly value: Fr) {}
 
   static async compute(preTag: PreTag): Promise<SiloedTag> {
     const tag = await Tag.compute(preTag);
-    const logTag = await computeLogTag(tag.value, DomainSeparator.UNCONSTRAINED_MSG_LOG_TAG);
+    const domainSeparator =
+      preTag.extendedSecret.kind === AppTaggingSecretKind.CONSTRAINED
+        ? DomainSeparator.CONSTRAINED_MSG_LOG_TAG
+        : DomainSeparator.UNCONSTRAINED_MSG_LOG_TAG;
+    const logTag = await computeLogTag(tag.value, domainSeparator);
     return SiloedTag.computeFromTagAndApp(new Tag(logTag), preTag.extendedSecret.app);
   }
 
@@ -49,6 +49,10 @@ export class SiloedTag {
     return this.value.equals(other.value);
   }
 
+  static random(): SiloedTag {
+    return new SiloedTag(Fr.random());
+  }
+
   static get schema(): ZodFor<SiloedTag> {
     return schemas.Fr.transform((fr: Fr) => new SiloedTag(fr));
   }

package/src/logs/tag.ts

@@ -1,22 +1,18 @@
 import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
-import type { Fr } from '@aztec/foundation/curves/bn254';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ZodFor } from '@aztec/foundation/schemas';
 
 import { schemas } from '../schemas/schemas.js';
 import type { PreTag } from './pre_tag.js';
 
-/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
-
-export interface Tag {
-  /** Brand. */
-  _branding: 'Tag';
-}
-
 /**
  * Represents a tag of a private log. This is not the tag that "appears" on the chain as this tag is first siloed
  * with a contract address by kernels before being included in the final log.
  */
 export class Tag {
+  /** Branding for nominal typing. */
+  declare private readonly _branding: 'Tag';
+
   constructor(public readonly value: Fr) {}
 
   static async compute(preTag: PreTag): Promise<Tag> {
@@ -36,6 +32,10 @@ export class Tag {
     return this.value.equals(other.value);
   }
 
+  static random(): Tag {
+    return new Tag(Fr.random());
+  }
+
   static get schema(): ZodFor<Tag> {
     return schemas.Fr.transform((fr: Fr) => new Tag(fr));
   }

package/src/logs/tagging_index_range.ts

@@ -2,23 +2,17 @@ import { schemas } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
-import {
-  type ExtendedDirectionalAppTaggingSecret,
-  ExtendedDirectionalAppTaggingSecretSchema,
-} from './extended_directional_app_tagging_secret.js';
+import { type AppTaggingSecret, AppTaggingSecretSchema } from './app_tagging_secret.js';
 
-/**
- * Represents a range of tagging indexes for a given extended directional app tagging secret. Used to track the lowest
- * and highest indexes used in a transaction for a given (sender, recipient, app/contract) tuple.
- */
+/** Represents a range of tagging indexes for a given app tagging secret. */
 export type TaggingIndexRange = {
-  extendedSecret: ExtendedDirectionalAppTaggingSecret;
+  extendedSecret: AppTaggingSecret;
   lowestIndex: number;
   highestIndex: number;
 };
 
 export const TaggingIndexRangeSchema = z.object({
-  extendedSecret: ExtendedDirectionalAppTaggingSecretSchema,
+  extendedSecret: AppTaggingSecretSchema,
   lowestIndex: schemas.Integer,
   highestIndex: schemas.Integer,
 });

package/src/messaging/append_l1_to_l2_messages.ts

@@ -0,0 +1,21 @@
+import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+
+import type { MerkleTreeWriteOperations } from '../interfaces/merkle_tree_operations.js';
+import { MerkleTreeId } from '../trees/merkle_tree_id.js';
+
+/**
+ * Pads `l1ToL2Messages` to `NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP` and appends them to the
+ * L1→L2 message tree of `db`. Use whenever a fork at "state before the first block of a
+ * checkpoint" needs to mirror what the world-state synchronizer inserts at sync time.
+ */
+export async function appendL1ToL2MessagesToTree(db: MerkleTreeWriteOperations, l1ToL2Messages: Fr[]): Promise<void> {
+  const padded = padArrayEnd<Fr, number>(
+    l1ToL2Messages,
+    Fr.ZERO,
+    NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+    'Too many L1 to L2 messages',
+  );
+  await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, padded);
+}

package/src/messaging/index.ts

@@ -1,3 +1,4 @@
+export * from './append_l1_to_l2_messages.js';
 export * from './in_hash.js';
 export * from './inbox_leaf.js';
 export * from './l1_to_l2_message.js';

package/src/messaging/l1_to_l2_message.ts

@@ -1,4 +1,5 @@
-import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
+import { DomainSeparator, type L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { sha256ToField } from '@aztec/foundation/crypto/sha256';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
@@ -7,7 +8,7 @@ import { SiblingPath } from '@aztec/foundation/trees';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 import type { BlockParameter } from '../block/block_parameter.js';
-import { computeL1ToL2MessageNullifier } from '../hash/hash.js';
+import { siloNullifier } from '../hash/hash.js';
 import type { AztecNode } from '../interfaces/aztec-node.js';
 import { MerkleTreeId } from '../trees/merkle_tree_id.js';
 import { L1Actor } from './l1_actor.js';
@@ -74,28 +75,65 @@ export class L1ToL2Message {
   }
 }
 
-// This functionality is not on the node because we do not want to pass the node the secret, and give the node the ability to derive a valid nullifer for an L1 to L2 message.
-export async function getNonNullifiedL1ToL2MessageWitness(
+/**
+ * The unsiloed nullifier a message consumer derives, together with the contract address needed to silo it.
+ */
+export interface UnsiloedMessageNullifier {
+  contractAddress: AztecAddress;
+  nullifier: Fr;
+}
+
+/**
+ * Computes the unsiloed nullifier that the fee juice contract (and any consumer following the same scheme) derives when
+ * consuming an L1 to L2 message.
+ *
+ * This is not a general-purpose utility: other contracts may derive the secret hash and hence the nullifier
+ * differently. The result is unsiloed — callers silo it (with the consuming contract's address) before looking it up
+ * in the nullifier tree.
+ */
+export function computeFeeJuiceMessageNullifier(messageHash: Fr, secret: Fr): Promise<Fr> {
+  return poseidon2HashWithSeparator([messageHash, secret], DomainSeparator.MESSAGE_NULLIFIER);
+}
+
+/**
+ * Fetches the membership witness of an L1 to L2 message. When `unsiloedNullifier` is provided, the message is
+ * additionally required to be un-nullified.
+ */
+export async function getL1ToL2MessageWitness(
   node: AztecNode,
-  contractAddress: AztecAddress,
   messageHash: Fr,
-  secret: Fr,
+  unsiloedNullifier?: UnsiloedMessageNullifier,
   referenceBlock: BlockParameter = 'latest',
 ): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>]> {
-  const messageNullifier = await computeL1ToL2MessageNullifier(contractAddress, messageHash, secret);
-
-  const [l1ToL2Response, nullifierResponse] = await Promise.all([
-    node.getL1ToL2MessageMembershipWitness(referenceBlock, messageHash),
-    node.findLeavesIndexes(referenceBlock, MerkleTreeId.NULLIFIER_TREE, [messageNullifier]),
-  ]);
+  // Both requests are dispatched before awaiting so they run concurrently.
+  const l1ToL2ResponsePromise = node.getL1ToL2MessageMembershipWitness(referenceBlock, messageHash);
+  const nullifierResponsePromise = unsiloedNullifier
+    ? siloNullifier(unsiloedNullifier.contractAddress, unsiloedNullifier.nullifier).then(siloed =>
+        node.findLeavesIndexes(referenceBlock, MerkleTreeId.NULLIFIER_TREE, [siloed]),
+      )
+    : undefined;
 
+  const l1ToL2Response = await l1ToL2ResponsePromise;
   if (!l1ToL2Response) {
     throw new Error(`No L1 to L2 message found for message hash ${messageHash.toString()}`);
   }
 
-  if (nullifierResponse[0] !== undefined) {
+  const nullifierResponse = await nullifierResponsePromise;
+  if (nullifierResponse?.[0] !== undefined) {
     throw new Error(`No non-nullified L1 to L2 message found for message hash ${messageHash.toString()}`);
   }
 
   return l1ToL2Response;
 }
+
+// This functionality is not on the node because we do not want to pass the node the secret, and give the node the ability to derive a valid nullifer for an L1 to L2 message.
+export async function getNonNullifiedL1ToL2MessageWitness(
+  node: AztecNode,
+  contractAddress: AztecAddress,
+  messageHash: Fr,
+  secret: Fr,
+  referenceBlock: BlockParameter = 'latest',
+): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>]> {
+  const nullifier = await computeFeeJuiceMessageNullifier(messageHash, secret);
+  return getL1ToL2MessageWitness(node, messageHash, { contractAddress, nullifier }, referenceBlock);
+}

package/src/messaging/l1_to_l2_message_source.ts

@@ -10,7 +10,9 @@ export interface L1ToL2MessageSource {
   /**
    * Gets new L1 to L2 message (to be) included in a given checkpoint.
    * @param checkpointNumber - Checkpoint number to get messages for.
-   * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
+   * @returns The L1 to L2 messages/leaves of the messages subtree.
+   * @throws If the message tree for the given checkpoint has not yet been sealed on L1
+   * (i.e., checkpointNumber >= inbox treeInProgress).
    */
   getL1ToL2Messages(checkpointNumber: CheckpointNumber): Promise<Fr[]>;