@aztec-labs/stdlib 6.0.0-nightly.20260829

package/src/logs/log_result.ts

@@ -0,0 +1,103 @@
+import { BlockNumber, BlockNumberSchema } from '@aztec-labs/foundation/branded-types';
+import { times } from '@aztec-labs/foundation/collection';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { schemas as foundationSchemas } from '@aztec-labs/foundation/schemas';
+import type { PickIfFlag, Prettify } from '@aztec-labs/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,137 @@
+import { BlockNumberSchema } from '@aztec-labs/foundation/branded-types';
+import type { BlockNumber } from '@aztec-labs/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. The call throws if that block is no longer
+   * present. Results are capped at that block, and `toBlock` can only narrow the range further, never past it.
+   */
+  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

@@ -0,0 +1,18 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+
+import type { TxHash } from '../tx/tx_hash.js';
+
+/**
+ * Additional information needed to process a message.
+ *
+ * All messages exist in the context of a transaction, and information about that transaction is typically required
+ * in order to perform validation, store results, etc. For example, messages containing notes require knowledge of note
+ * hashes and the first nullifier in order to find the note's nonce.
+ *
+ * A TS version of `message_context.nr`.
+ */
+export type MessageContext = {
+  txHash: TxHash;
+  uniqueNoteHashesInTx: Fr[];
+  firstNullifierInTx: Fr;
+};

package/src/logs/pending_tagged_log.ts

@@ -0,0 +1,12 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+
+import type { MessageContext } from './message_context.js';
+
+/**
+ * Represents a pending tagged log as it is stored in the pending tagged log array to which the fetchTaggedLogs oracle
+ * inserts found private logs. A TS version of `pending_tagged_log.nr`.
+ */
+export type PendingTaggedLog = {
+  log: Fr[];
+  context: MessageContext;
+};

package/src/logs/pre_tag.ts

@@ -0,0 +1,21 @@
+import { schemas } from '@aztec-labs/foundation/schemas';
+import { z } from 'zod';
+
+import { type AppTaggingSecret, AppTaggingSecretSchema } from './app_tagging_secret.js';
+
+/**
+ * Represents a preimage of a private log tag (see `Tag` in `pxe/src/tagging`).
+ *
+ * Note: It's a bit unfortunate that this type resides in `stdlib` as the rest of the tagging functionality resides
+ * in `pxe/src/tagging`. But this type is used by other types in stdlib hence there doesn't seem to be a good way
+ * around this.
+ */
+export type PreTag = {
+  extendedSecret: AppTaggingSecret;
+  index: number;
+};
+
+export const PreTagSchema = z.object({
+  extendedSecret: AppTaggingSecretSchema,
+  index: schemas.Integer,
+});

package/src/logs/private_log.ts

@@ -0,0 +1,127 @@
+import { PRIVATE_LOG_LENGTH, PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec-labs/constants';
+import { type FieldsOf, makeTuple } from '@aztec-labs/foundation/array';
+import { padArrayEnd } from '@aztec-labs/foundation/collection';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { schemas } from '@aztec-labs/foundation/schemas';
+import {
+  BufferReader,
+  BufferSink,
+  FieldReader,
+  type Tuple,
+  serializeToFields,
+  serializeToSink,
+} from '@aztec-labs/foundation/serialize';
+import { inspect } from 'util';
+import { z } from 'zod';
+
+export class PrivateLog {
+  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * PRIVATE_LOG_LENGTH;
+
+  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 serializeToFields(...PrivateLog.getFields(this));
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    return new PrivateLog(reader.readFieldArray(PRIVATE_LOG_SIZE_IN_FIELDS), reader.readU32());
+  }
+
+  getEmittedFields() {
+    return this.fields.slice(0, this.emittedLength);
+  }
+
+  getEmittedFieldsWithoutTag() {
+    return this.fields.slice(1, this.emittedLength);
+  }
+
+  toBlobFields(): Fr[] {
+    return this.getEmittedFields();
+  }
+
+  static fromBlobFields(emittedLength: number, fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    const emittedFields = reader.readFieldArray(emittedLength);
+    return new PrivateLog(padArrayEnd(emittedFields, Fr.ZERO, PRIVATE_LOG_SIZE_IN_FIELDS), emittedLength);
+  }
+
+  isEmpty() {
+    // Faster to check emittedLength than compare all fields against zero
+    return this.emittedLength === 0;
+  }
+
+  static empty() {
+    return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, Fr.zero), 0);
+  }
+
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, this.fields, this.emittedLength);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateLog(reader.readArray(PRIVATE_LOG_SIZE_IN_FIELDS, Fr), reader.readNumber());
+  }
+
+  static random(tag = Fr.random()) {
+    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() {
+    return z
+      .object({
+        fields: z.array(schemas.Fr),
+        emittedLength: z.number(),
+      })
+      .strict()
+      .transform(({ fields, emittedLength }) => PrivateLog.fromFields(fields.concat(new Fr(emittedLength))));
+  }
+
+  /**
+   * Creates a PrivateLog 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 PrivateLog fields
+   * @returns A PrivateLog instance
+   */
+  static fromPlainObject(obj: any): PrivateLog {
+    if (obj instanceof PrivateLog) {
+      return obj;
+    }
+    return new PrivateLog(
+      obj.fields.map((f: any) => Fr.fromPlainObject(f)),
+      obj.emittedLength,
+    );
+  }
+
+  equals(other: PrivateLog) {
+    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

@@ -0,0 +1,217 @@
+import { FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH, PUBLIC_LOG_HEADER_LENGTH } from '@aztec-labs/constants';
+import type { FieldsOf } from '@aztec-labs/foundation/array';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { type ZodFor, schemas } from '@aztec-labs/foundation/schemas';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { inspect } from 'util';
+import { z } from 'zod';
+
+import { AztecAddress } from '../aztec-address/index.js';
+
+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));
+  }
+
+  /**
+   * 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)),
+    );
+  }
+
+  isEmpty() {
+    return this.length === 0;
+  }
+}
+
+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;
+  }
+
+  toFields(): Fr[] {
+    return [new Fr(this.fields.length), this.contractAddress.toField(), ...this.fields];
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    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.length === 0;
+  }
+
+  static empty() {
+    return new PublicLog(AztecAddress.ZERO, []);
+  }
+
+  toBuffer(): Buffer {
+    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(
+      AztecAddress.fromPlainObject(obj.contractAddress),
+      obj.fields.map((f: any) => Fr.fromPlainObject(f)),
+    );
+  }
+
+  static async random() {
+    return new PublicLog(
+      await AztecAddress.random(),
+      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]))
+    );
+  }
+
+  toHumanReadable(): string {
+    return `PublicLog: (contractAddress: ${this.contractAddress} fields: ${this.fields})`;
+  }
+
+  static get schema(): ZodFor<PublicLog> {
+    return z
+      .object({
+        contractAddress: AztecAddress.schema,
+        fields: z.array(schemas.Fr),
+      })
+      .transform(({ contractAddress, fields }) => PublicLog.from({ contractAddress, fields }));
+  }
+
+  [inspect.custom](): string {
+    return `PublicLog {
+      contractAddress: ${inspect(this.contractAddress)},
+      fields: [${this.fields.map(x => inspect(x)).join(', ')}],
+    }`;
+  }
+}