@aztec/stdlib 0.0.1-commit.b2a5d0dd1 → 0.0.1-commit.b3d3157a

package/src/logs/log_cursor.ts

@@ -0,0 +1,110 @@
+import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
+import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
+
+import { z } from 'zod';
+
+import { schemas } from '../schemas/schemas.js';
+import type { LogResultBase } from './log_result.js';
+
+/**
+ * Cursor identifying a position in a tag's ordered log stream. Used as `afterLog` on `TagQuery` to resume
+ * pagination strictly after a previously-seen log.
+ *
+ * `(blockNumber, txIndexWithinBlock, logIndexWithinTx)` is sufficient to uniquely identify a position
+ * and matches the composite-key ordering of the archiver's log index, so the cursor maps directly to a
+ * key without a tx-hash lookup. All three fields are always present on {@link LogResult}, so a cursor is
+ * constructible from any returned log.
+ */
+export class LogCursor {
+  constructor(
+    /** The block the cursor points to. */
+    public readonly blockNumber: BlockNumber,
+    /** The tx index within the block the cursor points to. */
+    public readonly txIndexWithinBlock: number,
+    /** The log index within the tx the cursor points to. */
+    public readonly logIndexWithinTx: number,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        blockNumber: BlockNumberSchema,
+        txIndexWithinBlock: schemas.Integer,
+        logIndexWithinTx: schemas.Integer,
+      })
+      .transform(
+        ({ blockNumber, txIndexWithinBlock, logIndexWithinTx }) =>
+          new LogCursor(blockNumber, txIndexWithinBlock, logIndexWithinTx),
+      );
+  }
+
+  /** Builds a cursor that points at the given log. Pagination resumes strictly after this position. */
+  static fromLog(log: Pick<LogResultBase, 'blockNumber' | 'txIndexWithinBlock' | 'logIndexWithinTx'>): LogCursor {
+    return new LogCursor(log.blockNumber, log.txIndexWithinBlock, log.logIndexWithinTx);
+  }
+
+  static random(): LogCursor {
+    return new LogCursor(
+      BlockNumber(Math.floor(Math.random() * 100000) + 1),
+      Math.floor(Math.random() * 100),
+      Math.floor(Math.random() * 100),
+    );
+  }
+
+  toBuffer(): Buffer {
+    return Buffer.concat([
+      numToUInt32BE(this.blockNumber),
+      numToUInt32BE(this.txIndexWithinBlock),
+      numToUInt32BE(this.logIndexWithinTx),
+    ]);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): LogCursor {
+    const reader = BufferReader.asReader(buffer);
+    const blockNumber = BlockNumber(reader.readNumber());
+    const txIndexWithinBlock = reader.readNumber();
+    const logIndexWithinTx = reader.readNumber();
+    return new LogCursor(blockNumber, txIndexWithinBlock, logIndexWithinTx);
+  }
+
+  equals(other: LogCursor): boolean {
+    return (
+      this.blockNumber === other.blockNumber &&
+      this.txIndexWithinBlock === other.txIndexWithinBlock &&
+      this.logIndexWithinTx === other.logIndexWithinTx
+    );
+  }
+
+  toString(): string {
+    return `${this.blockNumber}-${this.txIndexWithinBlock}-${this.logIndexWithinTx}`;
+  }
+
+  /**
+   * Parses a `<blockNumber>-<txIndexWithinBlock>-<logIndexWithinTx>` triple into a {@link LogCursor}.
+   * Throws on malformed input. Returns `undefined` for an empty / missing value so callers can use
+   * this directly as an optional CLI option parser.
+   */
+  static parseOptional(value: string): LogCursor | undefined {
+    if (!value) {
+      return undefined;
+    }
+    const parts = value.split('-');
+    if (parts.length !== 3) {
+      throw new Error(`Invalid log cursor "${value}". Expected <blockNumber>-<txIndexWithinBlock>-<logIndexWithinTx>.`);
+    }
+    const [blockNumberStr, txIndexStr, logIndexStr] = parts;
+    const blockNumber = Number(blockNumberStr);
+    const txIndexWithinBlock = Number(txIndexStr);
+    const logIndexWithinTx = Number(logIndexStr);
+    if (!Number.isInteger(blockNumber) || blockNumber < 1) {
+      throw new Error(`Invalid log cursor block number: ${blockNumberStr}`);
+    }
+    if (!Number.isInteger(txIndexWithinBlock) || txIndexWithinBlock < 0) {
+      throw new Error(`Invalid log cursor tx index: ${txIndexStr}`);
+    }
+    if (!Number.isInteger(logIndexWithinTx) || logIndexWithinTx < 0) {
+      throw new Error(`Invalid log cursor log index: ${logIndexStr}`);
+    }
+    return new LogCursor(BlockNumber(blockNumber), txIndexWithinBlock, logIndexWithinTx);
+  }
+}

