@aztec/stdlib 3.0.0-nightly.20250919 → 3.0.0-nightly.20250921

package/src/avm/avm_accumulated_data.ts

@@ -3,7 +3,6 @@ import {
   MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
-  MAX_PUBLIC_LOGS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
 } from '@aztec/constants';
 import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
@@ -23,7 +22,7 @@ import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import { inspect } from 'util';
 import { z } from 'zod';
 
-import { PublicLog } from '../logs/public_log.js';
+import { FlatPublicLogs } from '../logs/public_log.js';
 import { ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
 import { PublicDataWrite } from './public_data_write.js';
 
@@ -44,7 +43,7 @@ export class AvmAccumulatedData {
     /**
      * The public logs emitted from the AVM execution.
      */
-    public publicLogs: Tuple<PublicLog, typeof MAX_PUBLIC_LOGS_PER_TX>,
+    public publicLogs: FlatPublicLogs,
     /**
      * The public data writes made in the AVM execution.
      */
@@ -57,7 +56,7 @@ export class AvmAccumulatedData {
         noteHashes: schemas.Fr.array().min(MAX_NOTE_HASHES_PER_TX).max(MAX_NOTE_HASHES_PER_TX),
         nullifiers: schemas.Fr.array().min(MAX_NULLIFIERS_PER_TX).max(MAX_NULLIFIERS_PER_TX),
         l2ToL1Msgs: ScopedL2ToL1Message.schema.array().min(MAX_L2_TO_L1_MSGS_PER_TX).max(MAX_L2_TO_L1_MSGS_PER_TX),
-        publicLogs: PublicLog.schema.array().min(MAX_PUBLIC_LOGS_PER_TX).max(MAX_PUBLIC_LOGS_PER_TX),
+        publicLogs: FlatPublicLogs.schema,
         publicDataWrites: PublicDataWrite.schema
           .array()
           .min(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX)
@@ -69,7 +68,7 @@ export class AvmAccumulatedData {
             assertLength(noteHashes, MAX_NOTE_HASHES_PER_TX),
             assertLength(nullifiers, MAX_NULLIFIERS_PER_TX),
             assertLength(l2ToL1Msgs, MAX_L2_TO_L1_MSGS_PER_TX),
-            assertLength(publicLogs, MAX_PUBLIC_LOGS_PER_TX),
+            publicLogs,
             assertLength(publicDataWrites, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX),
           ),
       );
@@ -80,7 +79,7 @@ export class AvmAccumulatedData {
       arraySerializedSizeOfNonEmpty(this.noteHashes) +
       arraySerializedSizeOfNonEmpty(this.nullifiers) +
       arraySerializedSizeOfNonEmpty(this.l2ToL1Msgs) +
-      arraySerializedSizeOfNonEmpty(this.publicLogs) +
+      this.publicLogs.toBuffer().length +
       arraySerializedSizeOfNonEmpty(this.publicDataWrites)
     );
   }
@@ -91,7 +90,7 @@ export class AvmAccumulatedData {
       reader.readArray(MAX_NOTE_HASHES_PER_TX, Fr),
       reader.readArray(MAX_NULLIFIERS_PER_TX, Fr),
       reader.readArray(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
-      reader.readArray(MAX_PUBLIC_LOGS_PER_TX, PublicLog),
+      reader.readObject(FlatPublicLogs),
       reader.readArray(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PublicDataWrite),
     );
   }
@@ -116,7 +115,7 @@ export class AvmAccumulatedData {
       reader.readFieldArray(MAX_NOTE_HASHES_PER_TX),
       reader.readFieldArray(MAX_NULLIFIERS_PER_TX),
       reader.readArray(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message),
-      reader.readArray(MAX_PUBLIC_LOGS_PER_TX, PublicLog),
+      reader.readObject(FlatPublicLogs),
       reader.readArray(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PublicDataWrite),
     );
   }
@@ -144,7 +143,7 @@ export class AvmAccumulatedData {
       makeTuple(MAX_NOTE_HASHES_PER_TX, Fr.zero),
       makeTuple(MAX_NULLIFIERS_PER_TX, Fr.zero),
       makeTuple(MAX_L2_TO_L1_MSGS_PER_TX, ScopedL2ToL1Message.empty),
-      makeTuple(MAX_PUBLIC_LOGS_PER_TX, PublicLog.empty),
+      FlatPublicLogs.empty(),
       makeTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, PublicDataWrite.empty),
     );
   }
