@aztec/stdlib 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/src/logs/message_context.ts

@@ -1,6 +1,4 @@
-import { MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
-import { range } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/curves/bn254';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { TxHash } from '../tx/tx_hash.js';
 
@@ -13,60 +11,8 @@ import type { TxHash } from '../tx/tx_hash.js';
  *
  * A TS version of `message_context.nr`.
  */
-export class MessageContext {
-  constructor(
-    public txHash: TxHash,
-    public uniqueNoteHashesInTx: Fr[],
-    public firstNullifierInTx: Fr,
-  ) {}
-
-  toFields(): Fr[] {
-    return [
-      this.txHash.hash,
-      ...serializeBoundedVec(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
-      this.firstNullifierInTx,
-    ];
-  }
-
-  toNoirStruct() {
-    /* eslint-disable camelcase */
-    return {
-      tx_hash: this.txHash.hash,
-      unique_note_hashes_in_tx: this.uniqueNoteHashesInTx,
-      first_nullifier_in_tx: this.firstNullifierInTx,
-    };
-    /* eslint-enable camelcase */
-  }
-
-  static toEmptyFields(): Fr[] {
-    const serializationLen =
-      1 /* txHash */ + MAX_NOTE_HASHES_PER_TX + 1 /* uniqueNoteHashesInTx BVec */ + 1; /* firstNullifierInTx */
-    return range(serializationLen).map(_ => Fr.zero());
-  }
-
-  static toSerializedOption(response: MessageContext | null): Fr[] {
-    if (response) {
-      return [new Fr(1), ...response.toFields()];
-    } else {
-      return [new Fr(0), ...MessageContext.toEmptyFields()];
-    }
-  }
-}
-
-/**
- * Helper function to serialize a bounded vector according to Noir's BoundedVec format
- * @param values - The values to serialize
- * @param maxLength - The maximum length of the bounded vector
- * @returns The serialized bounded vector as Fr[]
- * @dev Copied over from pending_tagged_log.ts.
- */
-function serializeBoundedVec(values: Fr[], maxLength: number): Fr[] {
-  if (values.length > maxLength) {
-    throw new Error(`Attempted to serialize ${values} values into a BoundedVec with max length ${maxLength}`);
-  }
-
-  const lengthDiff = maxLength - values.length;
-  const zeroPaddingArray = Array(lengthDiff).fill(Fr.ZERO);
-  const storage = values.concat(zeroPaddingArray);
-  return [...storage, new Fr(values.length)];
-}
+export type MessageContext = {
+  txHash: TxHash;
+  uniqueNoteHashesInTx: Fr[];
+  firstNullifierInTx: Fr;
+};

package/src/logs/pending_tagged_log.ts

@@ -1,39 +1,12 @@
-import { PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/curves/bn254';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
-import type { TxHash } from '../tx/tx_hash.js';
-import { MessageContext } from './message_context.js';
+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 class PendingTaggedLog {
-  private context: MessageContext;
-
-  constructor(
-    public log: Fr[],
-    txHash: TxHash,
-    uniqueNoteHashesInTx: Fr[],
-    firstNullifierInTx: Fr,
-  ) {
-    this.context = new MessageContext(txHash, uniqueNoteHashesInTx, firstNullifierInTx);
-  }
-
-  toFields(): Fr[] {
-    return [...serializeBoundedVec(this.log, PRIVATE_LOG_SIZE_IN_FIELDS), ...this.context.toFields()];
-  }
-}
-
-/**
- * Helper function to serialize a bounded vector according to Noir's BoundedVec format
- * @param values - The values to serialize
- * @param maxLength - The maximum length of the bounded vector
- * @returns The serialized bounded vector as Fr[]
- */
-function serializeBoundedVec(values: Fr[], maxLength: number): Fr[] {
-  const lengthDiff = maxLength - values.length;
-  const zeroPaddingArray = Array(lengthDiff).fill(Fr.ZERO);
-  const storage = values.concat(zeroPaddingArray);
-  return [...storage, new Fr(values.length)];
-}
+export type PendingTaggedLog = {
+  log: Fr[];
+  context: MessageContext;
+};

package/src/logs/shared_secret_derivation.ts

@@ -2,16 +2,28 @@ import { DomainSeparator } from '@aztec/constants';
 import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import type { Fr } from '@aztec/foundation/curves/bn254';
-import type { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
+import { GrumpkinScalar, type Point } from '@aztec/foundation/curves/grumpkin';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 import type { PublicKey } from '../keys/public_key.js';
 
 /**
- * Derives an app-siloed ECDH shared secret.
+ * Derives the raw ECDH shared secret point `S = secretKey * publicKey`.
  *
- * Computes the raw ECDH shared secret `S = secretKey * publicKey`, then app-silos it:
- * `s_app = h(DOM_SEP__APP_SILOED_ECDH_SHARED_SECRET, S.x, S.y, contractAddress)`
+ * @throws If the publicKey is zero.
+ */
+export function deriveEcdhSharedSecretPoint(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.`,
+    );
+  }
+  return Grumpkin.mul(publicKey, secretKey);
+}
+
+/**
+ * Derives an app-siloed ECDH shared secret from keys: ECDHs `S = secretKey * publicKey` via
+ * {@link deriveEcdhSharedSecretPoint}, then app-silos it via {@link appSiloEcdhSharedSecretPoint}.
  *
  * @param secretKey - The secret key used to derive shared secret.
  * @param publicKey - The public key used to derive shared secret.
@@ -19,19 +31,40 @@ import type { PublicKey } from '../keys/public_key.js';
  * @returns The app-siloed shared secret as a Field.
  * @throws If the publicKey is zero.
  */
-export async function deriveAppSiloedSharedSecret(
+export async function appSiloEcdhSharedSecret(
   secretKey: GrumpkinScalar,
   publicKey: PublicKey,
   contractAddress: AztecAddress,
 ): Promise<Fr> {
-  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 rawSharedSecret = await Grumpkin.mul(publicKey, secretKey);
-  return poseidon2HashWithSeparator(
-    [rawSharedSecret.x, rawSharedSecret.y, contractAddress],
-    DomainSeparator.APP_SILOED_ECDH_SHARED_SECRET,
+  const rawSharedSecret = await deriveEcdhSharedSecretPoint(secretKey, publicKey);
+  return appSiloEcdhSharedSecretPoint(rawSharedSecret, contractAddress);
+}
+
+/**
+ * App-silos a shared secret point: `s_app = h(DOM_SEP__APP_SILOED_ECDH_SHARED_SECRET, S.x, S.y, app)`.
+ *
+ * Mirrors `compute_app_siloed_shared_secret` in aztec-nr.
+ *
+ * @param point - The raw shared secret point `S`.
+ * @param app - The contract address to silo to.
+ */
+export function appSiloEcdhSharedSecretPoint(point: Point, app: AztecAddress): Promise<Fr> {
+  return poseidon2HashWithSeparator([point.x, point.y, app], DomainSeparator.APP_SILOED_ECDH_SHARED_SECRET);
+}
+
+/**
+ * Protects a handshake's shared secret from being forged by the recipient: `S' = hash(ephPk, recipientPoint) * S`.
+ *
+ * Mirrors aztec-nr's `protect_from_forgery` and must stay byte-compatible with it.
+ *
+ * @param secret - The raw shared secret `S` to protect.
+ * @param ephPk - The handshake's ephemeral public key.
+ * @param recipientPoint - The recipient's address point.
+ */
+export async function protectFromForgery(secret: Point, ephPk: Point, recipientPoint: Point): Promise<Point> {
+  const scalar = await poseidon2HashWithSeparator(
+    [ephPk.x, ephPk.y, recipientPoint.x, recipientPoint.y],
+    DomainSeparator.HANDSHAKE_FORGERY_PROTECTION,
   );
+  return Grumpkin.mul(secret, new GrumpkinScalar(scalar.toBigInt()));
 }

package/src/messaging/l1_to_l2_message.ts

@@ -1,4 +1,5 @@
-import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
+import { DomainSeparator, type L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { sha256ToField } from '@aztec/foundation/crypto/sha256';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
@@ -7,7 +8,7 @@ import { SiblingPath } from '@aztec/foundation/trees';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 import type { BlockParameter } from '../block/block_parameter.js';
-import { computeL1ToL2MessageNullifier } from '../hash/hash.js';
+import { siloNullifier } from '../hash/hash.js';
 import type { AztecNode } from '../interfaces/aztec-node.js';
 import { MerkleTreeId } from '../trees/merkle_tree_id.js';
 import { L1Actor } from './l1_actor.js';
@@ -74,28 +75,65 @@ export class L1ToL2Message {
   }
 }
 
-// This functionality is not on the node because we do not want to pass the node the secret, and give the node the ability to derive a valid nullifer for an L1 to L2 message.
-export async function getNonNullifiedL1ToL2MessageWitness(
+/**
+ * The unsiloed nullifier a message consumer derives, together with the contract address needed to silo it.
+ */
+export interface UnsiloedMessageNullifier {
+  contractAddress: AztecAddress;
+  nullifier: Fr;
+}
+
+/**
+ * Computes the unsiloed nullifier that the fee juice contract (and any consumer following the same scheme) derives when
+ * consuming an L1 to L2 message.
+ *
+ * This is not a general-purpose utility: other contracts may derive the secret hash and hence the nullifier
+ * differently. The result is unsiloed — callers silo it (with the consuming contract's address) before looking it up
+ * in the nullifier tree.
+ */
+export function computeFeeJuiceMessageNullifier(messageHash: Fr, secret: Fr): Promise<Fr> {
+  return poseidon2HashWithSeparator([messageHash, secret], DomainSeparator.MESSAGE_NULLIFIER);
+}
+
+/**
+ * Fetches the membership witness of an L1 to L2 message. When `unsiloedNullifier` is provided, the message is
+ * additionally required to be un-nullified.
+ */
+export async function getL1ToL2MessageWitness(
   node: AztecNode,
-  contractAddress: AztecAddress,
   messageHash: Fr,
-  secret: Fr,
+  unsiloedNullifier?: UnsiloedMessageNullifier,
   referenceBlock: BlockParameter = 'latest',
 ): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>]> {
-  const messageNullifier = await computeL1ToL2MessageNullifier(contractAddress, messageHash, secret);
-
-  const [l1ToL2Response, nullifierResponse] = await Promise.all([
-    node.getL1ToL2MessageMembershipWitness(referenceBlock, messageHash),
-    node.findLeavesIndexes(referenceBlock, MerkleTreeId.NULLIFIER_TREE, [messageNullifier]),
-  ]);
+  // Both requests are dispatched before awaiting so they run concurrently.
+  const l1ToL2ResponsePromise = node.getL1ToL2MessageMembershipWitness(referenceBlock, messageHash);
+  const nullifierResponsePromise = unsiloedNullifier
+    ? siloNullifier(unsiloedNullifier.contractAddress, unsiloedNullifier.nullifier).then(siloed =>
+        node.findLeavesIndexes(referenceBlock, MerkleTreeId.NULLIFIER_TREE, [siloed]),
+      )
+    : undefined;
 
+  const l1ToL2Response = await l1ToL2ResponsePromise;
   if (!l1ToL2Response) {
     throw new Error(`No L1 to L2 message found for message hash ${messageHash.toString()}`);
   }
 
-  if (nullifierResponse[0] !== undefined) {
+  const nullifierResponse = await nullifierResponsePromise;
+  if (nullifierResponse?.[0] !== undefined) {
     throw new Error(`No non-nullified L1 to L2 message found for message hash ${messageHash.toString()}`);
   }
 
   return l1ToL2Response;
 }
+
+// This functionality is not on the node because we do not want to pass the node the secret, and give the node the ability to derive a valid nullifer for an L1 to L2 message.
+export async function getNonNullifiedL1ToL2MessageWitness(
+  node: AztecNode,
+  contractAddress: AztecAddress,
+  messageHash: Fr,
+  secret: Fr,
+  referenceBlock: BlockParameter = 'latest',
+): Promise<[bigint, SiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>]> {
+  const nullifier = await computeFeeJuiceMessageNullifier(messageHash, secret);
+  return getL1ToL2MessageWitness(node, messageHash, { contractAddress, nullifier }, referenceBlock);
+}

package/src/messaging/l2_to_l1_membership.ts

@@ -1,11 +1,14 @@
 import { MAX_CHECKPOINTS_PER_EPOCH, OUT_HASH_TREE_LEAF_COUNT } from '@aztec/constants';
-import type { EpochNumber } from '@aztec/foundation/branded-types';
+import { type EpochNumber, EpochNumberSchema } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { SiblingPath, UnbalancedMerkleTreeCalculator, computeUnbalancedShaRoot } from '@aztec/foundation/trees';
 
+import { z } from 'zod';
+
 import type { AztecNode } from '../interfaces/aztec-node.js';
+import { schemas } from '../schemas/schemas.js';
 import { TxHash } from '../tx/tx_hash.js';
-import { TxReceipt } from '../tx/tx_receipt.js';
+import type { TxReceipt } from '../tx/tx_receipt.js';
 
 /**
  * Provides access to the L1 Outbox's per-epoch roots so the witness helper can pick the smallest
@@ -123,6 +126,19 @@ export type L2ToL1MembershipWitness = {
   siblingPath: SiblingPath<number>;
 };
 
+/**
+ * Zod schema for {@link L2ToL1MembershipWitness}. The sibling-path length varies with the shape of
+ * the per-epoch tree, so we use the unsized `SiblingPath.schema` here rather than a fixed-height
+ * `schemaFor`.
+ */
+export const L2ToL1MembershipWitnessSchema = z.object({
+  epochNumber: EpochNumberSchema,
+  numCheckpointsInEpoch: schemas.Integer,
+  root: schemas.Fr,
+  leafIndex: schemas.BigInt,
+  siblingPath: SiblingPath.schema,
+}) as unknown as z.ZodType<L2ToL1MembershipWitness>;
+
 /**
  * Computes the L2 to L1 membership witness for a given message in a transaction.
  *
@@ -144,26 +160,27 @@ export type L2ToL1MembershipWitness = {
  *   If not provided, the message is found by scanning the tx's messages (throws if duplicates exist).
  */
 export async function computeL2ToL1MembershipWitness(
-  node: Pick<AztecNode, 'getL2ToL1Messages' | 'getTxReceipt' | 'getTxEffect' | 'getBlock' | 'getCheckpointsData'>,
+  node: Pick<AztecNode, 'getL2ToL1Messages' | 'getTxReceipt' | 'getBlock' | 'getCheckpointsData'>,
   outboxOrRoots: OutboxRootsReader | Fr[],
   message: Fr,
-  txHashOrReceipt: TxHash | Pick<TxReceipt, 'txHash' | 'epochNumber' | 'blockNumber'>,
+  txHashOrReceipt: TxHash | Pick<TxReceipt, 'txHash' | 'epochNumber' | 'blockNumber' | 'txIndexInBlock'>,
   messageIndexInTx?: number,
 ): Promise<L2ToL1MembershipWitness | undefined> {
-  const receipt = 'txHash' in txHashOrReceipt ? txHashOrReceipt : await node.getTxReceipt(txHashOrReceipt);
-  const { txHash, epochNumber, blockNumber } = receipt;
-  if (epochNumber === undefined || blockNumber === undefined) {
+  const receipt =
+    'txHash' in txHashOrReceipt ? txHashOrReceipt : await node.getTxReceipt(txHashOrReceipt, { includeTxEffect: true });
+
+  const { epochNumber, blockNumber, txIndexInBlock } = receipt;
+  if (epochNumber === undefined || blockNumber === undefined || txIndexInBlock === undefined) {
     return undefined;
   }
 
-  const [messagesInEpoch, block, txEffect, checkpointsData] = await Promise.all([
+  const [messagesInEpoch, block, checkpointsData] = await Promise.all([
     node.getL2ToL1Messages(epochNumber),
     node.getBlock(blockNumber),
-    node.getTxEffect(txHash),
     node.getCheckpointsData({ epoch: epochNumber }),
   ]);
 
-  if (messagesInEpoch.length === 0 || !block || !txEffect) {
+  if (messagesInEpoch.length === 0 || !block) {
     return undefined;
   }
 
@@ -173,7 +190,7 @@ export async function computeL2ToL1MembershipWitness(
   }
 
   const blockIndex = block.indexWithinCheckpoint;
-  const txIndex = txEffect.txIndexInBlock;
+  const txIndex = txIndexInBlock;
 
   // Pick the smallest partial-proof root on the Outbox that covers checkpointIndex. The Outbox
   // stores roots keyed by `numCheckpointsInEpoch - 1`, so to cover a tx in checkpoint at index

package/src/noir/index.ts

@@ -2,6 +2,7 @@ import type {
   ABIParameter,
   ABIParameterVisibility,
   AbiErrorType,
+  AbiNamedValue,
   AbiType,
   AbiValue,
   DebugFileMap,
@@ -73,7 +74,7 @@ export interface NoirCompiledContract {
   /** The events of the contract */
   outputs: {
     structs: Record<string, AbiType[]>;
-    globals: Record<string, AbiValue[]>;
+    globals: Record<string, (AbiNamedValue | AbiValue)[]>;
   };
   /** The map of file ID to the source code and path of the file. */
   file_map: DebugFileMap;

package/src/p2p/attestation_utils.ts

@@ -1,3 +1,4 @@
+import { normalizeSignature } from '@aztec/foundation/crypto/secp256k1-signer';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 
 import { CommitteeAttestation } from '../block/index.js';
@@ -18,9 +19,15 @@ export function orderAttestations(
   for (const attestation of attestations) {
     const sender = attestation.getSender();
     if (sender) {
+      // Canonicalize the recovery byte to v ∈ {27, 28} before it reaches the L1 bundle. A committee
+      // member (or a peer mutating the byte in flight) can emit an equivalent signature in yParity form
+      // (v = 0/1); left as-is it makes `packAttestations` (empty iff v === 0) and `getSigners` (empty iff
+      // r,s,v all zero) disagree, reverting `propose()` with SignersSizeMismatch, and a v = 1 byte would
+      // later revert epoch proving in ECDSA.recover. `sender` recovered, so the signature is non-empty
+      // and low-s, and normalizeSignature preserves the recovered address.
       attestationMap.set(
         sender.toString(),
-        CommitteeAttestation.fromAddressAndSignature(sender, attestation.signature),
+        CommitteeAttestation.fromAddressAndSignature(sender, normalizeSignature(attestation.signature)),
       );
     }
   }

package/src/p2p/checkpoint_attestation.ts

@@ -1,5 +1,6 @@
 import { CheckpointProposalHash, type SlotNumber } from '@aztec/foundation/branded-types';
 import { type BaseBuffer32, Buffer32 } from '@aztec/foundation/buffer';
+import { normalizeSignature } from '@aztec/foundation/crypto/secp256k1-signer';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
@@ -97,6 +98,17 @@ export class CheckpointAttestation extends Gossipable {
     return this.cachedProposer ?? undefined;
   }
 
+  /**
+   * Returns a copy with the attester signature canonicalized to v ∈ {27, 28}. Callers store attestations
+   * received from gossip verbatim; normalizing on ingress keeps a signature emitted in yParity form
+   * (v = 0/1) — whether by a malicious committee member or a peer mutating the byte in flight — from
+   * reaching the L1 bundle in a non-canonical form. Must only be called once the signature has recovered
+   * a sender (so it is non-empty and low-s); `normalizeSignature` throws on an all-zero signature.
+   */
+  withNormalizedSignature(): CheckpointAttestation {
+    return new CheckpointAttestation(this.payload, normalizeSignature(this.signature), this.proposerSignature);
+  }
+
   getPayload(): Buffer {
     return this.payload.getPayloadToSign();
   }

package/src/p2p/index.ts

@@ -4,7 +4,6 @@ export * from './checkpoint_attestation.js';
 export * from './checkpoint_proposal.js';
 export * from './consensus_payload.js';
 export * from './gossipable.js';
-export * from './interface.js';
 export * from './signature_utils.js';
 export * from './signed_txs.js';
 export * from './topic_type.js';

package/src/p2p/signature_utils.ts

@@ -112,6 +112,15 @@ export function getHashedSignaturePayloadTypedData(signable: Signable): Buffer32
   return Buffer32.fromString(hashTypedData(getCoordinationSignatureTypedData(signable)));
 }
 
+/**
+ * Recovers the sender of a gossiped coordination message. Deliberately lenient (allowYParityAsV): a
+ * signature whose recovery byte is in yParity form (v ∈ {0, 1}) still resolves to its sender, so the P2P
+ * layer can attribute and accept it and then canonicalize on ingress (CheckpointAttestation.
+ * withNormalizedSignature, A-1351) before it reaches the L1 bundle. This is intentionally looser than
+ * on-chain checkpoint validation (getAttestationInfoFromPayload), which recovers strictly to mirror L1's
+ * ECDSA.recover — do not unify the two. These proposal/attestation signatures are P2P-only and never reach
+ * L1 verbatim, so leniency here cannot leak a non-canonical byte onto L1.
+ */
 export function recoverCoordinationSigner(signable: Signable, signature: Signature): EthAddress | undefined {
   const digest = getHashedSignaturePayloadTypedData(signable);
   return tryRecoverAddress(digest, signature, { allowYParityAsV: true });

package/src/rollup/avm_proof_data.ts

@@ -1,6 +1,6 @@
-import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED } from '@aztec/constants';
+import { AVM_V2_PROOF_LENGTH_IN_FIELDS } from '@aztec/constants';
 
 import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
 import type { ProofDataForFixedVk } from '../proofs/proof_data.js';
 
-export type AvmProofData = ProofDataForFixedVk<AvmCircuitPublicInputs, typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
+export type AvmProofData = ProofDataForFixedVk<AvmCircuitPublicInputs, typeof AVM_V2_PROOF_LENGTH_IN_FIELDS>;

package/src/rollup/checkpoint_header.ts

@@ -52,6 +52,8 @@ export class CheckpointHeader {
     public gasFees: GasFees,
     /** Total mana used in the block, computed by the root rollup circuit */
     public totalManaUsed: Fr,
+    /** Total fees accrued across the checkpoint. */
+    public accumulatedFees: Fr,
   ) {}
 
   static get schema(): ZodFor<CheckpointHeader> {
@@ -68,6 +70,7 @@ export class CheckpointHeader {
         feeRecipient: schemas.AztecAddress,
         gasFees: GasFees.schema,
         totalManaUsed: schemas.Fr,
+        accumulatedFees: schemas.Fr,
       })
       .transform(CheckpointHeader.from);
   }
@@ -85,6 +88,7 @@ export class CheckpointHeader {
       fields.feeRecipient,
       fields.gasFees,
       fields.totalManaUsed,
+      fields.accumulatedFees,
     ] as const;
   }
 
@@ -107,6 +111,7 @@ export class CheckpointHeader {
       reader.readObject(AztecAddress),
       reader.readObject(GasFees),
       reader.readObject(Fr),
+      reader.readObject(Fr),
     );
   }
 
@@ -122,7 +127,8 @@ export class CheckpointHeader {
       this.coinbase.equals(other.coinbase) &&
       this.feeRecipient.equals(other.feeRecipient) &&
       this.gasFees.equals(other.gasFees) &&
-      this.totalManaUsed.equals(other.totalManaUsed)
+      this.totalManaUsed.equals(other.totalManaUsed) &&
+      this.accumulatedFees.equals(other.accumulatedFees)
     );
   }
 
@@ -151,6 +157,7 @@ export class CheckpointHeader {
       this.feeRecipient,
       this.gasFees,
       this.totalManaUsed,
+      this.accumulatedFees,
     ]);
   }
 
@@ -171,6 +178,7 @@ export class CheckpointHeader {
       feeRecipient: AztecAddress.ZERO,
       gasFees: GasFees.empty(),
       totalManaUsed: Fr.ZERO,
+      accumulatedFees: Fr.ZERO,
       ...fields,
     });
   }
@@ -188,6 +196,7 @@ export class CheckpointHeader {
       feeRecipient: new AztecAddress(Fr.random()),
       gasFees: GasFees.random(),
       totalManaUsed: new Fr(BigInt(Math.floor(Math.random() * 1000000))),
+      accumulatedFees: new Fr(BigInt(Math.floor(Math.random() * 1000000))),
       ...overrides,
     });
   }
@@ -204,7 +213,8 @@ export class CheckpointHeader {
       this.coinbase.isZero() &&
       this.feeRecipient.isZero() &&
       this.gasFees.isEmpty() &&
-      this.totalManaUsed.isZero()
+      this.totalManaUsed.isZero() &&
+      this.accumulatedFees.isZero()
     );
   }
 
@@ -233,6 +243,7 @@ export class CheckpointHeader {
       new AztecAddress(hexToBuffer(header.feeRecipient)),
       new GasFees(header.gasFees.feePerDaGas, header.gasFees.feePerL2Gas),
       new Fr(header.totalManaUsed),
+      new Fr(header.accumulatedFees),
     );
   }
 
@@ -260,6 +271,7 @@ export class CheckpointHeader {
         feePerL2Gas: this.gasFees.feePerL2Gas,
       },
       totalManaUsed: this.totalManaUsed.toBigInt(),
+      accumulatedFees: this.accumulatedFees.toBigInt(),
     };
   }
 
