@aztec/stdlib 0.86.0-starknet.1 → 0.87.0

package/src/logs/contract_class_log.ts

@@ -1,139 +1,238 @@
-import { CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { CONTRACT_CLASS_LOG_LENGTH, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
 import { poseidon2Hash } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
 import { z } from 'zod';
 
 import { AztecAddress } from '../aztec-address/index.js';
 
-export class ContractClassLog {
-  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * CONTRACT_CLASS_LOG_SIZE_IN_FIELDS;
-  // Keeps original first field pre-siloing. Only set by silo().
-  public unsiloedFirstField?: Fr | undefined;
-
+export class ContractClassLogFields {
   // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
-  // public fields: Tuple<Fr, typeof CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS>
-  constructor(public contractAddress: AztecAddress, public fields: Fr[]) {
-    if (fields.length !== CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS) {
+  // public fields: Tuple<Fr, typeof CONTRACT_CLASS_LOG_SIZE_IN_FIELDS>
+  constructor(public fields: Fr[]) {
+    if (fields.length !== CONTRACT_CLASS_LOG_SIZE_IN_FIELDS) {
       throw new Error(
-        `Invalid number of fields for ContractClassLog. Expected ${CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS}, got ${fields.length}`,
+        `Invalid number of fields for ContractClassLog. Expected ${CONTRACT_CLASS_LOG_SIZE_IN_FIELDS}, got ${fields.length}`,
       );
     }
   }
 
+  static get schema() {
+    return z
+      .object({
+        fields: z.array(schemas.Fr).refine(arr => arr.length === CONTRACT_CLASS_LOG_SIZE_IN_FIELDS),
+      })
+      .transform(({ fields }) => new ContractClassLogFields(fields));
+  }
+
+  toFields(): Fr[] {
+    return this.fields;
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
+    // reader.readFieldArray(CONTRACT_CLASS_LOG_LENGTH);
+    return new ContractClassLogFields(
+      Array.from({ length: CONTRACT_CLASS_LOG_SIZE_IN_FIELDS }, () => reader.readField()),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.fields);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
+    // reader.readArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, Fr)
+    return new ContractClassLogFields(
+      Array.from({ length: CONTRACT_CLASS_LOG_SIZE_IN_FIELDS }, () => reader.readObject(Fr)),
+    );
+  }
+
+  equals(other: ContractClassLogFields) {
+    return this.fields.every((f, i) => f.equals(other.fields[i]));
+  }
+
+  getEmittedFields(emittedLength: number) {
+    return this.fields.slice(0, emittedLength);
+  }
+
+  static fromEmittedFields(emittedFields: Fr[]) {
+    return new ContractClassLogFields(
+      emittedFields.concat(Array(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS - emittedFields.length).fill(Fr.ZERO)),
+    );
+  }
+
+  isEmpty() {
+    return this.fields.every(f => f.isZero());
+  }
+
+  static empty() {
+    return new ContractClassLogFields(Array(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS).fill(Fr.ZERO));
+  }
+
+  static random(emittedLength = CONTRACT_CLASS_LOG_SIZE_IN_FIELDS) {
+    return new ContractClassLogFields(
+      Array.from({ length: emittedLength }, () => Fr.random()).concat(
+        Array(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS - emittedLength).fill(Fr.ZERO),
+      ),
+    );
+  }
+
+  async hash() {
+    return await poseidon2Hash(this.fields);
+  }
+
+  clone() {
+    return ContractClassLogFields.fromBuffer(this.toBuffer());
+  }
+}
+
+export class ContractClassLog {
+  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * CONTRACT_CLASS_LOG_LENGTH;
+  // Keeps original first field pre-siloing. Only set by silo().
+  public unsiloedFirstField?: Fr | undefined;
+
+  constructor(
+    public contractAddress: AztecAddress,
+    public fields: ContractClassLogFields,
+    public emittedLength: number,
+  ) {}
+
+  static from(fields: FieldsOf<ContractClassLog>) {
+    return new ContractClassLog(fields.contractAddress, fields.fields, fields.emittedLength);
+  }
+
   toFields(): Fr[] {
-    return [this.contractAddress.toField(), ...this.fields];
+    return serializeToFields([this.contractAddress, this.fields, this.emittedLength]);
   }
 
   equals(other: ContractClassLog) {
     return (
       this.contractAddress.equals(other.contractAddress) &&
-      this.fields.length === other.fields.length &&
-      this.fields.every((f, i) => f.equals(other.fields[i]))
+      this.fields.equals(other.fields) &&
+      this.emittedLength === other.emittedLength
     );
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
-    // return new ContractClassLog(reader.readFieldArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS));
     return new ContractClassLog(
       reader.readObject(AztecAddress),
-      Array.from({ length: CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS }, () => reader.readField()),
+      reader.readObject(ContractClassLogFields),
+      reader.readU32(),
+    );
+  }
+
+  getEmittedFields() {
+    return this.fields.getEmittedFields(this.emittedLength);
+  }
+
+  toBlobFields(): Fr[] {
+    return [new Fr(this.emittedLength), this.contractAddress.toField()].concat(this.getEmittedFields());
+  }
+
+  static fromBlobFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    const emittedLength = reader.readU32();
+    const contractAddress = reader.readObject(AztecAddress);
+    const emittedFields = reader.readFieldArray(emittedLength);
+    return new ContractClassLog(
+      contractAddress,
+      ContractClassLogFields.fromEmittedFields(emittedFields),
+      emittedLength,
     );
   }
 
   isEmpty() {
-    return this.fields.every(f => f.isZero());
+    return this.contractAddress.isZero() && this.fields.isEmpty() && this.emittedLength === 0;
   }
 
   static empty() {
-    return new ContractClassLog(AztecAddress.ZERO, new Array(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS).fill(Fr.ZERO));
+    return new ContractClassLog(AztecAddress.ZERO, ContractClassLogFields.empty(), 0);
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer([this.contractAddress, this.fields]);
+    return serializeToBuffer([this.contractAddress, this.fields, this.emittedLength]);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
-    // reader.readArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, Fr);
     const address = reader.readObject(AztecAddress);
-    const fields = Array.from({ length: CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS }, () =>
-      reader.remainingBytes() == 0 ? Fr.ZERO : Fr.fromBuffer(reader),
-    );
-    return new ContractClassLog(address, fields);
-  }
-
-  clone() {
-    return ContractClassLog.fromBuffer(this.toBuffer());
+    const fields = ContractClassLogFields.fromBuffer(reader);
+    const emittedLength = reader.readNumber();
+    return new ContractClassLog(address, fields, emittedLength);
   }
 
   static async random() {
     // NB: Using half the maximum number of fields per log because max fields keeps overfilling blobs in tests.
-    // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
-    // makeTuple(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS, Fr.random);
-    const fields = Array.from({ length: Math.ceil(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS / 2) }, () => Fr.random());
+    const emittedLength = Math.ceil(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS / 2);
     return new ContractClassLog(
       await AztecAddress.random(),
-      fields.concat(Array.from({ length: Math.floor(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS / 2) }, () => Fr.ZERO)),
+      ContractClassLogFields.random(emittedLength),
+      emittedLength,
     );
   }
 
-  getEmittedLength() {
-    // This assumes that we cut trailing zeroes from the end of the log. In ts, these will always be added back.
-    // Does not include address or length prefix.
-    // Note: Unlike public logs, address is not included here because it is not included in the log itself.
-    return this.getEmittedFields().length;
-  }
-
-  getEmittedFields() {
-    const lastNonZeroIndex = this.fields.findLastIndex(f => !f.isZero());
-    return this.fields.slice(0, lastNonZeroIndex + 1);
-  }
-
   setUnsiloedFirstField(field: Fr) {
     this.unsiloedFirstField = field;
   }
 
   toUnsiloed() {
+    if (this.contractAddress.isZero()) {
+      return this;
+    }
     if (this.unsiloedFirstField) {
-      return new ContractClassLog(this.contractAddress, [this.unsiloedFirstField].concat(this.fields.slice(1)));
+      return new ContractClassLog(
+        this.contractAddress,
+        new ContractClassLogFields([this.unsiloedFirstField].concat(this.fields.fields.slice(1))),
+        this.emittedLength,
+      );
     } else {
       return this;
     }
   }
 
+  // TODO(#13914): Don't need to silo the contract class logs.
   async silo() {
-    const innerLog = this.clone();
-    if (innerLog.contractAddress.isZero()) {
-      return innerLog;
+    if (this.contractAddress.isZero()) {
+      return this;
     }
-    innerLog.setUnsiloedFirstField(innerLog.fields[0]);
-    innerLog.fields[0] = await poseidon2Hash([innerLog.contractAddress, innerLog.fields[0]]);
-    return innerLog;
+
+    const fields = this.fields.clone();
+    const unsiloedField = fields.fields[0];
+    const siloedField = await poseidon2Hash([this.contractAddress, unsiloedField]);
+    fields.fields[0] = siloedField;
+    const cloned = new ContractClassLog(this.contractAddress, fields, this.emittedLength);
+    cloned.setUnsiloedFirstField(unsiloedField);
+    return cloned;
   }
 
   async hash() {
-    return await poseidon2Hash(this.fields);
+    return await this.fields.hash();
   }
 
   static get schema() {
     return z
       .object({
         contractAddress: AztecAddress.schema,
-        fields: z.array(schemas.Fr),
+        fields: ContractClassLogFields.schema,
+        emittedLength: z.number(),
       })
-      .transform(({ contractAddress, fields }) => ContractClassLog.fromFields([contractAddress.toField(), ...fields]));
+      .transform(ContractClassLog.from);
   }
 
   [inspect.custom](): string {
     return `ContractClassLog {
-      fields: [${this.fields.map((x: Fr) => inspect(x)).join(', ')}],
+      contractAddress: ${this.contractAddress.toString()},
+      emittedLength: ${this.emittedLength},
+      fields: [${this.fields.fields.map((x: Fr) => inspect(x)).join(', ')}],
     }`;
   }
 }

package/src/logs/indexed_tagging_secret.ts

@@ -4,7 +4,10 @@ import { Fr } from '@aztec/foundation/fields';
 import type { AztecAddress } from '../aztec-address/index.js';
 
 export class IndexedTaggingSecret {
-  constructor(public appTaggingSecret: Fr, public index: number) {
+  constructor(
+    public appTaggingSecret: Fr,
+    public index: number,
+  ) {
     if (index < 0) {
       throw new Error('IndexedTaggingSecret index out of bounds');
     }

package/src/logs/log_with_tx_data.ts

@@ -1,4 +1,4 @@
-import { MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS } from '@aztec/constants';
+import { MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { TxHash } from '@aztec/stdlib/tx';
 
@@ -6,6 +6,8 @@ import { TxHash } from '@aztec/stdlib/tx';
 // response for PXE's custom getLogByTag oracle.
 export class LogWithTxData {
   constructor(
+    // The emitted fields of a log.
+    // For public logs, the contract address is prepended to the content.
     public logContent: Fr[],
     public txHash: TxHash,
     public uniqueNoteHashesInTx: Fr[],
@@ -14,7 +16,10 @@ export class LogWithTxData {
 
   toNoirSerialization(): (Fr | Fr[])[] {
     return [
-      ...toBoundedVecSerialization(this.logContent, PUBLIC_LOG_DATA_SIZE_IN_FIELDS),
+      // The log fields length is PUBLIC_LOG_SIZE_IN_FIELDS. + 1 because the contract address is prepended to the content.
+      // This is only used for public logs currently, so the maxLength is PUBLIC_LOG_SIZE_IN_FIELDS + 1.
+      // TODO(#11639): this could also be used for private logs.
+      ...toBoundedVecSerialization(this.logContent, PUBLIC_LOG_SIZE_IN_FIELDS + 1),
       this.txHash.hash,
       ...toBoundedVecSerialization(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
       this.firstNullifierInTx,

package/src/logs/private_log.ts

@@ -1,24 +1,58 @@
-import { PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_LOG_DATA_SIZE_IN_FIELDS } from '@aztec/constants';
-import { makeTuple } from '@aztec/foundation/array';
+import { PRIVATE_LOG_LENGTH, PRIVATE_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 { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import {
+  BufferReader,
+  FieldReader,
+  type Tuple,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
 import { z } from 'zod';
 
 export class PrivateLog {
-  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * PRIVATE_LOG_SIZE_IN_FIELDS;
+  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * PRIVATE_LOG_LENGTH;
 
-  constructor(public fields: Tuple<Fr, typeof PRIVATE_LOG_SIZE_IN_FIELDS>) {}
+  constructor(
+    public fields: Tuple<Fr, typeof PRIVATE_LOG_SIZE_IN_FIELDS>,
+    // Named `emittedLength` instead of `length` to avoid being confused with fields.length.
+    public emittedLength: number,
+  ) {}
+
+  static from(fields: FieldsOf<PrivateLog>) {
+    return new PrivateLog(...PrivateLog.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PrivateLog>) {
+    return [fields.fields, fields.emittedLength] as const;
+  }
 
   toFields(): Fr[] {
-    return this.fields;
+    return serializeToFields(...PrivateLog.getFields(this));
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new PrivateLog(reader.readFieldArray(PRIVATE_LOG_SIZE_IN_FIELDS));
+    return new PrivateLog(reader.readFieldArray(PRIVATE_LOG_SIZE_IN_FIELDS), reader.readU32());
+  }
+
+  getEmittedFields() {
+    return this.fields.slice(0, this.emittedLength);
+  }
+
+  toBlobFields(): Fr[] {
+    return [new Fr(this.emittedLength)].concat(this.getEmittedFields());
+  }
+
+  static fromBlobFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    const emittedLength = reader.readU32();
+    const emittedFields = reader.readFieldArray(emittedLength);
+    return new PrivateLog(padArrayEnd(emittedFields, Fr.ZERO, PRIVATE_LOG_SIZE_IN_FIELDS), emittedLength);
   }
 
   isEmpty() {
@@ -26,54 +60,42 @@ export class PrivateLog {
   }
 
   static empty() {
-    return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.zero));
+    return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.zero), 0);
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer(this.fields);
+    return serializeToBuffer(this.fields, this.emittedLength);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new PrivateLog(reader.readArray(PRIVATE_LOG_SIZE_IN_FIELDS, Fr));
+    return new PrivateLog(reader.readArray(PRIVATE_LOG_SIZE_IN_FIELDS, Fr), reader.readNumber());
   }
 
   static random(tag = Fr.random()) {
-    return PrivateLog.fromFields([tag, ...Array.from({ length: PRIVATE_LOG_SIZE_IN_FIELDS - 1 }, () => Fr.random())]);
-  }
-
-  getEmittedLength() {
-    // This assumes that we cut trailing zeroes from the end of the log. In ts, these will always be added back.
-    // Does not include length prefix.
-    return this.getEmittedFields().length;
-  }
-
-  getEmittedFields() {
-    const lastNonZeroIndex = this.fields.findLastIndex(f => !f.isZero());
-    return this.fields.slice(0, lastNonZeroIndex + 1);
+    const fields = makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.random);
+    fields[0] = tag;
+    return new PrivateLog(fields, PRIVATE_LOG_SIZE_IN_FIELDS);
   }
 
   static get schema() {
-    if (PUBLIC_LOG_DATA_SIZE_IN_FIELDS + 1 == PRIVATE_LOG_SIZE_IN_FIELDS) {
-      throw new Error(
-        'Constants got updated and schema for PublicLog matches that of PrivateLog. This needs to be updated now as Zod is no longer able to differentiate the 2 in TxScopedL2Log.',
-      );
-    }
-
     return z
       .object({
         fields: z.array(schemas.Fr),
+        emittedLength: z.number(),
       })
-      .transform(({ fields }) => PrivateLog.fromFields(fields));
+      .strict()
+      .transform(({ fields, emittedLength }) => PrivateLog.fromFields(fields.concat(new Fr(emittedLength))));
   }
 
   equals(other: PrivateLog) {
-    return this.fields.every((field, i) => field.equals(other.fields[i]));
+    return this.fields.every((field, i) => field.equals(other.fields[i])) && this.emittedLength === other.emittedLength;
   }
 
   [inspect.custom](): string {
     return `PrivateLog {
       fields: [${this.fields.map(x => inspect(x)).join(', ')}],
+      emittedLength: ${this.emittedLength},
     }`;
   }
 }

package/src/logs/public_log.ts

@@ -1,9 +1,6 @@
-import {
-  PRIVATE_LOG_SIZE_IN_FIELDS,
-  PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
-  PUBLIC_LOG_SIZE_IN_FIELDS,
-} from '@aztec/constants';
+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 { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import {
@@ -20,29 +17,61 @@ import { z } from 'zod';
 import { AztecAddress } from '../aztec-address/index.js';
 
 export class PublicLog {
-  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * PUBLIC_LOG_SIZE_IN_FIELDS;
+  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * PUBLIC_LOG_LENGTH;
 
-  constructor(public contractAddress: AztecAddress, public log: Tuple<Fr, typeof PUBLIC_LOG_DATA_SIZE_IN_FIELDS>) {}
+  constructor(
+    public contractAddress: AztecAddress,
+    public fields: Tuple<Fr, typeof PUBLIC_LOG_SIZE_IN_FIELDS>,
+    public emittedLength: number,
+  ) {}
 
-  toFields(): Fr[] {
-    return serializeToFields(...PublicLog.getFields(this));
+  static from(fields: FieldsOf<PublicLog>) {
+    return new PublicLog(...PublicLog.getFields(fields));
   }
 
   static getFields(fields: FieldsOf<PublicLog>) {
-    return [fields.contractAddress, fields.log] as const;
+    return [fields.contractAddress, fields.fields, fields.emittedLength] as const;
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(...PublicLog.getFields(this));
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new PublicLog(reader.readObject(AztecAddress), reader.readFieldArray(PUBLIC_LOG_DATA_SIZE_IN_FIELDS));
+    return new PublicLog(
+      reader.readObject(AztecAddress),
+      reader.readFieldArray(PUBLIC_LOG_SIZE_IN_FIELDS),
+      reader.readU32(),
+    );
+  }
+
+  getEmittedFields() {
+    return this.fields.slice(0, this.emittedLength);
+  }
+
+  toBlobFields(): Fr[] {
+    return [new Fr(this.emittedLength), this.contractAddress.toField()].concat(this.getEmittedFields());
+  }
+
+  static fromBlobFields(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,
+    );
   }
 
   isEmpty() {
-    return this.contractAddress.isZero() && this.log.every(f => f.isZero());
+    return this.contractAddress.isZero() && this.fields.every(f => f.isZero()) && this.emittedLength === 0;
   }
 
   static empty() {
-    return new PublicLog(AztecAddress.ZERO, makeTuple(PUBLIC_LOG_DATA_SIZE_IN_FIELDS, Fr.zero));
+    return new PublicLog(AztecAddress.ZERO, makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, Fr.zero), 0);
   }
 
   toBuffer(): Buffer {
@@ -51,55 +80,50 @@ export class PublicLog {
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new PublicLog(reader.readObject(AztecAddress), reader.readArray(PUBLIC_LOG_DATA_SIZE_IN_FIELDS, Fr));
+    return new PublicLog(
+      reader.readObject(AztecAddress),
+      reader.readArray(PUBLIC_LOG_SIZE_IN_FIELDS, Fr),
+      reader.readNumber(),
+    );
   }
 
   static async random() {
-    return new PublicLog(await AztecAddress.random(), makeTuple(PUBLIC_LOG_DATA_SIZE_IN_FIELDS, Fr.random));
-  }
-
-  getEmittedLength() {
-    // This assumes that we cut trailing zeroes from the end of the log. In ts, these will always be added back.
-    // Does not include length prefix.
-    return this.getEmittedFields().length;
-  }
-
-  getEmittedFields() {
-    const fields = this.toFields();
-    const lastNonZeroIndex = fields.findLastIndex(f => !f.isZero());
-    return fields.slice(0, lastNonZeroIndex + 1);
+    return new PublicLog(
+      await AztecAddress.random(),
+      makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, Fr.random),
+      PUBLIC_LOG_SIZE_IN_FIELDS,
+    );
   }
 
   equals(other: this) {
     return (
       this.contractAddress.equals(other.contractAddress) &&
-      this.log.reduce((acc, field, i) => acc && field.equals(other.log[i]), true)
+      this.fields.every((field, i) => field.equals(other.fields[i])) &&
+      this.emittedLength === other.emittedLength
     );
   }
 
   toHumanReadable(): string {
-    return `PublicLog: (contractAddress: ${this.contractAddress} log: ${this.log})`;
+    return `PublicLog: (contractAddress: ${this.contractAddress} fields: ${this.fields}) emittedLength: ${this.emittedLength}`;
   }
 
   static get schema(): ZodFor<PublicLog> {
-    if (PUBLIC_LOG_DATA_SIZE_IN_FIELDS + 1 == PRIVATE_LOG_SIZE_IN_FIELDS) {
-      throw new Error(
-        'Constants got updated and schema for PrivateLog matches that of PublicLog. This needs to be updated now as Zod is no longer able to differentiate the 2 in TxScopedL2Log.',
-      );
-    }
-
     return z
       .object({
         contractAddress: AztecAddress.schema,
-        log: z.array(schemas.Fr),
+        fields: z.array(schemas.Fr).refine(arr => arr.length === PUBLIC_LOG_SIZE_IN_FIELDS),
+        emittedLength: z.number(),
       })
-      .transform(({ contractAddress, log }) => PublicLog.fromFields([contractAddress.toField(), ...log]));
+      .transform(({ contractAddress, fields, emittedLength }) =>
+        PublicLog.fromFields([contractAddress.toField(), ...fields, new Fr(emittedLength)]),
+      );
   }
 
   [inspect.custom](): string {
     return `PublicLog {
       contractAddress: ${inspect(this.contractAddress)},
-      log: [${this.log.map(x => inspect(x)).join(', ')}],
+      fields: [${this.fields.map(x => inspect(x)).join(', ')}],
+      emittedLength: ${this.emittedLength},
     }`;
   }
 }

package/src/logs/tx_scoped_l2_log.ts

@@ -75,8 +75,7 @@ export class TxScopedL2Log {
     return new TxScopedL2Log(txHash, dataStartIndexForTx, logIndexInTx, blockNumber, log);
   }
 
-  static async random() {
-    const isFromPublic = Math.random() < 0.5;
+  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);
   }

package/src/messaging/inbox_leaf.ts

@@ -25,4 +25,14 @@ export class InboxLeaf {
   static smallestIndexFromL2Block(l2block: bigint): bigint {
     return (l2block - BigInt(INITIAL_L2_BLOCK_NUM)) * BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
   }
+
+  /**
+   * Returns the range of valid indices for a given L2 block.
+   * Start index is inclusive, end index is exclusive.
+   */
+  static indexRangeFromL2Block(l2block: bigint): [bigint, bigint] {
+    const start = this.smallestIndexFromL2Block(l2block);
+    const end = start + BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+    return [start, end];
+  }
 }

package/src/messaging/l2_to_l1_message.ts

@@ -10,7 +10,11 @@ import { z } from 'zod';
 import { AztecAddress } from '../aztec-address/index.js';
 
 export class L2ToL1Message {
-  constructor(public recipient: EthAddress, public content: Fr, public counter: number) {}
+  constructor(
+    public recipient: EthAddress,
+    public content: Fr,
+    public counter: number,
+  ) {}
 
   static get schema() {
     return z
@@ -97,7 +101,10 @@ export class L2ToL1Message {
 }
 
 export class ScopedL2ToL1Message {
-  constructor(public message: L2ToL1Message, public contractAddress: AztecAddress) {}
+  constructor(
+    public message: L2ToL1Message,
+    public contractAddress: AztecAddress,
+  ) {}
 
   static get schema() {
     return z