@@ -154,7 +153,7 @@ export class AvmAccumulatedData {
       this.noteHashes.every(x => x.isZero()) &&
       this.nullifiers.every(x => x.isZero()) &&
       this.l2ToL1Msgs.every(x => x.isEmpty()) &&
-      this.publicLogs.every(x => x.isEmpty()) &&
+      this.publicLogs.isEmpty() &&
       this.publicDataWrites.every(x => x.isEmpty())
     );
   }
@@ -175,6 +174,7 @@ export class AvmAccumulatedData {
     .map(h => inspect(h))
     .join(', ')}],
   publicLogs: [${this.publicLogs
+    .toLogs()
     .filter(x => !x.isEmpty())
     .map(h => inspect(h))
     .join(', ')}],
@@ -203,10 +203,6 @@ export class AvmAccumulatedDataArrayLengths {
      * Number of L2 to L1 messages
      */
     public l2ToL1Msgs: number,
-    /**
-     * Number of public logs
-     */
-    public publicLogs: number,
     /**
      * Number of public data writes
      */
@@ -219,12 +215,11 @@ export class AvmAccumulatedDataArrayLengths {
         noteHashes: z.number(),
         nullifiers: z.number(),
         l2ToL1Msgs: z.number(),
-        publicLogs: z.number(),
         publicDataWrites: z.number(),
       })
       .transform(
-        ({ noteHashes, nullifiers, l2ToL1Msgs, publicLogs, publicDataWrites }) =>
-          new AvmAccumulatedDataArrayLengths(noteHashes, nullifiers, l2ToL1Msgs, publicLogs, publicDataWrites),
+        ({ noteHashes, nullifiers, l2ToL1Msgs, publicDataWrites }) =>
+          new AvmAccumulatedDataArrayLengths(noteHashes, nullifiers, l2ToL1Msgs, publicDataWrites),
       );
   }
 
