@aztec/stdlib 0.0.1-fake-ceab37513c → 0.0.1-private.d0bedffd

package/src/logs/public_log.ts

@@ -1,133 +1,218 @@
-import { PUBLIC_LOG_LENGTH, PUBLIC_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
-import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+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';
-import {
-  BufferReader,
-  FieldReader,
-  type Tuple,
-  serializeToBuffer,
-  serializeToFields,
-} from '@aztec/foundation/serialize';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
 import { z } from 'zod';
 
 import { AztecAddress } from '../aztec-address/index.js';
 
-export class PublicLog {
-  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * PUBLIC_LOG_LENGTH;
+function totalSizeInFields(logs: PublicLog[]) {
+  return logs.reduce((acc, log) => acc + log.sizeInFields(), 0);
+}
 
+// This class represents logs in the same format as noir does, with a bounded maximum length.
+export class FlatPublicLogs {
+  // We don't use tuple here because FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH is too large
   constructor(
-    public contractAddress: AztecAddress,
-    public fields: Tuple<Fr, typeof PUBLIC_LOG_SIZE_IN_FIELDS>,
-    public emittedLength: number,
-  ) {}
+    public length: number,
+    public payload: Fr[],
+  ) {
+    if (payload.length !== FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH) {
+      throw new Error('Invalid payload given to FlatPublicLogs');
+    }
+    if (length > payload.length) {
+      throw new Error('Invalid length given to FlatPublicLogs');
+    }
+  }
 
-  static from(fields: FieldsOf<PublicLog>) {
-    return new PublicLog(...PublicLog.getFields(fields));
+  private static fromUnpaddedPayload(payload: Fr[]) {
+    const length = payload.length;
+    return new FlatPublicLogs(length, [...payload, ...Array(FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH - length).fill(Fr.ZERO)]);
   }
 
-  static getFields(fields: FieldsOf<PublicLog>) {
-    return [fields.contractAddress, fields.fields, fields.emittedLength] as const;
+  // In blobs, the actual nonempty length of the logs is encoded with the prefix, and then we have the non-padded payload.
+  static fromBlobFields(length: number, fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    const payload = reader.readFieldArray(length);
+    return this.fromUnpaddedPayload(payload);
   }
 
+  toBlobFields() {
+    return this.payload.slice(0, this.length);
+  }
+
+  static fromLogs(logs: PublicLog[]) {
+    return this.fromUnpaddedPayload(logs.flatMap(log => log.toFields()));
+  }
+
+  toLogs() {
+    const reader = FieldReader.asReader(this.payload);
+    const logs = [];
+    while (totalSizeInFields(logs) < this.length) {
+      logs.push(PublicLog.fromFields(reader));
+    }
+    if (totalSizeInFields(logs) !== this.length) {
+      throw new Error('Wrong length in FlatPublicLogs');
+    }
+    return logs;
+  }
+
+  static get schema(): ZodFor<FlatPublicLogs> {
+    return z
+      .object({
+        length: z.number(),
+        payload: z.array(schemas.Fr).min(FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH).max(FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH),
+      })
+      .transform(({ length, payload }) => new FlatPublicLogs(length, payload));
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.length, this.payload.slice(0, this.length));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    const length = reader.readNumber();
+    return this.fromUnpaddedPayload(reader.readArray(length, Fr));
+  }
+
+  // ToFields and fromFields expect the noir style representation, with constant length payload.
   toFields(): Fr[] {
-    return serializeToFields(...PublicLog.getFields(this));
+    return [new Fr(this.length), ...this.payload];
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new PublicLog(
-      reader.readObject(AztecAddress),
-      reader.readFieldArray(PUBLIC_LOG_SIZE_IN_FIELDS),
-      reader.readU32(),
+    // We need to do this because field reader returns tuples, which break the type system on these sizes.
+    const length = reader.readU32();
+    const payload: Fr[] = [];
+    for (let i = 0; i < FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH; ++i) {
+      payload.push(reader.readField());
+    }
+    return new FlatPublicLogs(length, payload);
+  }
+
+  static empty() {
+    return new FlatPublicLogs(0, Array(FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH).fill(Fr.ZERO));
+  }
+
+  /**
+   * Creates a FlatPublicLogs instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing FlatPublicLogs fields
+   * @returns A FlatPublicLogs instance
+   */
+  static fromPlainObject(obj: any): FlatPublicLogs {
+    return new FlatPublicLogs(
+      obj.length,
+      obj.payload.map((p: any) => Fr.fromPlainObject(p)),
     );
   }
 
-  getEmittedFields() {
-    return this.fields.slice(0, this.emittedLength);
+  isEmpty() {
+    return this.length === 0;
   }
+}
 
-  getEmittedFieldsWithoutTag() {
-    return this.fields.slice(1, this.emittedLength);
+export class PublicLog {
+  constructor(
+    public readonly contractAddress: AztecAddress,
+    public readonly fields: Fr[],
+  ) {}
+
+  static from(fields: FieldsOf<PublicLog>) {
+    return new PublicLog(...PublicLog.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PublicLog>) {
+    return [fields.contractAddress, fields.fields] as const;
   }
 
-  toBlobFields(): Fr[] {
-    return [new Fr(this.emittedLength), this.contractAddress.toField()].concat(this.getEmittedFields());
+  toFields(): Fr[] {
+    return [new Fr(this.fields.length), this.contractAddress.toField(), ...this.fields];
   }
 
-  static fromBlobFields(fields: Fr[] | FieldReader) {
+  static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    const emittedLength = reader.readU32();
-    const contractAddress = reader.readObject(AztecAddress);
-    const emittedFields = reader.readFieldArray(emittedLength);
-    return new PublicLog(
-      contractAddress,
-      padArrayEnd(emittedFields, Fr.ZERO, PUBLIC_LOG_SIZE_IN_FIELDS),
-      emittedLength,
-    );
+    const fieldsLength = reader.readU32();
+    return new PublicLog(reader.readObject(AztecAddress), reader.readFieldArray(fieldsLength));
+  }
+
+  sizeInFields() {
+    return this.fields.length + PUBLIC_LOG_HEADER_LENGTH;
+  }
+
+  /** Returns the serialized log (field as in noir field and not a struct field). */
+  getEmittedFields() {
+    // We slice from 0 to return a shallow copy.
+    return this.fields.slice(0);
+  }
+
+  getEmittedFieldsWithoutTag() {
+    return this.fields.slice(1);
   }
 
   isEmpty() {
-    return this.contractAddress.isZero() && this.fields.every(f => f.isZero()) && this.emittedLength === 0;
+    return this.contractAddress.isZero() && this.fields.length === 0;
   }
 
   static empty() {
-    return new PublicLog(AztecAddress.ZERO, makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, Fr.zero), 0);
+    return new PublicLog(AztecAddress.ZERO, []);
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer(...PublicLog.getFields(this));
+    return serializeToBuffer(this.fields.length, this.contractAddress, this.fields);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
+    const fieldsLength = reader.readNumber();
+    return new PublicLog(reader.readObject(AztecAddress), reader.readArray(fieldsLength, Fr));
+  }
+
+  static fromPlainObject(obj: any): PublicLog {
     return new PublicLog(
-      reader.readObject(AztecAddress),
-      reader.readArray(PUBLIC_LOG_SIZE_IN_FIELDS, Fr),
-      reader.readNumber(),
+      AztecAddress.fromPlainObject(obj.contractAddress),
+      obj.fields.map((f: any) => Fr.fromPlainObject(f)),
     );
   }
 
   static async random() {
     return new PublicLog(
       await AztecAddress.random(),
-      makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, Fr.random),
-      PUBLIC_LOG_SIZE_IN_FIELDS,
+      Array.from({ length: 10 }, () => Fr.random()),
     );
   }
 
   equals(other: this) {
     return (
+      this.fields.length === other.fields.length &&
       this.contractAddress.equals(other.contractAddress) &&
-      this.fields.every((field, i) => field.equals(other.fields[i])) &&
-      this.emittedLength === other.emittedLength
+      this.fields.every((field, i) => field.equals(other.fields[i]))
     );
   }
 
   toHumanReadable(): string {
-    return `PublicLog: (contractAddress: ${this.contractAddress} fields: ${this.fields}) emittedLength: ${this.emittedLength}`;
+    return `PublicLog: (contractAddress: ${this.contractAddress} fields: ${this.fields})`;
   }
 
   static get schema(): ZodFor<PublicLog> {
     return z
       .object({
         contractAddress: AztecAddress.schema,
-        fields: z.array(schemas.Fr).refine(arr => arr.length === PUBLIC_LOG_SIZE_IN_FIELDS),
-        emittedLength: z.number(),
+        fields: z.array(schemas.Fr),
       })
-      .transform(({ contractAddress, fields, emittedLength }) =>
-        PublicLog.fromFields([contractAddress.toField(), ...fields, new Fr(emittedLength)]),
-      );
+      .transform(({ contractAddress, fields }) => PublicLog.from({ contractAddress, fields }));
   }
 
   [inspect.custom](): string {
     return `PublicLog {
       contractAddress: ${inspect(this.contractAddress)},
       fields: [${this.fields.map(x => inspect(x)).join(', ')}],
-      emittedLength: ${this.emittedLength},
     }`;
   }
 }

package/src/logs/shared_secret_derivation.ts

@@ -1,5 +1,5 @@
-import { Grumpkin } from '@aztec/foundation/crypto';
-import type { GrumpkinScalar, Point } from '@aztec/foundation/fields';
+import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
+import type { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';
 
 import type { PublicKey } from '../keys/public_key.js';
 
@@ -16,13 +16,11 @@ import type { PublicKey } from '../keys/public_key.js';
  * TODO(#12656): This function is kept around because of the utilityGetSharedSecret oracle. Nuke this once returning
  * the app-siloed secret.
  */
-export async function deriveEcdhSharedSecret(secretKey: GrumpkinScalar, publicKey: PublicKey): Promise<Point> {
+export function deriveEcdhSharedSecret(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.`,
     );
   }
-  const curve = new Grumpkin();
-  const sharedSecret = await curve.mul(publicKey, secretKey);
-  return sharedSecret;
+  return Grumpkin.mul(publicKey, secretKey);
 }

package/src/logs/siloed_tag.ts

@@ -0,0 +1,50 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { ZodFor } from '@aztec/foundation/schemas';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import { computeSiloedPrivateLogFirstField } from '../hash/hash.js';
+import { schemas } from '../schemas/schemas.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 {
+  constructor(public readonly value: Fr) {}
+
+  static async compute(preTag: PreTag): Promise<SiloedTag> {
+    const tag = await Tag.compute(preTag);
+    return SiloedTag.computeFromTagAndApp(tag, preTag.extendedSecret.app);
+  }
+
+  static async computeFromTagAndApp(tag: Tag, app: AztecAddress): Promise<SiloedTag> {
+    const siloedTag = await computeSiloedPrivateLogFirstField(app, tag.value);
+    return new SiloedTag(siloedTag);
+  }
+
+  toString(): string {
+    return this.value.toString();
+  }
+
+  toJSON(): string {
+    return this.value.toString();
+  }
+
+  equals(other: SiloedTag): boolean {
+    return this.value.equals(other.value);
+  }
+
+  static get schema(): ZodFor<SiloedTag> {
+    return schemas.Fr.transform((fr: Fr) => new SiloedTag(fr));
+  }
+}

package/src/logs/tag.ts

@@ -0,0 +1,42 @@
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import type { 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 {
+  constructor(public readonly value: Fr) {}
+
+  static async compute(preTag: PreTag): Promise<Tag> {
+    const tag = await poseidon2Hash([preTag.extendedSecret.secret, preTag.index]);
+    return new Tag(tag);
+  }
+
+  toString(): string {
+    return this.value.toString();
+  }
+
+  toJSON(): string {
+    return this.value.toString();
+  }
+
+  equals(other: Tag): boolean {
+    return this.value.equals(other.value);
+  }
+
+  static get schema(): ZodFor<Tag> {
+    return schemas.Fr.transform((fr: Fr) => new Tag(fr));
+  }
+}

package/src/logs/tx_scoped_l2_log.ts

@@ -1,12 +1,19 @@
-import { BufferReader, boolToBuffer, numToUInt32BE } from '@aztec/foundation/serialize';
+import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { schemas as foundationSchemas } from '@aztec/foundation/schemas';
+import {
+  BufferReader,
+  bigintToUInt64BE,
+  numToUInt32BE,
+  serializeArrayOfBufferableToVector,
+} from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
+import { schemas } from '../schemas/schemas.js';
 import { TxHash } from '../tx/tx_hash.js';
-import { PrivateLog } from './private_log.js';
-import { PublicLog } from './public_log.js';
+import type { UInt64 } from '../types/shared.js';
 
-// TODO(#14460): Split to private and public versions instead of having this weird mix.
 export class TxScopedL2Log {
   constructor(
     /*
@@ -14,82 +21,78 @@ export class TxScopedL2Log {
      */
     public txHash: TxHash,
     /*
-     * The next available leaf index for the note hash tree for this transaction. It is stored
-     * with the log so the noteHashIndex can be reconstructed after decryption.
+     * The block this log is included in
      */
-    public dataStartIndexForTx: number,
+    public blockNumber: BlockNumber,
     /*
-     * The index of the log in the transaction. Note that public and private logs are in separate arrays in the tx
-     * effect and for this reason these indices are independent (a private and public log can have the same index).
+     * The timestamp of the block this log is included in
      */
-    public logIndexInTx: number,
+    public blockTimestamp: UInt64,
     /*
-     * The block this log is included in
+     * The log data as an array of field elements
+     */
+    public logData: Fr[],
+    /*
+     * The note hashes from the tx effect
      */
-    public blockNumber: number,
+    public noteHashes: Fr[],
     /*
-     * The log data as either a PrivateLog or PublicLog
+     * The first nullifier from the tx effect. Used for nonce discovery when processing notes from logs.
+     *
+     * (Note nonces are computed as `hash(firstNullifier, noteIndexInTx)`.)
      */
-    public log: PrivateLog | PublicLog,
+    public firstNullifier: Fr,
   ) {}
 
-  get isFromPublic() {
-    return this.log instanceof PublicLog;
-  }
-
   static get schema() {
     return z
       .object({
         txHash: TxHash.schema,
-        dataStartIndexForTx: z.number(),
-        logIndexInTx: z.number(),
-        blockNumber: z.number(),
-        log: z.union([PrivateLog.schema, PublicLog.schema]),
+        blockNumber: BlockNumberSchema,
+        blockTimestamp: schemas.UInt64,
+        logData: z.array(foundationSchemas.Fr),
+        noteHashes: z.array(foundationSchemas.Fr),
+        firstNullifier: foundationSchemas.Fr,
       })
       .transform(
-        ({ txHash, dataStartIndexForTx, logIndexInTx, blockNumber, log }) =>
-          new TxScopedL2Log(txHash, dataStartIndexForTx, logIndexInTx, blockNumber, log),
+        ({ txHash, blockNumber, blockTimestamp, logData, noteHashes, firstNullifier }) =>
+          new TxScopedL2Log(txHash, blockNumber, blockTimestamp, logData, noteHashes, firstNullifier),
       );
   }
 
   toBuffer() {
-    const isFromPublic = this.log instanceof PublicLog;
     return Buffer.concat([
       this.txHash.toBuffer(),
-      numToUInt32BE(this.dataStartIndexForTx),
-      numToUInt32BE(this.logIndexInTx),
       numToUInt32BE(this.blockNumber),
-      boolToBuffer(isFromPublic),
-      this.log.toBuffer(),
+      bigintToUInt64BE(this.blockTimestamp),
+      serializeArrayOfBufferableToVector(this.logData),
+      serializeArrayOfBufferableToVector(this.noteHashes),
+      this.firstNullifier.toBuffer(),
     ]);
   }
 
   static fromBuffer(buffer: Buffer) {
     const reader = BufferReader.asReader(buffer);
     const txHash = reader.readObject(TxHash);
-    const dataStartIndexForTx = reader.readNumber();
-    const logIndexInTx = reader.readNumber();
-    const blockNumber = reader.readNumber();
-    const isFromPublic = reader.readBoolean();
-    const log = isFromPublic ? PublicLog.fromBuffer(reader) : PrivateLog.fromBuffer(reader);
-
-    return new TxScopedL2Log(txHash, dataStartIndexForTx, logIndexInTx, blockNumber, log);
-  }
+    const blockNumber = BlockNumber(reader.readNumber());
+    const blockTimestamp = reader.readUInt64();
+    const logData = reader.readVector(Fr);
+    const noteHashes = reader.readVector(Fr);
+    const firstNullifier = reader.readObject(Fr);
 
-  static async random(isFromPublic = Math.random() < 0.5) {
-    const log = isFromPublic ? await PublicLog.random() : PrivateLog.random();
-    return new TxScopedL2Log(TxHash.random(), 1, 1, 1, log);
+    return new TxScopedL2Log(txHash, blockNumber, blockTimestamp, logData, noteHashes, firstNullifier);
   }
 
   equals(other: TxScopedL2Log) {
     return (
       this.txHash.equals(other.txHash) &&
-      this.dataStartIndexForTx === other.dataStartIndexForTx &&
-      this.logIndexInTx === other.logIndexInTx &&
       this.blockNumber === other.blockNumber &&
-      ((this.log instanceof PublicLog && other.log instanceof PublicLog) ||
-        (this.log instanceof PrivateLog && other.log instanceof PrivateLog)) &&
-      this.log.equals(other.log as any)
+      this.blockTimestamp === other.blockTimestamp &&
+      this.logData.length === other.logData.length &&
+      this.logData.every((f, i) => f.equals(other.logData[i])) &&
+      this.noteHashes.length === other.noteHashes.length &&
+      this.noteHashes.every((h, i) => h.equals(other.noteHashes[i])) &&
+      this.firstNullifier.equals(other.firstNullifier)
     );
   }
 }

package/src/messaging/in_hash.ts

@@ -0,0 +1,12 @@
+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 { computeBalancedShaRoot } from '@aztec/foundation/trees';
+
+/**
+ * Computes the inHash for a checkpoint (or the first block in a checkpoint) given its l1 to l2 messages.
+ */
+export function computeInHashFromL1ToL2Messages(unpaddedL1ToL2Messages: Fr[]): Fr {
+  const l1ToL2Messages = padArrayEnd<Fr, number>(unpaddedL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+  return new Fr(computeBalancedShaRoot(l1ToL2Messages.map(msg => msg.toBuffer())));
+}

package/src/messaging/inbox_leaf.ts

@@ -1,6 +1,7 @@
-import { INITIAL_L2_BLOCK_NUM, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { INITIAL_CHECKPOINT_NUMBER, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
 import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 export class InboxLeaf {
@@ -22,22 +23,22 @@ export class InboxLeaf {
     return new InboxLeaf(index, leaf);
   }
 
-  static smallestIndexFromL2Block(l2blockNumber: number): bigint {
-    return BigInt(l2blockNumber - INITIAL_L2_BLOCK_NUM) * BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+  static smallestIndexForCheckpoint(checkpointNumber: CheckpointNumber): bigint {
+    return BigInt(checkpointNumber - INITIAL_CHECKPOINT_NUMBER) * BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
   }
 
   /**
-   * Returns the range of valid indices for a given L2 block.
+   * Returns the range of valid indices for a given checkpoint.
    * Start index is inclusive, end index is exclusive.
    */
-  static indexRangeFromL2Block(l2blockNumber: number): [bigint, bigint] {
-    const start = this.smallestIndexFromL2Block(l2blockNumber);
+  static indexRangeForCheckpoint(checkpointNumber: CheckpointNumber): [bigint, bigint] {
+    const start = this.smallestIndexForCheckpoint(checkpointNumber);
     const end = start + BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
     return [start, end];
   }
 
-  /** Returns the L2 block number for a given leaf index */
-  static l2BlockFromIndex(index: bigint): number {
-    return Number(index / BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP)) + INITIAL_L2_BLOCK_NUM;
+  /** Returns the checkpoint number for a given leaf index */
+  static checkpointNumberFromIndex(index: bigint): CheckpointNumber {
+    return CheckpointNumber(Number(index / BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP)) + INITIAL_CHECKPOINT_NUMBER);
   }
 }

package/src/messaging/index.ts

@@ -1,3 +1,4 @@
+export * from './in_hash.js';
 export * from './inbox_leaf.js';
 export * from './l1_to_l2_message.js';
 export * from './l1_to_l2_message_source.js';
@@ -5,3 +6,4 @@ export * from './l1_actor.js';
 export * from './l2_actor.js';
 export * from './l2_to_l1_message.js';
 export * from './l2_to_l1_membership.js';
+export * from './out_hash.js';

package/src/messaging/l1_actor.ts

@@ -1,6 +1,6 @@
-import { randomInt } from '@aztec/foundation/crypto';
+import { randomInt } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 /**

package/src/messaging/l1_to_l2_message.ts

@@ -1,6 +1,6 @@
 import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
-import { sha256ToField } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { sha256ToField } from '@aztec/foundation/crypto/sha256';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex } from '@aztec/foundation/string';
 import { SiblingPath } from '@aztec/foundation/trees';
@@ -84,6 +84,7 @@ export async function getNonNullifiedL1ToL2MessageWitness(
   if (!response) {
     throw new Error(`No L1 to L2 message found for message hash ${messageHash.toString()}`);
   }
+
   const [messageIndex, siblingPath] = response;
 
   const messageNullifier = await computeL1ToL2MessageNullifier(contractAddress, messageHash, secret);