@@ -276,6 +288,7 @@ export class CheckpointHeader {
       feeRecipient: this.feeRecipient.toString(),
       gasFees: this.gasFees.toInspect(),
       totalManaUsed: this.totalManaUsed.toBigInt(),
+      accumulatedFees: this.accumulatedFees.toBigInt(),
     };
   }
 
@@ -292,6 +305,7 @@ export class CheckpointHeader {
   feeRecipient: ${this.feeRecipient.toString()},
   gasFees: { da:${this.gasFees.feePerDaGas}, l2:${this.gasFees.feePerL2Gas} },
   totalManaUsed: ${this.totalManaUsed.toBigInt()},
+  accumulatedFees: ${this.accumulatedFees.toBigInt()},
 }`;
   }
 }

package/src/stats/stats.ts

@@ -86,12 +86,16 @@ export type ClientCircuitName =
   | 'private-kernel-init'
   | 'private-kernel-init-2'
   | 'private-kernel-init-3'
+  | 'private-kernel-init-4'
+  | 'private-kernel-init-5'
   | 'private-kernel-inner'
   | 'private-kernel-inner-2'
   | 'private-kernel-inner-3'
+  | 'private-kernel-inner-4'
+  | 'private-kernel-inner-5'
   | 'private-kernel-reset'
-  | 'private-kernel-tail'
-  | 'private-kernel-tail-to-public'
+  | 'private-kernel-reset-tail'
+  | 'private-kernel-reset-tail-to-public'
   | 'hiding-kernel-to-rollup'
   | 'hiding-kernel-to-public'
   | 'app-circuit';