@@ -235,12 +230,11 @@ export class AvmAccumulatedDataArrayLengths {
       reader.readNumber(),
       reader.readNumber(),
       reader.readNumber(),
-      reader.readNumber(),
     );
   }
 
   toBuffer() {
-    return serializeToBuffer(this.noteHashes, this.nullifiers, this.l2ToL1Msgs, this.publicLogs, this.publicDataWrites);
+    return serializeToBuffer(this.noteHashes, this.nullifiers, this.l2ToL1Msgs, this.publicDataWrites);
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
@@ -250,22 +244,15 @@ export class AvmAccumulatedDataArrayLengths {
       Number(reader.readField()),
       Number(reader.readField()),
       Number(reader.readField()),
-      Number(reader.readField()),
     );
   }
 
   toFields(): Fr[] {
-    return [
-      new Fr(this.noteHashes),
-      new Fr(this.nullifiers),
-      new Fr(this.l2ToL1Msgs),
-      new Fr(this.publicLogs),
-      new Fr(this.publicDataWrites),
-    ];
+    return [new Fr(this.noteHashes), new Fr(this.nullifiers), new Fr(this.l2ToL1Msgs), new Fr(this.publicDataWrites)];
   }
 
   static empty() {
-    return new AvmAccumulatedDataArrayLengths(0, 0, 0, 0, 0);
+    return new AvmAccumulatedDataArrayLengths(0, 0, 0, 0);
   }
 
   [inspect.custom]() {
@@ -273,7 +260,6 @@ export class AvmAccumulatedDataArrayLengths {
   noteHashes: ${this.noteHashes},
   nullifiers: ${this.nullifiers},
   l2ToL1Msgs: ${this.l2ToL1Msgs},
-  publicLogs: ${this.publicLogs},
   publicDataWrites: ${this.publicDataWrites},
 }`;
   }

package/src/interfaces/epoch-prover.ts

@@ -15,19 +15,18 @@ export interface EpochProver extends Omit<IBlockFactory, 'setBlockCompleted' | '
   /**
    * Starts a new epoch. Must be the first method to be called.
    * @param epochNumber - The epoch number.
-   * @param firstCheckpointNumber - The number of the first checkpoint in the epoch. Used to determine the correct order when checkpoints are added.
    * @param totalNumCheckpoints - The total number of checkpoints expected in the epoch (must be at least one).
    * @param finalBlobBatchingChallenges - The final blob batching challenges for the epoch.
    **/
   startNewEpoch(
     epochNumber: number,
-    firstCheckpointNumber: Fr,
     totalNumCheckpoints: number,
     finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
   ): void;
 
   /**
    * Starts a new checkpoint.
+   * @param checkpointIndex - The index of the checkpoint in the epoch.
    * @param constants - The constants for this checkpoint.
    * @param l1ToL2Messages - The set of L1 to L2 messages to be included in this checkpoint.
    * @param totalNumBlocks - The total number of blocks expected in the checkpoint (must be at least one).
@@ -35,6 +34,7 @@ export interface EpochProver extends Omit<IBlockFactory, 'setBlockCompleted' | '
    * @param headerOfLastBlockInPreviousCheckpoint - The header of the last block in the previous checkpoint.
    */
   startNewCheckpoint(
+    checkpointIndex: number,
     constants: CheckpointConstantData,
     l1ToL2Messages: Fr[],
     totalNumBlocks: number,

package/src/interfaces/pxe.ts

@@ -13,25 +13,14 @@ import {
   ContractClassWithIdSchema,
   type ContractInstanceWithAddress,
   ContractInstanceWithAddressSchema,
-  type NodeInfo,
-  NodeInfoSchema,
   type PartialAddress,
   type ProtocolContractAddresses,
   ProtocolContractAddressesSchema,
 } from '../contract/index.js';
-import { GasFees } from '../gas/gas_fees.js';
 import { UniqueNote } from '../note/extended_note.js';
 import { type NotesFilter, NotesFilterSchema } from '../note/notes_filter.js';
 import { AbiDecodedSchema, optional, schemas } from '../schemas/schemas.js';
-import {
-  PrivateExecutionResult,
-  SimulationOverrides,
-  Tx,
-  TxExecutionRequest,
-  TxHash,
-  TxReceipt,
-  TxSimulationResult,
-} from '../tx/index.js';
+import { PrivateExecutionResult, SimulationOverrides, TxExecutionRequest, TxSimulationResult } from '../tx/index.js';
 import { TxProfileResult, UtilitySimulationResult } from '../tx/profiling.js';
 import { TxProvingResult } from '../tx/proven_tx.js';
 
@@ -176,23 +165,6 @@ export interface PXE {
     msgSender?: AztecAddress,
   ): Promise<TxProfileResult>;
 
-  /**
-   * Sends a transaction to an Aztec node to be broadcasted to the network and mined.
-   * @param tx - The transaction as created via `proveTx`.
-   * @returns A hash of the transaction, used to identify it.
-   */
-  sendTx(tx: Tx): Promise<TxHash>;
-
-  /**
-   * Fetches a transaction receipt for a given transaction hash. Returns a mined receipt if it was added
-   * to the chain, a pending receipt if it's still in the mempool of the connected Aztec node, or a dropped
-   * receipt if not found in the connected Aztec node.
-   *
-   * @param txHash - The transaction hash.
-   * @returns A receipt of the transaction.
-   */
-  getTxReceipt(txHash: TxHash): Promise<TxReceipt>;
-
   /**
    * Gets notes registered in this PXE based on the provided filter.
    * @param filter - The filter to apply to the notes.
@@ -200,12 +172,6 @@ export interface PXE {
    */
   getNotes(filter: NotesFilter): Promise<UniqueNote[]>;
 
-  /**
-   * Method to fetch the current base fees.
-   * @returns The current base fees.
-   */
-  getCurrentBaseFees(): Promise<GasFees>;
-
   /**
    * Simulate the execution of a contract utility function.
    *
@@ -227,13 +193,6 @@ export interface PXE {
     scopes?: AztecAddress[],
   ): Promise<UtilitySimulationResult>;
 
-  /**
-   * Returns the information about the server's node. Includes current Node version, compatible Noir version,
-   * L1 chain identifier, rollup version, and L1 address of the rollup contract.
-   * @returns - The node information.
-   */
-  getNodeInfo(): Promise<NodeInfo>;
-
   /**
    * Returns information about this PXE.
    */
@@ -379,10 +338,7 @@ export const PXESchema: ApiSchemaFor<PXE> = {
       optional(z.array(schemas.AztecAddress)),
     )
     .returns(TxSimulationResult.schema),
-  sendTx: z.function().args(Tx.schema).returns(TxHash.schema),
-  getTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema),
   getNotes: z.function().args(NotesFilterSchema).returns(z.array(UniqueNote.schema)),
-  getCurrentBaseFees: z.function().returns(GasFees.schema),
 
   simulateUtility: z
     .function()
@@ -395,7 +351,6 @@ export const PXESchema: ApiSchemaFor<PXE> = {
       optional(z.array(schemas.AztecAddress)),
     )
     .returns(UtilitySimulationResult.schema),
-  getNodeInfo: z.function().returns(NodeInfoSchema),
   getPXEInfo: z.function().returns(PXEInfoSchema),
   getContractMetadata: z.function().args(schemas.AztecAddress).returns(ContractMetadataSchema),
   getContractClassMetadata: z.function().args(schemas.Fr, optional(z.boolean())).returns(ContractClassMetadataSchema),

package/src/logs/log_with_tx_data.ts

@@ -1,44 +1,34 @@
-import { MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_CIPHERTEXT_LEN, PUBLIC_LOG_PLAINTEXT_LEN } from '@aztec/constants';
+import { MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_CIPHERTEXT_LEN } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { TxHash } from '@aztec/stdlib/tx';
 
-// TypeScript representation of the Noir aztec::oracle::message_processing::LogWithTxData<N> struct. This is used as a
-// response for PXE's custom getPublicLogByTag and getPrivateLogByTag oracles.
-class LogWithTxData<N extends number> {
+// This is used as a response for PXE's custom getPublicLogByTag oracle.
+export class PublicLogWithTxData {
+  constructor(
+    public logPayload: Fr[],
+    public txHash: TxHash,
+    public uniqueNoteHashesInTx: Fr[],
+    public firstNullifierInTx: Fr,
+  ) {}
+}
+
+// This is used as a response for PXE's custom getPrivateLogByTag oracle.
+export class PrivateLogWithTxData {
   constructor(
     public logPayload: Fr[],
     public txHash: TxHash,
     public uniqueNoteHashesInTx: Fr[],
     public firstNullifierInTx: Fr,
-    private maxLogContentLength: N,
   ) {}
 
   toNoirSerialization(): (Fr | Fr[])[] {
     return [
-      ...toBoundedVecSerialization(this.logPayload, this.maxLogContentLength),
+      ...toBoundedVecSerialization(this.logPayload, PRIVATE_LOG_CIPHERTEXT_LEN),
       this.txHash.hash,
       ...toBoundedVecSerialization(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
       this.firstNullifierInTx,
     ];
   }
-}
-
-// This is used as a response for PXE's custom getPublicLogByTag oracle.
-export class PublicLogWithTxData extends LogWithTxData<typeof PUBLIC_LOG_PLAINTEXT_LEN> {
-  constructor(logContent: Fr[], txHash: TxHash, uniqueNoteHashesInTx: Fr[], firstNullifierInTx: Fr) {
-    super(logContent, txHash, uniqueNoteHashesInTx, firstNullifierInTx, PUBLIC_LOG_PLAINTEXT_LEN);
-  }
-
-  static noirSerializationOfEmpty(): (Fr | Fr[])[] {
-    return new PublicLogWithTxData([], TxHash.zero(), [], new Fr(0)).toNoirSerialization();
-  }
-}
-
-// This is used as a response for PXE's custom getPrivateLogByTag oracle.
-export class PrivateLogWithTxData extends LogWithTxData<typeof PRIVATE_LOG_CIPHERTEXT_LEN> {
-  constructor(logContent: Fr[], txHash: TxHash, uniqueNoteHashesInTx: Fr[], firstNullifierInTx: Fr) {
-    super(logContent, txHash, uniqueNoteHashesInTx, firstNullifierInTx, PRIVATE_LOG_CIPHERTEXT_LEN);
-  }
 
   static noirSerializationOfEmpty(): (Fr | Fr[])[] {
     return new PrivateLogWithTxData([], TxHash.zero(), [], new Fr(0)).toNoirSerialization();

package/src/logs/public_log.ts

@@ -1,28 +1,113 @@
-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 { FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH, PUBLIC_LOG_HEADER_LENGTH } from '@aztec/constants';
+import type { FieldsOf } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/fields';
 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 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');
+    }
+  }
+
+  private static fromUnpaddedPayload(payload: Fr[]) {
+    const length = payload.length;
+    return new FlatPublicLogs(length, [...payload, ...Array(FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH - length).fill(Fr.ZERO)]);
+  }
+
+  // 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 [new Fr(this.length), ...this.payload];
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    // 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));
+  }
+
+  isEmpty() {
+    return this.length === 0;
+  }
+}
+
+export class PublicLog {
   constructor(
     public contractAddress: AztecAddress,
-    public fields: Tuple<Fr, typeof PUBLIC_LOG_SIZE_IN_FIELDS>,
-    public emittedLength: number,
+    public fields: Fr[],
   ) {}
 
   static from(fields: FieldsOf<PublicLog>) {
@@ -30,104 +115,81 @@ export class PublicLog {
   }
 
   static getFields(fields: FieldsOf<PublicLog>) {
-    return [fields.contractAddress, fields.fields, fields.emittedLength] as const;
+    return [fields.contractAddress, fields.fields] as const;
   }
 
   toFields(): Fr[] {
-    return serializeToFields(...PublicLog.getFields(this));
+    return [new Fr(this.fields.length), this.contractAddress.toField(), ...this.fields];
   }
 
   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(),
-    );
+    const fieldsLength = reader.readU32();
+    return new PublicLog(reader.readObject(AztecAddress), reader.readFieldArray(fieldsLength));
   }
 
-  getEmittedFields() {
-    return this.fields.slice(0, this.emittedLength);
-  }
-
-  getEmittedFieldsWithoutTag() {
-    return this.fields.slice(1, this.emittedLength);
+  sizeInFields() {
+    return this.fields.length + PUBLIC_LOG_HEADER_LENGTH;
   }
 
-  toBlobFields(): Fr[] {
-    return [new Fr(this.emittedLength), this.contractAddress.toField()].concat(this.getEmittedFields());
+  getEmittedFields() {
+    return this.fields.slice(0);
   }
 
-  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,
-    );
+  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);
-    return new PublicLog(
-      reader.readObject(AztecAddress),
-      reader.readArray(PUBLIC_LOG_SIZE_IN_FIELDS, Fr),
-      reader.readNumber(),
-    );
+    const fieldsLength = reader.readNumber();
+    return new PublicLog(reader.readObject(AztecAddress), reader.readArray(fieldsLength, Fr));
   }
 
   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/tests/factories.ts

@@ -27,7 +27,6 @@ import {
   MAX_PRIVATE_LOGS_PER_TX,
   MAX_PROTOCOL_CONTRACTS,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  MAX_PUBLIC_LOGS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH,
@@ -38,7 +37,6 @@ import {
   NUM_MSGS_PER_BASE_PARITY,
   PRIVATE_LOG_SIZE_IN_FIELDS,
   PUBLIC_DATA_TREE_HEIGHT,
-  PUBLIC_LOG_SIZE_IN_FIELDS,
   RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   VK_TREE_HEIGHT,
 } from '@aztec/constants';
@@ -124,7 +122,7 @@ import {
 import { PublicKeys, computeAddress } from '../keys/index.js';
 import { ContractClassLogFields } from '../logs/index.js';
 import { PrivateLog } from '../logs/private_log.js';
-import { PublicLog } from '../logs/public_log.js';
+import { FlatPublicLogs, PublicLog } from '../logs/public_log.js';
 import { CountedL2ToL1Message, L2ToL1Message, ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
 import { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js';
 import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
@@ -210,8 +208,7 @@ function makePrivateLogData(seed: number) {
 function makePublicLog(seed: number) {
   return new PublicLog(
     makeAztecAddress(seed),
-    makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, fr, seed + 1),
-    PUBLIC_LOG_SIZE_IN_FIELDS,
+    new Array(10).fill(null).map((_, i) => new Fr(seed + i)),
   );
 }
 
@@ -351,13 +348,13 @@ function makeAvmAccumulatedData(seed = 1) {
     makeTuple(MAX_NOTE_HASHES_PER_TX, fr, seed),
     makeTuple(MAX_NULLIFIERS_PER_TX, fr, seed + 0x100),
     makeTuple(MAX_L2_TO_L1_MSGS_PER_TX, makeScopedL2ToL1Message, seed + 0x200),
-    makeTuple(MAX_PUBLIC_LOGS_PER_TX, makePublicLog, seed + 0x300),
+    FlatPublicLogs.fromLogs(new Array(20).fill(null).map((_, i) => makePublicLog(seed + i * 256))),
     makeTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, makePublicDataWrite, seed + 0x400),
   );
 }
 
 function makeAvmAccumulatedDataArrayLengths(seed = 1) {
-  return new AvmAccumulatedDataArrayLengths(seed, seed + 1, seed + 2, seed + 3, seed + 4);
+  return new AvmAccumulatedDataArrayLengths(seed, seed + 1, seed + 2, seed + 3);
 }
 
 export function makeGas(seed = 1) {

package/src/tx/processed_tx.ts

@@ -175,7 +175,7 @@ export function makeProcessedTxFromTxWithPublicCalls(
       ),
     publicDataWrites,
     privateLogs,
-    avmPublicInputs.accumulatedData.publicLogs.filter(l => !l.isEmpty()),
+    avmPublicInputs.accumulatedData.publicLogs.toLogs(),
     contractClassLogs,
   );