@aztec/stdlib 3.0.0-canary.a9708bd → 3.0.0-manual.20251030

package/src/kernel/private_kernel_prover_output.ts

@@ -5,7 +5,7 @@ import { serializeWitness } from '@aztec/noir-noirc_abi';
 import { Encoder } from 'msgpackr';
 import { z } from 'zod';
 
-import type { ClientIvcProof } from '../proofs/client_ivc_proof.js';
+import type { ChonkProof } from '../proofs/chonk_proof.js';
 import type { PrivateKernelCircuitPublicInputs } from './private_kernel_circuit_public_inputs.js';
 import type { PrivateKernelTailCircuitPublicInputs } from './private_kernel_tail_circuit_public_inputs.js';
 
@@ -45,10 +45,10 @@ export interface PrivateKernelExecutionProofOutput<
   /** The public inputs used by the proof generation process. */
   publicInputs: PublicInputsType;
   /** The private IVC proof optimized for user devices. It will be consumed by an Aztec prover,
-   * which recursively verifies it through the "tube" circuit.*/
-  clientIvcProof: ClientIvcProof;
+   * which recursively verifies it through the "private tx base" or the "public chonk verifier" circuit.*/
+  chonkProof: ChonkProof;
   /**
-   * The trace the clientIvcProof corresponds to.
+   * The trace the chonkProof corresponds to.
    * A trace of app circuits interleaved with private kernel circuits.
    * If simulate is ran with profiling mode, also includes gate counts.
    */

package/src/kernel/private_kernel_tail_circuit_public_inputs.ts

@@ -170,10 +170,10 @@ export class PrivateKernelTailCircuitPublicInputs {
       throw new Error('Private tail public inputs is not for rollup circuit.');
     }
     const constants = new TxConstantData(
-      this.constants.historicalHeader,
+      this.constants.anchorBlockHeader,
       this.constants.txContext,
       this.constants.vkTreeRoot,
-      this.constants.protocolContractTreeRoot,
+      this.constants.protocolContractsHash,
     );
     return new PrivateToRollupKernelCircuitPublicInputs(
       constants,
@@ -184,6 +184,12 @@ export class PrivateKernelTailCircuitPublicInputs {
     );
   }
 
+  publicInputs(): PrivateToPublicKernelCircuitPublicInputs | PrivateToRollupKernelCircuitPublicInputs {
+    return this.forPublic
+      ? this.toPrivateToPublicKernelCircuitPublicInputs()
+      : this.toPrivateToRollupKernelCircuitPublicInputs();
+  }
+
   numberOfPublicCallRequests() {
     return (
       this.numberOfNonRevertiblePublicCallRequests() +

package/src/kernel/private_to_public_kernel_circuit_public_inputs.ts

@@ -1,6 +1,7 @@
 import { GeneratorIndex, PRIVATE_TO_PUBLIC_KERNEL_CIRCUIT_PUBLIC_INPUTS_LENGTH } from '@aztec/constants';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
 import type { Fr } from '@aztec/foundation/fields';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, bigintToUInt64BE, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
@@ -93,4 +94,12 @@ export class PrivateToPublicKernelCircuitPublicInputs {
   hash() {
     return poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.PUBLIC_TX_HASH);
   }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(PrivateToPublicKernelCircuitPublicInputs);
+  }
 }

package/src/keys/derivation.ts

@@ -1,9 +1,8 @@
 import { GeneratorIndex } from '@aztec/constants';
-import { Grumpkin, poseidon2Hash, poseidon2HashWithSeparator, sha512ToGrumpkinScalar } from '@aztec/foundation/crypto';
+import { Grumpkin, poseidon2HashWithSeparator, sha512ToGrumpkinScalar } from '@aztec/foundation/crypto';
 import { Fq, Fr, GrumpkinScalar } from '@aztec/foundation/fields';
 
 import { AztecAddress } from '../aztec-address/index.js';
-import type { CompleteAddress } from '../contract/complete_address.js';
 import type { KeyPrefix } from './key_types.js';
 import { PublicKeys } from './public_keys.js';
 import { getKeyGenerator } from './utils.js';
@@ -51,7 +50,7 @@ export async function computeAddress(publicKeys: PublicKeys, partialAddress: Fr)
   // 2. addressPoint = (preaddress * G) + ivpk_m
   // 3. address = addressPoint.x
   const preaddress = await computePreaddress(await publicKeys.hash(), partialAddress);
