@aztec/stdlib 0.0.1-commit.5476d83 → 0.0.1-commit.5914bae

package/src/p2p/gossipable.ts

@@ -7,23 +7,33 @@ export class P2PMessage {
   constructor(
     public readonly payload: Buffer,
     public readonly timestamp?: Date,
+    public readonly traceContext?: string,
   ) {}
 
-  static fromGossipable(message: Gossipable, instrumentMessages = false): P2PMessage {
-    return new P2PMessage(message.toBuffer(), instrumentMessages ? new Date() : undefined);
+  static fromGossipable(message: Gossipable, instrumentMessages = false, traceContext?: string): P2PMessage {
+    if (!instrumentMessages) {
+      return new P2PMessage(message.toBuffer());
+    }
+    return new P2PMessage(message.toBuffer(), new Date(), traceContext);
   }
 
   static fromMessageData(messageData: Buffer, instrumentMessages = false): P2PMessage {
     const reader = new BufferReader(messageData);
-    const timestamp = instrumentMessages ? new Date(Number(reader.readUInt64())) : undefined;
+    let timestamp: Date | undefined;
+    let traceContext: string | undefined;
+    if (instrumentMessages) {
+      timestamp = new Date(Number(reader.readUInt64()));
+      traceContext = reader.readString();
+    }
     const payload = reader.readBuffer();
-    return new P2PMessage(payload, timestamp);
+    return new P2PMessage(payload, timestamp, traceContext);
   }
 
   toMessageData(): Buffer {
     const arr: Buffer[] = [];
     if (this.timestamp) {
       arr.push(bigintToUInt64BE(BigInt(this.timestamp.getTime())));
+      arr.push(serializeToBuffer(this.traceContext ?? ''));
     }
     arr.push(serializeToBuffer(this.payload.length, this.payload));
     return serializeToBuffer(arr);

package/src/p2p/index.ts

@@ -1,11 +1,13 @@
 export * from './attestation_utils.js';
-export * from './block_attestation.js';
 export * from './block_proposal.js';
+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';
-export * from './client_type.js';
 export * from './message_validator.js';
 export * from './peer_error.js';
+export * from './constants.js';

package/src/p2p/message_validator.ts

@@ -1,10 +1,22 @@
 import type { PeerErrorSeverity } from './peer_error.js';
 
+/**
+ * Result of validating a P2P message.
+ * - 'accept': Message is valid and should be accepted and processed
+ * - 'ignore': Message should be ignored (not propagated or processed, but sender not penalized)
+ * - 'reject': Message is invalid (rejected and sender penalized)
+ */
+export type ValidationResult =
+  | { result: 'accept' }
+  | { result: 'ignore' }
+  | { result: 'reject'; severity: PeerErrorSeverity };
+
 /**
  * P2PValidator
  *
- * A validator for P2P messages, which returns a severity of error to be applied to the peer
+ * A validator for P2P messages, which returns a ValidationResult indicating
+ * whether to accept, ignore, or reject the message
  */
 export interface P2PValidator<T> {
-  validate(message: T): Promise<PeerErrorSeverity | undefined>;
+  validate(message: T): Promise<ValidationResult>;
 }

package/src/p2p/peer_error.ts

@@ -15,3 +15,10 @@ export enum PeerErrorSeverity {
    */
   HighToleranceError = 'HighToleranceError',
 }
+
+/** Severities ordered from mildest to harshest. */
+export const PeerErrorSeverityByHarshness = [
+  PeerErrorSeverity.HighToleranceError,
+  PeerErrorSeverity.MidToleranceError,
+  PeerErrorSeverity.LowToleranceError,
+] as const;

package/src/p2p/signature_utils.ts

@@ -1,10 +1,13 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256, makeEthSignDigest } from '@aztec/foundation/crypto';
+import { keccak256 } from '@aztec/foundation/crypto/keccak';
+import { makeEthSignDigest } from '@aztec/foundation/crypto/secp256k1-signer';
 
 export enum SignatureDomainSeparator {
   blockProposal = 0,
-  blockAttestation = 1,
+  checkpointAttestation = 1,
   attestationsAndSigners = 2,
+  checkpointProposal = 3,
+  signedTxs = 4,
 }
 
 export interface Signable {

package/src/p2p/signed_txs.ts

@@ -0,0 +1,88 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { MAX_TXS_PER_BLOCK } from '../deserialization/index.js';
+import { Tx } from '../tx/tx.js';
+import {
+  SignatureDomainSeparator,
+  getHashedSignaturePayload,
+  getHashedSignaturePayloadEthSignedMessage,
+} from './signature_utils.js';
+
+/**
+ * A signed collection of transactions.
+ * The signature is over the transaction objects themselves, providing
+ * data availability guarantees beyond just the transaction hashes.
+ */
+export class SignedTxs {
+  private sender: EthAddress | undefined;
+
+  constructor(
+    /** The transactions */
+    public readonly txs: Tx[],
+    /** The proposer's signature over the transactions */
+    public readonly signature: Signature,
+  ) {}
+
+  /**
+   * Get the payload to sign for this signed txs.
+   */
+  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
+    return serializeToBuffer([domainSeparator, this.txs.length, this.txs]);
+  }
+
+  /**
+   * Lazily evaluate the sender of the signed txs; result is cached
+   * @returns The sender address, or undefined if signature recovery fails
+   */
+  getSender(): EthAddress | undefined {
+    if (!this.sender) {
+      const hashed = getHashedSignaturePayloadEthSignedMessage(this, SignatureDomainSeparator.signedTxs);
+      this.sender = tryRecoverAddress(hashed, this.signature);
+    }
+    return this.sender;
+  }
+
+  /**
+   * Create SignedTxs from a signer function
+   */
+  static async createFromSigner(
+    txs: Tx[],
+    payloadSigner: (payload: Buffer32) => Promise<Signature>,
+  ): Promise<SignedTxs> {
+    const tempSignedTxs = new SignedTxs(txs, Signature.empty());
+    const hashed = getHashedSignaturePayload(tempSignedTxs, SignatureDomainSeparator.signedTxs);
+    const signature = await payloadSigner(hashed);
+    return new SignedTxs(txs, signature);
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([this.txs.length, this.txs, this.signature]);
+  }
+
+  static fromBuffer(buf: Buffer | BufferReader): SignedTxs {
+    const reader = BufferReader.asReader(buf);
+    const txCount = reader.readNumber();
+    if (txCount > MAX_TXS_PER_BLOCK) {
+      throw new Error(`txs count ${txCount} exceeds maximum ${MAX_TXS_PER_BLOCK}`);
+    }
+    const txs = reader.readArray(txCount, Tx);
+    const signature = reader.readObject(Signature);
+    return new SignedTxs(txs, signature);
+  }
+
+  getSize(): number {
+    return 4 /* txs.length */ + this.txs.reduce((acc, tx) => acc + tx.getSize(), 0) + this.signature.getSize();
+  }
+
+  static empty(): SignedTxs {
+    return new SignedTxs([], Signature.empty());
+  }
+
+  static random(): SignedTxs {
+    return new SignedTxs([Tx.random(), Tx.random()], Signature.random());
+  }
+}

package/src/p2p/topic_type.ts

@@ -1,5 +1,3 @@
-import { P2PClientType } from './client_type.js';
-
 /**
  * Creates the topic channel identifier string from a given topic type
  */
@@ -23,22 +21,18 @@ export function getTopicFromString(topicStr: string): TopicType | undefined {
 export enum TopicType {
   tx = 'tx',
   block_proposal = 'block_proposal',
-  block_attestation = 'block_attestation',
-}
-
-export function getTopicTypeForClientType(clientType: P2PClientType) {
-  if (clientType === P2PClientType.Full) {
-    return Object.values(TopicType);
-  } else if (clientType === P2PClientType.Prover) {
-    return [TopicType.tx, TopicType.block_proposal];
-  } else {
-    const _: never = clientType;
-    return [TopicType.tx];
-  }
+  checkpoint_proposal = 'checkpoint_proposal',
+  checkpoint_attestation = 'checkpoint_attestation',
 }
 
-export function getTopicsForClientAndConfig(clientType: P2PClientType, disableTransactions: boolean) {
-  const topics = getTopicTypeForClientType(clientType);
+/** Returns all gossip topics, optionally filtering out transactions. */
+export function getTopicsForConfig(disableTransactions: boolean) {
+  const topics = [
+    TopicType.tx,
+    TopicType.block_proposal,
+    TopicType.checkpoint_proposal,
+    TopicType.checkpoint_attestation,
+  ];
   if (disableTransactions) {
     return topics.filter(topic => topic !== TopicType.tx);
   }

package/src/parity/parity_base_private_inputs.ts

@@ -1,5 +1,5 @@
 import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, NUM_MSGS_PER_BASE_PARITY } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -41,7 +41,7 @@ export class ParityBasePrivateInputs {
    */
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new ParityBasePrivateInputs(reader.readArray(NUM_MSGS_PER_BASE_PARITY, Fr), Fr.fromBuffer(reader));
+    return new ParityBasePrivateInputs(reader.readTuple(NUM_MSGS_PER_BASE_PARITY, Fr), Fr.fromBuffer(reader));
   }
 
   /**

package/src/parity/parity_public_inputs.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';

package/src/proofs/chonk_proof.ts

@@ -1,6 +1,7 @@
 import { CHONK_PROOF_LENGTH } from '@aztec/constants';
-import { randomBytes } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { times } from '@aztec/foundation/collection';
+import { randomBytes } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
@@ -31,12 +32,15 @@ export class ChonkProof {
 
   static random() {
     // NB: Not using Fr.random here because it slows down some tests that require a large number of txs significantly.
+    // NB2: generate one fewer random bytes to not have to deal with buffers representing numbers greater than the field modulus
+    // NB3: a chonk proof can be compressed. Simulate this by filling 1/4 of the proof with zero data
     const reducedFrSize = Fr.SIZE_IN_BYTES - 1;
-    const randomFields = randomBytes(CHONK_PROOF_LENGTH * reducedFrSize);
-    const proof = Array.from(
-      { length: CHONK_PROOF_LENGTH },
-      (_, i) => new Fr(randomFields.subarray(i * reducedFrSize, (i + 1) * reducedFrSize)),
-    );
+    const nonZeroFields = Math.floor((3 * CHONK_PROOF_LENGTH) / 4);
+    const randomFields = randomBytes(nonZeroFields * Fr.SIZE_IN_BYTES);
+    const proof = [
+      ...times(nonZeroFields, i => new Fr(randomFields.subarray(i * reducedFrSize, (i + 1) * reducedFrSize))),
+      ...times(CHONK_PROOF_LENGTH - nonZeroFields, () => Fr.ZERO),
+    ];
     return new ChonkProof(proof);
   }
 
@@ -52,7 +56,10 @@ export class ChonkProof {
   static fromBuffer(buffer: Buffer | BufferReader): ChonkProof {
     const reader = BufferReader.asReader(buffer);
     const proofLength = reader.readNumber();
-    const proof = reader.readArray(proofLength, Fr);
+    if (proofLength !== CHONK_PROOF_LENGTH) {
+      throw new Error(`Invalid ChonkProof length from buffer: ${proofLength}, expected ${CHONK_PROOF_LENGTH}`);
+    }
+    const proof = reader.readArray(CHONK_PROOF_LENGTH, Fr);
     return new ChonkProof(proof);
   }
 
@@ -102,6 +109,11 @@ export class ChonkProofWithPublicInputs {
   static fromBuffer(buffer: Buffer | BufferReader): ChonkProofWithPublicInputs {
     const reader = BufferReader.asReader(buffer);
     const proofLength = reader.readNumber();
+    if (proofLength < CHONK_PROOF_LENGTH) {
+      throw new Error(
+        `Invalid ChonkProofWithPublicInputs length from buffer: ${proofLength}, expected at least ${CHONK_PROOF_LENGTH}`,
+      );
+    }
     const proof = reader.readArray(proofLength, Fr);
     return new ChonkProofWithPublicInputs(proof);
   }

package/src/proofs/proof.ts

@@ -1,5 +1,5 @@
 import { PAIRING_POINTS_SIZE } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 

package/src/proofs/proof_data.ts

@@ -29,6 +29,30 @@ export class ProofData<T extends Bufferable, PROOF_LENGTH extends number> {
   }
 }
 
+/**
+ * Represents the data of a recursive proof for a circuit with a fixed verification key.
+ */
+export class ProofDataForFixedVk<T extends Bufferable, PROOF_LENGTH extends number> {
+  constructor(
+    public publicInputs: T,
+    public proof: RecursiveProof<PROOF_LENGTH>,
+  ) {}
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(this.publicInputs, this.proof);
+  }
+
+  public static fromBuffer<T extends Bufferable, PROOF_LENGTH extends number>(
+    buffer: Buffer | BufferReader,
+    publicInputs: {
+      fromBuffer: (reader: BufferReader) => T;
+    },
+  ): ProofDataForFixedVk<T, PROOF_LENGTH> {
+    const reader = BufferReader.asReader(buffer);
+    return new ProofDataForFixedVk(reader.readObject(publicInputs), RecursiveProof.fromBuffer(reader));
+  }
+}
+
 export type ChonkProofData<T extends Bufferable> = ProofData<T, typeof CHONK_PROOF_LENGTH>;
 
 export type UltraHonkProofData<T extends Bufferable> = ProofData<T, typeof RECURSIVE_PROOF_LENGTH>;

package/src/proofs/recursive_proof.ts

@@ -1,5 +1,5 @@
 import { makeTuple } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';

package/src/rollup/avm_proof_data.ts

@@ -1,13 +1,6 @@
 import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
 
 import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
-import type { ProofData } from '../proofs/proof_data.js';
+import type { ProofDataForFixedVk } from '../proofs/proof_data.js';
 
-export type AvmProofData = ProofData<AvmCircuitPublicInputs, typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
-
-// TODO(#14234)[Unconditional PIs validation]: remove this function.
-export function enhanceProofWithPiValidationFlag(proof: Fr[], skipPublicInputsValidation: boolean): Fr[] {
-  const skipPublicInputsField = skipPublicInputsValidation ? new Fr(1) : new Fr(0);
-  return [skipPublicInputsField].concat(proof).slice(0, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED);
-}
+export type AvmProofData = ProofDataForFixedVk<AvmCircuitPublicInputs, typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;

package/src/rollup/base_rollup_hints.ts

@@ -1,7 +1,7 @@
 import { SpongeBlob } from '@aztec/blob-lib/types';
 import { ARCHIVE_HEIGHT, MAX_CONTRACT_CLASS_LOGS_PER_TX } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
@@ -86,7 +86,7 @@ export class PrivateBaseRollupHints {
       reader.readObject(SpongeBlob),
       reader.readObject(TreeSnapshotDiffHints),
       reader.readObject(PublicDataTreeLeafPreimage),
-      reader.readArray(ARCHIVE_HEIGHT, Fr),
+      reader.readTuple(ARCHIVE_HEIGHT, Fr),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
       reader.readObject(BlockConstantData),
     );
@@ -163,7 +163,7 @@ export class PublicBaseRollupHints {
     return new PublicBaseRollupHints(
       reader.readObject(SpongeBlob),
       reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readArray(ARCHIVE_HEIGHT, Fr),
+      reader.readTuple(ARCHIVE_HEIGHT, Fr),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
     );
   }

package/src/rollup/block_constant_data.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 

package/src/rollup/block_headers_hash.ts

@@ -1,11 +1,11 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { computeUnbalancedPoseidonRoot } from '@aztec/foundation/trees';
 
 import type { BlockHeader } from '../tx/block_header.js';
 
 export async function computeBlockHeadersHash(blockHeaders: BlockHeader[]): Promise<Fr> {
   const blockHeaderHashes = await Promise.all(blockHeaders.map(header => header.hash()));
-  // Must match the implementation in merge_block_rollups.nr, with the **wonky** rollup structure
+  // Must match the implementation in merge_block_rollups.nr, with the **unbalanced** rollup structure
   // (see validate_consecutive_block_rollups.nr > assert_rollups_filled_greedily.nr).
   const blockHeadersHash = await computeUnbalancedPoseidonRoot(blockHeaderHashes.map(hash => hash.toBuffer()));
   return Fr.fromBuffer(blockHeadersHash);

package/src/rollup/block_rollup_public_inputs.ts

@@ -1,5 +1,5 @@
 import { SpongeBlob } from '@aztec/blob-lib/types';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -43,17 +43,13 @@ export class BlockRollupPublicInputs {
      */
     public endSpongeBlob: SpongeBlob,
     /**
-     * Timestamp of the first block in this block range.
+     * Timestamp of the blocks in this block range.
      */
-    public startTimestamp: UInt64,
-    /**
-     * Timestamp of the last block in this block range.
-     */
-    public endTimestamp: UInt64,
+    public timestamp: UInt64,
     /**
      * Hash of the headers of all blocks in this block range. It will be combined with the `blockHeadersHash` from
-     * other blocks in the same checkpoint to form a wonky tree. The root of that tree becomes the final hash stored in
-     * the checkpoint header, enabling validation of the blocks included in a checkpoint given their headers.
+     * other blocks in the same checkpoint to form an unbalanced tree. The root of that tree becomes the final hash
+     * stored in the checkpoint header, enabling validation of the blocks included in a checkpoint given their headers.
      */
     public blockHeadersHash: Fr,
     /**
@@ -85,7 +81,6 @@ export class BlockRollupPublicInputs {
       reader.readObject(SpongeBlob),
       reader.readObject(SpongeBlob),
       reader.readUInt64(),
-      reader.readUInt64(),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
@@ -103,8 +98,7 @@ export class BlockRollupPublicInputs {
       this.endState,
       this.startSpongeBlob,
       this.endSpongeBlob,
-      bigintToUInt64BE(this.startTimestamp),
-      bigintToUInt64BE(this.endTimestamp),
+      bigintToUInt64BE(this.timestamp),
       this.blockHeadersHash,
       this.inHash,
       this.outHash,

package/src/rollup/block_root_rollup_private_inputs.ts

@@ -1,5 +1,5 @@
 import { ARCHIVE_HEIGHT, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, type Tuple, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
@@ -60,8 +60,8 @@ export class BlockRootFirstRollupPrivateInputs {
       ProofData.fromBuffer(reader, ParityPublicInputs),
       [ProofData.fromBuffer(reader, TxRollupPublicInputs), ProofData.fromBuffer(reader, TxRollupPublicInputs)],
       AppendOnlyTreeSnapshot.fromBuffer(reader),
-      reader.readArray(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
-      reader.readArray(ARCHIVE_HEIGHT, Fr),
+      reader.readTuple(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
+      reader.readTuple(ARCHIVE_HEIGHT, Fr),
     );
   }
 
@@ -124,8 +124,8 @@ export class BlockRootSingleTxFirstRollupPrivateInputs {
       ProofData.fromBuffer(reader, ParityPublicInputs),
       ProofData.fromBuffer(reader, TxRollupPublicInputs),
       AppendOnlyTreeSnapshot.fromBuffer(reader),
-      reader.readArray(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
-      reader.readArray(ARCHIVE_HEIGHT, Fr),
+      reader.readTuple(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
+      reader.readTuple(ARCHIVE_HEIGHT, Fr),
     );
   }
 
@@ -206,8 +206,8 @@ export class BlockRootEmptyTxFirstRollupPrivateInputs {
       StateReference.fromBuffer(reader),
       CheckpointConstantData.fromBuffer(reader),
       reader.readUInt64(),
-      reader.readArray(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
-      reader.readArray(ARCHIVE_HEIGHT, Fr),
+      reader.readTuple(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
+      reader.readTuple(ARCHIVE_HEIGHT, Fr),
     );
   }
 
@@ -248,7 +248,7 @@ export class BlockRootRollupPrivateInputs {
     const reader = BufferReader.asReader(buffer);
     return new BlockRootRollupPrivateInputs(
       [ProofData.fromBuffer(reader, TxRollupPublicInputs), ProofData.fromBuffer(reader, TxRollupPublicInputs)],
-      reader.readArray(ARCHIVE_HEIGHT, Fr),
+      reader.readTuple(ARCHIVE_HEIGHT, Fr),
     );
   }
 
@@ -289,7 +289,7 @@ export class BlockRootSingleTxRollupPrivateInputs {
     const reader = BufferReader.asReader(buffer);
     return new BlockRootSingleTxRollupPrivateInputs(
       ProofData.fromBuffer(reader, TxRollupPublicInputs),
-      reader.readArray(ARCHIVE_HEIGHT, Fr),
+      reader.readTuple(ARCHIVE_HEIGHT, Fr),
     );
   }
 

package/src/rollup/checkpoint_constant_data.ts

@@ -1,6 +1,6 @@
 import { SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
@@ -11,6 +11,7 @@ import { GasFees } from '../gas/gas_fees.js';
 
 /**
  * Constants that are the same for the entire checkpoint.
+ * Used in circuits during rollup proving.
  */
 export class CheckpointConstantData {
   constructor(