package/src/logs/log_result.ts

@@ -0,0 +1,104 @@
+import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
+import { times } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { schemas as foundationSchemas } from '@aztec/foundation/schemas';
+import type { PickIfFlag, Prettify } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { BlockHash } from '../block/block_hash.js';
+import { schemas } from '../schemas/schemas.js';
+import { TxHash } from '../tx/tx_hash.js';
+import type { UInt64 } from '../types/shared.js';
+
+/** Options for narrowing the shape of a {@link LogResult}. */
+export type LogIncludeOptions = {
+  /** When set, the log carries `noteHashes` + all `nullifiers` from its tx effect. Off by default. */
+  includeEffects?: boolean;
+};
+
+export const LogIncludeOptionsSchema: z.ZodType<LogIncludeOptions> = z.object({
+  includeEffects: z.boolean().optional(),
+});
+
+/** Required metadata always present on a {@link LogResult}. */
+export type LogResultBase = {
+  /** The data contents of the log, with the tag as the first field. */
+  logData: Fr[];
+  /** The block this log was emitted in. */
+  blockNumber: BlockNumber;
+  /** The hash of the block this log was emitted in. */
+  blockHash: BlockHash;
+  /** The timestamp of the block this log was emitted in. */
+  blockTimestamp: UInt64;
+  /** The hash of the tx this log was emitted in. */
+  txHash: TxHash;
+  /** The 0-based index of this log's tx within its block. */
+  txIndexWithinBlock: number;
+  /** The 0-based index of this log within its tx (across both private and public logs for the tx). */
+  logIndexWithinTx: number;
+};
+
+/**
+ * A single log returned from {@link L2LogsSource.getPrivateLogsByTags} or {@link L2LogsSource.getPublicLogsByTags}.
+ *
+ * Generic over the include-options so that flagged fields become required when the caller passes a
+ * literal `true`. The default type argument ({@link LogIncludeOptions}) yields the widest shape
+ * (all include-fields optional) — this is what the JSON-RPC wire layer validates against.
+ *
+ * `logData` is the raw field-element payload, with the tag in field 0 (consumers slice it off).
+ *
+ * @example
+ * const l: LogResult<{ includeEffects: true }> = (await node.getPrivateLogsByTags({ tags, includeEffects: true }))[0][0];
+ * l.nullifiers; // required, not optional
+ */
+export type LogResult<Opts extends LogIncludeOptions = LogIncludeOptions> = Prettify<
+  LogResultBase & PickIfFlag<LogIncludeOptions, Opts, 'includeEffects', { noteHashes: Fr[]; nullifiers: Fr[] }>
+>;
+
+/** Zod schema for the widest {@link LogResult} shape (all include-gated fields optional). */
+export const LogResultSchema: z.ZodType<LogResult> = z.object({
+  logData: z.array(foundationSchemas.Fr),
+  blockNumber: BlockNumberSchema,
+  blockHash: BlockHash.schema,
+  blockTimestamp: schemas.UInt64,
+  txHash: TxHash.schema,
+  txIndexWithinBlock: schemas.Integer,
+  logIndexWithinTx: schemas.Integer,
+  noteHashes: z.array(foundationSchemas.Fr).optional(),
+  nullifiers: z.array(foundationSchemas.Fr).optional(),
+});
+
+/** Builds a random {@link LogResult} for tests. `includeEffects` populates `noteHashes` + `nullifiers`. */
+export function randomLogResult(includeEffects = false): LogResult {
+  const base: LogResultBase = {
+    logData: times(3, Fr.random),
+    blockNumber: BlockNumber(Math.floor(Math.random() * 100000) + 1),
+    blockHash: BlockHash.random(),
+    blockTimestamp: BigInt(Math.floor(Date.now() / 1000)),
+    txHash: TxHash.random(),
+    txIndexWithinBlock: Math.floor(Math.random() * 100),
+    logIndexWithinTx: Math.floor(Math.random() * 100),
+  };
+  if (includeEffects) {
+    return { ...base, noteHashes: times(3, Fr.random), nullifiers: times(3, Fr.random) };
+  }
+  return base;
+}
+
+/** Human-readable single-line representation, primarily for the CLI `get-logs` command. */
+export function logResultToHumanReadable(log: LogResult): string {
+  const head =
+    `block ${log.blockNumber} (${log.blockHash.toString()}) ` +
+    `tx ${log.txHash.toString()} txIndex ${log.txIndexWithinBlock} logIndex ${log.logIndexWithinTx} ` +
+    `ts ${log.blockTimestamp}`;
+  const data = `data [${log.logData.map(f => f.toString()).join(', ')}]`;
+  const parts = [head, data];
+  if (log.noteHashes !== undefined) {
+    parts.push(`noteHashes [${log.noteHashes.map(f => f.toString()).join(', ')}]`);
+  }
+  if (log.nullifiers !== undefined) {
+    parts.push(`nullifiers [${log.nullifiers.map(f => f.toString()).join(', ')}]`);
+  }
+  return parts.join(' | ');
+}