-  const address = await new Grumpkin().add(
+  const address = await Grumpkin.add(
     await derivePublicKeyFromSecretKey(new Fq(preaddress.toBigInt())),
     publicKeys.masterIncomingViewingPublicKey,
   );
@@ -82,8 +81,7 @@ export async function computeAddressSecret(preaddress: Fr, ivsk: Fq) {
 }
 
 export function derivePublicKeyFromSecretKey(secretKey: Fq) {
-  const curve = new Grumpkin();
-  return curve.mul(curve.generator(), secretKey);
+  return Grumpkin.mul(Grumpkin.generator, secretKey);
 }
 
 /**
@@ -121,27 +119,3 @@ export async function deriveKeys(secretKey: Fr) {
     publicKeys,
   };
 }
-
-// Returns shared tagging secret computed with Diffie-Hellman key exchange.
-async function computeTaggingSecretPoint(knownAddress: CompleteAddress, ivsk: Fq, externalAddress: AztecAddress) {
-  const knownPreaddress = await computePreaddress(await knownAddress.publicKeys.hash(), knownAddress.partialAddress);
-  // TODO: #8970 - Computation of address point from x coordinate might fail
-  const externalAddressPoint = await externalAddress.toAddressPoint();
-  const curve = new Grumpkin();
-  // Given A (known complete address) -> B (external address) and h == preaddress
-  // Compute shared secret as S = (h_A + ivsk_A) * Addr_Point_B
-
-  // Beware! h_a + ivsk_a (also known as the address secret) can lead to an address point with a negative y-coordinate, since there's two possible candidates
-  // computeAddressSecret takes care of selecting the one that leads to a positive y-coordinate, which is the only valid address point
-  return curve.mul(externalAddressPoint, await computeAddressSecret(knownPreaddress, ivsk));
-}
-
-export async function computeAppTaggingSecret(
-  knownAddress: CompleteAddress,
-  ivsk: Fq,
-  externalAddress: AztecAddress,
-  app: AztecAddress,
-) {
-  const taggingSecretPoint = await computeTaggingSecretPoint(knownAddress, ivsk, externalAddress);
-  return poseidon2Hash([taggingSecretPoint.x, taggingSecretPoint.y, app]);
-}

package/src/logs/contract_class_log.ts

@@ -133,12 +133,11 @@ export class ContractClassLog {
   }
 
   toBlobFields(): Fr[] {
-    return [new Fr(this.emittedLength), this.contractAddress.toField()].concat(this.getEmittedFields());
+    return [this.contractAddress.toField()].concat(this.getEmittedFields());
   }
 
-  static fromBlobFields(fields: Fr[] | FieldReader) {
+  static fromBlobFields(emittedLength: number, 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(

package/src/logs/debug_log.ts

@@ -0,0 +1,32 @@
+import type { Fr } from '@aztec/foundation/fields';
+import { type LogLevel, LogLevels } from '@aztec/foundation/log';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+import { AztecAddress } from '../aztec-address/index.js';
+
+/*
+ * Represents a debug log emitted by public bytecode.
+ */
+export class DebugLog {
+  constructor(
+    public contractAddress: AztecAddress,
+    public level: LogLevel,
+    public message: string,
+    public fields: Fr[],
+  ) {}
+
+  static get schema(): ZodFor<DebugLog> {
+    return z
+      .object({
+        contractAddress: AztecAddress.schema,
+        level: z.enum(LogLevels),
+        message: z.string(),
+        fields: z.array(schemas.Fr),
+      })
+      .transform(
+        ({ contractAddress, level, message, fields }) => new DebugLog(contractAddress, level, message, fields),
+      );
+  }
+}

package/src/logs/directional_app_tagging_secret.ts

@@ -0,0 +1,77 @@
+import { Grumpkin, poseidon2Hash } from '@aztec/foundation/crypto';
+import { type Fq, Fr, type Point } from '@aztec/foundation/fields';
+
+import { z } from 'zod';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import type { CompleteAddress } from '../contract/complete_address.js';
+import { computeAddressSecret, computePreaddress } from '../keys/derivation.js';
+
+/**
+ * Directional application tagging secret used for log tagging.
+ *
+ * "Directional" because the derived secret is bound to the recipient
+ * address: A→B differs from B→A even with the same participants and app.
+ *
+ * Note: It's a bit unfortunate that this type resides in `stdlib` as the rest of the tagging functionality resides
+ * in `pxe/src/tagging`. We need to use this type in `PreTag` that in turn is used by other types
+ * in stdlib hence there doesn't seem to be a good way around this.
+ */
+export class DirectionalAppTaggingSecret {
+  private constructor(public readonly value: Fr) {}
+
+  /**
+   * Derives shared tagging secret and from that, the app address and recipient derives the directional app tagging
+   * secret.
+   *
+   * @param localAddress - The complete address of entity A in the shared tagging secret derivation scheme
+   * @param localIvsk - The incoming viewing secret key of entity A
+   * @param externalAddress - The address of entity B in the shared tagging secret derivation scheme
+   * @param app - Contract address to silo the secret to
+   * @param recipient - Recipient of the log. Defines the "direction of the secret".
+   * @returns The secret that can be used along with an index to compute a tag to be included in a log.
+   */
+  static async compute(
+    localAddress: CompleteAddress,
+    localIvsk: Fq,
+    externalAddress: AztecAddress,
+    app: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<DirectionalAppTaggingSecret> {
+    const taggingSecretPoint = await computeSharedTaggingSecret(localAddress, localIvsk, externalAddress);
+    const appTaggingSecret = await poseidon2Hash([taggingSecretPoint.x, taggingSecretPoint.y, app]);
+    const directionalAppTaggingSecret = await poseidon2Hash([appTaggingSecret, recipient]);
+
+    return new DirectionalAppTaggingSecret(directionalAppTaggingSecret);
+  }
+
+  toString(): string {
+    return this.value.toString();
+  }
+
+  static fromString(str: string): DirectionalAppTaggingSecret {
+    return new DirectionalAppTaggingSecret(Fr.fromString(str));
+  }
+}
+
+// Returns shared tagging secret computed with Diffie-Hellman key exchange.
+async function computeSharedTaggingSecret(
+  localAddress: CompleteAddress,
+  localIvsk: Fq,
+  externalAddress: AztecAddress,
+): Promise<Point> {
+  const knownPreaddress = await computePreaddress(await localAddress.publicKeys.hash(), localAddress.partialAddress);
+  // TODO: #8970 - Computation of address point from x coordinate might fail
+  const externalAddressPoint = await externalAddress.toAddressPoint();
+  // Given A (local complete address) -> B (external address) and h == preaddress
+  // Compute shared secret as S = (h_A + local_ivsk_A) * Addr_Point_B
+
+  // Beware! h_a + local_ivsk_a (also known as the address secret) can lead to an address point with a negative
+  // y-coordinate, since there's two possible candidates computeAddressSecret takes care of selecting the one that
+  // leads to a positive y-coordinate, which is the only valid address point
+  return Grumpkin.mul(externalAddressPoint, await computeAddressSecret(knownPreaddress, localIvsk));
+}
+
+export const DirectionalAppTaggingSecretSchema = z.object({
+  value: Fr.schema,
+});

package/src/logs/index.ts

@@ -1,5 +1,6 @@
 export * from './log_with_tx_data.js';
-export * from './indexed_tagging_secret.js';
+export * from './directional_app_tagging_secret.js';
+export * from './pre_tag.js';
 export * from './contract_class_log.js';
 export * from './public_log.js';
 export * from './private_log.js';
@@ -11,3 +12,4 @@ export * from './extended_contract_class_log.js';
 export * from './shared_secret_derivation.js';
 export * from './tx_scoped_l2_log.js';
 export * from './message_context.js';
+export * from './debug_log.js';

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

@@ -0,0 +1,25 @@
+import { schemas } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+import {
+  type DirectionalAppTaggingSecret,
+  DirectionalAppTaggingSecretSchema,
+} from './directional_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 = {
+  secret: DirectionalAppTaggingSecret;
+  index: number;
+};
+
+export const PreTagSchema = z.object({
+  secret: DirectionalAppTaggingSecretSchema,
+  index: schemas.Integer,
+});

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/logs/shared_secret_derivation.ts

@@ -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/messaging/inbox_leaf.ts

@@ -35,4 +35,9 @@ export class InboxLeaf {
     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;
+  }
 }