package/src/logs/logs_query.ts

@@ -0,0 +1,138 @@
+import { BlockNumberSchema } from '@aztec/foundation/branded-types';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+
+import { z } from 'zod';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import { BlockHash } from '../block/block_hash.js';
+import { MAX_LOGS_PER_TAG, MAX_RPC_LEN } from '../interfaces/api_limit.js';
+import { type ZodFor, schemas, zodFor } from '../schemas/index.js';
+import { TxHash } from '../tx/tx_hash.js';
+import { LogCursor } from './log_cursor.js';
+import { SiloedTag } from './siloed_tag.js';
+import { Tag } from './tag.js';
+
+/**
+ * A tag to query in {@link PrivateLogsQuery} / {@link PublicLogsQuery}, optionally resuming strictly
+ * after a previously-seen log via `afterLog`. The bare `T` form means "from the beginning".
+ */
+export type TagQuery<T extends Tag | SiloedTag> = T | { tag: T; afterLog?: LogCursor };
+
+/**
+ * Shared fields for {@link PrivateLogsQuery} and {@link PublicLogsQuery}.
+ */
+export type LogsQueryBase = {
+  /** Lower block bound, inclusive. */
+  fromBlock?: BlockNumber;
+  /** Upper block bound, exclusive. */
+  toBlock?: BlockNumber;
+  /**
+   * Restrict results to logs emitted in this transaction. Mutually exclusive with `fromBlock`/`toBlock`
+   * (a txHash already pins a block). `txHash` + `afterLog` is allowed and paginates within the tx's logs
+   * for that tag.
+   */
+  txHash?: TxHash;
+  /**
+   * Reorg-safety anchor: the latest block hash the caller has synced to. If set and the block is no
+   * longer present, the call throws. Distinct from `toBlock`, which is a filter, not a safety check.
+   */
+  referenceBlock?: BlockHash;
+  /** When set, each log also carries `noteHashes` and all `nullifiers` for note-nonce discovery. */
+  includeEffects?: boolean;
+  /**
+   * Maximum number of logs returned per tag. Capped at {@link MAX_LOGS_PER_TAG} (rejected if higher).
+   * Defaults to {@link MAX_LOGS_PER_TAG} when unset. Mainly useful for tests that need to force
+   * pagination at a small page size.
+   */
+  limitPerTag?: number;
+};
+
+/**
+ * Query for {@link L2LogsSource.getPrivateLogsByTags}. Returns one inner array per element of `tags`,
+ * in input order.
+ */
+export type PrivateLogsQuery = LogsQueryBase & {
+  /** Tags to query. Between 1 and {@link MAX_RPC_LEN} entries (inclusive). */
+  tags: TagQuery<SiloedTag>[];
+};
+
+/**
+ * Query for {@link L2LogsSource.getPublicLogsByTags}. Returns one inner array per element of `tags`,
+ * in input order.
+ */
+export type PublicLogsQuery = LogsQueryBase & {
+  /** Contract address that emitted the logs. Required for public queries. */
+  contractAddress: AztecAddress;
+  /** Tags to query. Between 1 and {@link MAX_RPC_LEN} entries (inclusive). */
+  tags: TagQuery<Tag>[];
+};
+
+function tagQuerySchema<T extends Tag | SiloedTag>(tagSchema: ZodFor<T>) {
+  return z.union([
+    tagSchema,
+    z.object({
+      tag: tagSchema,
+      afterLog: LogCursor.schema.optional(),
+    }),
+  ]) as ZodFor<TagQuery<T>>;
+}
+
+const logsQueryBaseShape = {
+  fromBlock: BlockNumberSchema.optional(),
+  toBlock: BlockNumberSchema.optional(),
+  txHash: TxHash.schema.optional(),
+  referenceBlock: BlockHash.schema.optional(),
+  includeEffects: z.boolean().optional(),
+  limitPerTag: z
+    .number()
+    .int()
+    .positive()
+    .max(MAX_LOGS_PER_TAG, { message: `limitPerTag must be <= ${MAX_LOGS_PER_TAG}` })
+    .optional(),
+};
+
+/** Minimal shape required by {@link refineTxHashAndRange}. */
+type TxHashAndRangeFields = {
+  /** Tx hash filter. */
+  txHash?: TxHash;
+  /** Lower block bound. */
+  fromBlock?: BlockNumber;
+  /** Upper block bound (exclusive). */
+  toBlock?: BlockNumber;
+};
+
+/**
+ * Refinement: a `txHash` already pins a block, so combining it with a block range is contradictory.
+ * (`txHash` + `afterLog` is still allowed and is enforced per-tag inside `TagQuery`.) Exported so
+ * `aztec.js`'s wallet event-filter schemas can reuse the same rule.
+ */
+export function refineTxHashAndRange<T extends TxHashAndRangeFields>(schema: z.ZodType<T>) {
+  return schema.refine(q => !(q.txHash !== undefined && (q.fromBlock !== undefined || q.toBlock !== undefined)), {
+    message: '`txHash` is mutually exclusive with `fromBlock`/`toBlock`',
+  });
+}
+
+export const PrivateLogsQuerySchema: ZodFor<PrivateLogsQuery> = refineTxHashAndRange(
+  zodFor<PrivateLogsQuery>()(
+    z.object({
+      ...logsQueryBaseShape,
+      tags: z
+        .array(tagQuerySchema(SiloedTag.schema))
+        .min(1)
+        .max(MAX_RPC_LEN, { message: `tags must have at most ${MAX_RPC_LEN} entries` }),
+    }),
+  ),
+);
+
+export const PublicLogsQuerySchema: ZodFor<PublicLogsQuery> = refineTxHashAndRange(
+  zodFor<PublicLogsQuery>()(
+    z.object({
+      ...logsQueryBaseShape,
+      contractAddress: schemas.AztecAddress,
+      tags: z
+        .array(tagQuerySchema(Tag.schema))
+        .min(1)
+        .max(MAX_RPC_LEN, { message: `tags must have at most ${MAX_RPC_LEN} entries` }),
+    }),
+  ),
+);

package/src/logs/message_context.ts

@@ -2,7 +2,7 @@ import { MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
 import { range } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/curves/bn254';
 
-import type { TxHash } from '../tx/tx_hash.js';
+import { TxHash } from '../tx/tx_hash.js';
 
 /**
  * Additional information needed to process a message.
@@ -38,6 +38,10 @@ export class MessageContext {
     /* eslint-enable camelcase */
   }
 
+  static empty(): MessageContext {
+    return new MessageContext(TxHash.zero(), [], Fr.ZERO);
+  }
+
   static toEmptyFields(): Fr[] {
     const serializationLen =
       1 /* txHash */ + MAX_NOTE_HASHES_PER_TX + 1 /* uniqueNoteHashesInTx BVec */ + 1; /* firstNullifierInTx */

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,8 +68,13 @@ 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) {

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

@@ -5,6 +5,7 @@ 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';
 
@@ -20,7 +21,11 @@ export class SiloedTag {
 
   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);
   }
 

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';