@aztec/stdlib 0.0.1-commit.5914bae → 0.0.1-commit.59a0419c6

package/src/proofs/chonk_proof.ts

@@ -1,21 +1,41 @@
+import { BarretenbergSync, flattenChonkProofFields } from '@aztec/bb.js';
 import { CHONK_PROOF_LENGTH } from '@aztec/constants';
 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';
+import { BufferReader, numToUInt32BE, serializeToBuffer } from '@aztec/foundation/serialize';
+
+/**
+ * Serialization format detection for ChonkProof is size-based:
+ *   - UNCOMPRESSED (legacy): [field_count=1632: uint32] [fields...]  → total ≈ 52KB (>= 40KB)
+ *   - COMPRESSED:            [byte_count: uint32] [compressed_bytes] → total ≈ 35KB (< 40KB)
+ *
+ * Detection: if the first uint32 equals CHONK_PROOF_LENGTH (1632), it's legacy format
+ * (field count). Otherwise, it's compressed format (byte count). The old uncompressed
+ * format is never smaller than 40KB; compressed proofs are always smaller than 40KB.
+ */
 
 // CHONK: "Client Honk" - An UltraHonk variant with incremental folding and delayed non-native arithmetic.
 export class ChonkProof {
+  /**
+   * Optional compressed proof bytes from chonk compression (point compression + u256 encoding).
+   * When set, toBuffer() will serialize in compressed format (~1.7x smaller).
+   * When reading from compressed format, this is populated and fields are decompressed on demand.
+   */
+  public compressedProof?: Buffer;
+
   constructor(
     // The proof fields.
     // For native verification, attach public inputs via `attachPublicInputs(publicInputs)`.
     // Not using Tuple here due to the length being too high.
     public fields: Fr[],
+    compressedProof?: Buffer,
   ) {
     if (fields.length !== CHONK_PROOF_LENGTH) {
       throw new Error(`Invalid ChonkProof length: ${fields.length}`);
     }
+    this.compressedProof = compressedProof;
   }
 
   public attachPublicInputs(publicInputs: Fr[]) {
@@ -53,22 +73,84 @@ export class ChonkProof {
     return this.toBuffer();
   }
 
+  /**
+   * Deserialize a ChonkProof from a buffer.
+   * Supports both legacy (field elements) and compressed (chonk compression) formats.
+   *
+   * Size-based format detection:
+   *   - First uint32 == CHONK_PROOF_LENGTH (1632): legacy format, read field elements
+   *     Total proof data ≈ 52KB (always >= 40KB)
+   *   - Otherwise: compressed format, first uint32 is byte count of compressed data
+   *     Total proof data ≈ 35KB (always < 40KB)
+   */
   static fromBuffer(buffer: Buffer | BufferReader): ChonkProof {
     const reader = BufferReader.asReader(buffer);
-    const proofLength = reader.readNumber();
-    if (proofLength !== CHONK_PROOF_LENGTH) {
-      throw new Error(`Invalid ChonkProof length from buffer: ${proofLength}, expected ${CHONK_PROOF_LENGTH}`);
+    const firstUint32 = reader.readNumber();
+
+    if (firstUint32 === CHONK_PROOF_LENGTH) {
+      // Legacy format: firstUint32 is the field count (1632)
+      // Widen to `number` to prevent TS from narrowing to literal 1632,
+      // which would cause Tuple<Fr, 1632> to exceed the recursion limit.
+      const fieldCount: number = firstUint32;
+      const proof = reader.readArray(fieldCount, Fr);
+      return new ChonkProof(proof);
     }
-    const proof = reader.readArray(CHONK_PROOF_LENGTH, Fr);
-    return new ChonkProof(proof);
+
+    // Compressed format: firstUint32 is the compressed byte count
+    const compressedBytes = reader.readBytes(firstUint32);
+    return ChonkProof.fromCompressedBytes(Buffer.from(compressedBytes));
+  }
+
+  /**
+   * Create a ChonkProof from compressed bytes by decompressing via the BarretenbergSync API.
+   * The compressed format uses point compression and u256 encoding (from PR #20645).
+   *
+   * @param compressed - Compressed proof bytes from chonk compression
+   * @returns ChonkProof with both fields and compressed bytes populated
+   */
+  static fromCompressedBytes(compressed: Buffer): ChonkProof {
+    const api = BarretenbergSync.getSingleton();
+    const result = api.chonkDecompressProof({ compressedProof: new Uint8Array(compressed) });
+
+    // Flatten the structured bb.js ChonkProof into flat Fr[] field elements
+    const flatFields = flattenChonkProofFields(result.proof);
+    const fields = flatFields.map(f => Fr.fromBuffer(Buffer.from(f)));
+
+    // The decompressed proof includes public inputs in hidingOinkProof.
+    // Since ChonkProof stores fields WITHOUT public inputs, strip them.
+    // The number of public inputs = total fields - CHONK_PROOF_LENGTH
+    if (fields.length > CHONK_PROOF_LENGTH) {
+      const numPubInputs = fields.length - CHONK_PROOF_LENGTH;
+      const proofFields = fields.slice(numPubInputs);
+      return new ChonkProof(proofFields, compressed);
+    }
+
+    return new ChonkProof(fields, compressed);
   }
 
+  /**
+   * Serialize the proof to a buffer.
+   * If compressed bytes are available, uses the compressed format (~1.7x smaller).
+   * Otherwise falls back to legacy field element format.
+   */
   public toBuffer() {
+    if (this.compressedProof) {
+      // Compressed format: [compressed_byte_count: uint32] [compressed_bytes]
+      return Buffer.concat([numToUInt32BE(this.compressedProof.length), this.compressedProof]);
+    }
+    // Legacy format: [field_count=1632: uint32] [fields...]
     return serializeToBuffer(this.fields.length, this.fields);
   }
 }
 
 export class ChonkProofWithPublicInputs {
+  /**
+   * Optional compressed proof bytes (covers the full proof WITH public inputs).
+   * Set by the prover when using chonk compression. Flows through to ChonkProof
+   * via removePublicInputs() so the Tx can serialize in compressed format.
+   */
+  public compressedProof?: Buffer;
+
   constructor(
     // The proof fields with public inputs.
     // For recursive verification, use without public inputs via `removePublicInputs()`.
@@ -86,7 +168,8 @@ export class ChonkProofWithPublicInputs {
 
   public removePublicInputs() {
     const numPublicInputs = this.fieldsWithPublicInputs.length - CHONK_PROOF_LENGTH;
-    return new ChonkProof(this.fieldsWithPublicInputs.slice(numPublicInputs));
+    // Flow compressed proof bytes through so the ChonkProof can serialize efficiently
+    return new ChonkProof(this.fieldsWithPublicInputs.slice(numPublicInputs), this.compressedProof);
   }
 
   public isEmpty() {
@@ -109,11 +192,6 @@ 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/rollup/base_rollup_hints.ts

@@ -86,7 +86,7 @@ export class PrivateBaseRollupHints {
       reader.readObject(SpongeBlob),
       reader.readObject(TreeSnapshotDiffHints),
       reader.readObject(PublicDataTreeLeafPreimage),
-      reader.readTuple(ARCHIVE_HEIGHT, Fr),
+      reader.readArray(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.readTuple(ARCHIVE_HEIGHT, Fr),
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
     );
   }

package/src/rollup/block_headers_hash.ts

@@ -1,5 +1,7 @@
+import { DomainSeparator } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { computeUnbalancedPoseidonRoot } from '@aztec/foundation/trees';
+import { computeUnbalancedMerkleTreeRootAsync } from '@aztec/foundation/trees';
 
 import type { BlockHeader } from '../tx/block_header.js';
 
@@ -7,6 +9,13 @@ export async function computeBlockHeadersHash(blockHeaders: BlockHeader[]): Prom
   const blockHeaderHashes = await Promise.all(blockHeaders.map(header => header.hash()));
   // 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()));
+  const blockHeadersHasher = async (left: Uint8Array, right: Uint8Array) =>
+    (
+      await poseidon2HashWithSeparator([Buffer.from(left), Buffer.from(right)], DomainSeparator.BLOCK_HEADERS_HASH)
+    ).toBuffer() as Buffer<ArrayBuffer>;
+  const blockHeadersHash = await computeUnbalancedMerkleTreeRootAsync(
+    blockHeaderHashes.map(hash => hash.toBuffer()),
+    blockHeadersHasher,
+  );
   return Fr.fromBuffer(blockHeadersHash);
 }

package/src/rollup/block_root_rollup_private_inputs.ts

@@ -60,8 +60,8 @@ export class BlockRootFirstRollupPrivateInputs {
       ProofData.fromBuffer(reader, ParityPublicInputs),
       [ProofData.fromBuffer(reader, TxRollupPublicInputs), ProofData.fromBuffer(reader, TxRollupPublicInputs)],
       AppendOnlyTreeSnapshot.fromBuffer(reader),
-      reader.readTuple(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
-      reader.readTuple(ARCHIVE_HEIGHT, Fr),
+      reader.readArray(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
     );
   }
 
@@ -124,8 +124,8 @@ export class BlockRootSingleTxFirstRollupPrivateInputs {
       ProofData.fromBuffer(reader, ParityPublicInputs),
       ProofData.fromBuffer(reader, TxRollupPublicInputs),
       AppendOnlyTreeSnapshot.fromBuffer(reader),
-      reader.readTuple(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
-      reader.readTuple(ARCHIVE_HEIGHT, Fr),
+      reader.readArray(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
     );
   }
 
@@ -206,8 +206,8 @@ export class BlockRootEmptyTxFirstRollupPrivateInputs {
       StateReference.fromBuffer(reader),
       CheckpointConstantData.fromBuffer(reader),
       reader.readUInt64(),
-      reader.readTuple(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
-      reader.readTuple(ARCHIVE_HEIGHT, Fr),
+      reader.readArray(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
+      reader.readArray(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.readTuple(ARCHIVE_HEIGHT, Fr),
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
     );
   }
 
@@ -289,7 +289,7 @@ export class BlockRootSingleTxRollupPrivateInputs {
     const reader = BufferReader.asReader(buffer);
     return new BlockRootSingleTxRollupPrivateInputs(
       ProofData.fromBuffer(reader, TxRollupPublicInputs),
-      reader.readTuple(ARCHIVE_HEIGHT, Fr),
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
     );
   }
 

package/src/rollup/checkpoint_rollup_public_inputs.ts

@@ -65,8 +65,8 @@ export class CheckpointRollupPublicInputs {
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readTuple(MAX_CHECKPOINTS_PER_EPOCH, Fr),
-      reader.readTuple(MAX_CHECKPOINTS_PER_EPOCH, FeeRecipient),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, Fr),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, FeeRecipient),
       reader.readObject(BlobAccumulator),
       reader.readObject(BlobAccumulator),
       reader.readObject(FinalBlobBatchingChallenges),

package/src/rollup/checkpoint_root_rollup_private_inputs.ts

@@ -81,15 +81,15 @@ export class CheckpointRootRollupHints {
     const reader = BufferReader.asReader(buffer);
     return new CheckpointRootRollupHints(
       BlockHeader.fromBuffer(reader),
-      reader.readTuple(ARCHIVE_HEIGHT, Fr),
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
       reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readTuple(OUT_HASH_TREE_HEIGHT, Fr),
+      reader.readArray(OUT_HASH_TREE_HEIGHT, Fr),
       reader.readObject(BlobAccumulator),
       reader.readObject(FinalBlobBatchingChallenges),
       // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
-      // reader.readTuple(FIELDS_PER_BLOB, Fr),
+      // reader.readArray(FIELDS_PER_BLOB, Fr),
       Array.from({ length: FIELDS_PER_BLOB * BLOBS_PER_CHECKPOINT }, () => Fr.fromBuffer(reader)),
-      reader.readTuple(BLOBS_PER_CHECKPOINT, BLS12Point),
+      reader.readArray(BLOBS_PER_CHECKPOINT, BLS12Point),
       Fr.fromBuffer(reader),
     );
   }

package/src/rollup/root_rollup_public_inputs.ts

@@ -68,8 +68,8 @@ export class RootRollupPublicInputs {
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
-      reader.readTuple(MAX_CHECKPOINTS_PER_EPOCH, Fr),
-      reader.readTuple(MAX_CHECKPOINTS_PER_EPOCH, FeeRecipient),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, Fr),
+      reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, FeeRecipient),
       EpochConstantData.fromBuffer(reader),
       reader.readObject(FinalBlobAccumulator),
     );

package/src/rollup/tree_snapshot_diff_hints.ts

@@ -85,14 +85,14 @@ export class TreeSnapshotDiffHints {
   static fromBuffer(buffer: Buffer | BufferReader): TreeSnapshotDiffHints {
     const reader = BufferReader.asReader(buffer);
     return new TreeSnapshotDiffHints(
-      reader.readTuple(NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
-      reader.readTuple(MAX_NULLIFIERS_PER_TX, NullifierLeafPreimage),
-      reader.readTuple(MAX_NULLIFIERS_PER_TX, {
+      reader.readArray(NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
+      reader.readArray(MAX_NULLIFIERS_PER_TX, NullifierLeafPreimage),
+      reader.readArray(MAX_NULLIFIERS_PER_TX, {
         fromBuffer: buffer => MembershipWitness.fromBuffer(buffer, NULLIFIER_TREE_HEIGHT),
       }),
-      reader.readTuple(MAX_NULLIFIERS_PER_TX, Fr),
+      reader.readArray(MAX_NULLIFIERS_PER_TX, Fr),
       reader.readNumbers(MAX_NULLIFIERS_PER_TX),
-      reader.readTuple(NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
+      reader.readArray(NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
       MembershipWitness.fromBuffer(reader, PUBLIC_DATA_TREE_HEIGHT),
     );
   }

package/src/slashing/index.ts

@@ -1,6 +1,5 @@
 export * from './types.js';
 export * from './interfaces.js';
 export * from './helpers.js';
-export * from './empire.js';
-export * from './tally.js';
+export * from './votes.js';
 export * from './serialization.js';

package/src/slashing/serialization.ts

@@ -1,15 +1,7 @@
-import { times } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { BufferReader, bigintToUInt64BE, bigintToUInt128BE, serializeToBuffer } from '@aztec/foundation/serialize';
 
-import type {
-  Offense,
-  OffenseType,
-  SlashPayload,
-  SlashPayloadRound,
-  ValidatorSlash,
-  ValidatorSlashOffense,
-} from './types.js';
+import type { Offense, OffenseType } from './types.js';
 
 export function serializeOffense(offense: Offense): Buffer {
   return serializeToBuffer(
@@ -29,75 +21,3 @@ export function deserializeOffense(buffer: Buffer): Offense {
 
   return { validator, amount, offenseType: offense, epochOrSlot };
 }
-
-function serializeValidatorSlashOffense(offense: ValidatorSlashOffense): Buffer {
-  return serializeToBuffer(bigintToUInt64BE(offense.epochOrSlot), offense.offenseType);
-}
-
-function deserializeValidatorSlashOffense(buffer: Buffer | BufferReader): ValidatorSlashOffense {
-  const reader = BufferReader.asReader(buffer);
-  return {
-    epochOrSlot: reader.readUInt64(),
-    offenseType: reader.readNumber() as OffenseType,
-  };
-}
-
-function serializeValidatorSlash(slash: ValidatorSlash): Buffer {
-  return serializeToBuffer(
-    slash.validator,
-    bigintToUInt128BE(slash.amount),
-    slash.offenses.length,
-    slash.offenses.map(serializeValidatorSlashOffense),
-  );
-}
-
-function deserializeValidatorSlash(buffer: Buffer | BufferReader): ValidatorSlash {
-  const reader = BufferReader.asReader(buffer);
-  const validator = reader.readObject(EthAddress);
-  const amount = reader.readUInt128();
-  const offensesCount = reader.readNumber();
-  const offenses = times(offensesCount, () => deserializeValidatorSlashOffense(reader));
-
-  return { validator, amount, offenses };
-}
-
-export function serializeSlashPayload(payload: SlashPayload): Buffer {
-  return serializeToBuffer(
-    payload.address,
-    payload.slashes.length,
-    payload.slashes.map(serializeValidatorSlash),
-    bigintToUInt64BE(payload.timestamp),
-  );
-}
-
-export function deserializeSlashPayload(buffer: Buffer): SlashPayload {
-  const reader = BufferReader.asReader(buffer);
-  const address = reader.readObject(EthAddress);
-  const slashesCount = reader.readNumber();
-  const slashes = times(slashesCount, () => deserializeValidatorSlash(reader));
-  const timestamp = reader.readUInt64();
-  return { address, slashes, timestamp };
-}
-
-export function serializeSlashPayloadRound(payload: SlashPayloadRound): Buffer {
-  return serializeToBuffer(
-    payload.address,
-    payload.slashes.length,
-    payload.slashes.map(serializeValidatorSlash),
-    bigintToUInt64BE(payload.timestamp),
-    Number(payload.votes),
-    bigintToUInt64BE(payload.round),
-  );
-}
-
-export function deserializeSlashPayloadRound(buffer: Buffer): SlashPayloadRound {
-  const reader = BufferReader.asReader(buffer);
-  const address = reader.readObject(EthAddress);
-  const slashesCount = reader.readNumber();
-  const slashes = times(slashesCount, () => deserializeValidatorSlash(reader));
-  const timestamp = reader.readUInt64();
-  const votes = BigInt(reader.readNumber());
-  const round = reader.readUInt64();
-
-  return { address, slashes, timestamp, votes, round };
-}

package/src/slashing/types.ts

@@ -126,45 +126,13 @@ export type ValidatorSlash = {
   offenses: ValidatorSlashOffense[];
 };
 
-/** Slash payload as published by the empire slash proposer */
-export type SlashPayload = {
-  address: EthAddress;
-  slashes: ValidatorSlash[];
-  timestamp: bigint;
-};
-
-/** Slash payload with round information from empire slash proposer */
-export type SlashPayloadRound = SlashPayload & { votes: bigint; round: bigint };
-
-export const SlashPayloadRoundSchema = zodFor<SlashPayloadRound>()(
-  z.object({
-    address: schemas.EthAddress,
-    timestamp: schemas.BigInt,
-    votes: schemas.BigInt,
-    round: schemas.BigInt,
-    slashes: z.array(
-      z.object({
-        validator: schemas.EthAddress,
-        amount: schemas.BigInt,
-        offenses: z.array(z.object({ offenseType: OffenseTypeSchema, epochOrSlot: schemas.BigInt })),
-      }),
-    ),
-  }),
-);
-
-/** Votes for a validator slash in the consensus slash proposer */
+/** Votes for a validator slash in the slashing proposer */
 export type ValidatorSlashVote = number;
 
 export type ProposerSlashAction =
-  /** Create a new slash payload on an empire-based slash proposer */
-  | { type: 'create-empire-payload'; data: ValidatorSlash[] }
-  /** Vote for a slashing payload on an empire-based slash proposer */
-  | { type: 'vote-empire-payload'; payload: EthAddress }
-  /** Execute a slashing payload on an empire-based slash proposer */
-  | { type: 'execute-empire-payload'; round: bigint }
-  /** Vote for offenses on a consensus slashing proposer */
+  /** Vote for offenses on the slashing proposer */
   | { type: 'vote-offenses'; votes: ValidatorSlashVote[]; committees: EthAddress[][]; round: bigint }
-  /** Execute a slashing round on a consensus slashing proposer */
+  /** Execute a slashing round on the slashing proposer */
   | { type: 'execute-slash'; committees: EthAddress[][]; round: bigint };
 
 export type ProposerSlashActionType = ProposerSlashAction['type'];

package/src/slashing/{tally.ts → votes.ts}

@@ -28,7 +28,7 @@ export function getSlashConsensusVotesFromOffenses(
     targetCommitteeSize: number;
     maxSlashedValidators?: number;
   },
-  logger: Logger = createLogger('slasher:tally'),
+  logger: Logger = createLogger('slasher:votes'),
 ): ValidatorSlashVote[] {
   const { slashingAmounts, targetCommitteeSize, maxSlashedValidators } = settings;
 

package/src/tests/factories.ts

@@ -9,7 +9,6 @@ import {
   AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
   CHONK_PROOF_LENGTH,
   CONTRACT_CLASS_LOG_SIZE_IN_FIELDS,
-  DomainSeparator,
   L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
   MAX_CHECKPOINTS_PER_EPOCH,
   MAX_CONTRACT_CLASS_LOGS_PER_TX,
@@ -46,7 +45,6 @@ import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
 import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { compact } from '@aztec/foundation/collection';
 import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { SchnorrSignature } from '@aztec/foundation/crypto/schnorr';
 import { sha256 } from '@aztec/foundation/crypto/sha256';
 import { Fq, Fr } from '@aztec/foundation/curves/bn254';
@@ -92,11 +90,10 @@ import {
   type ContractClassPublic,
   ContractDeploymentData,
   type ContractInstanceWithAddress,
-  type ExecutablePrivateFunctionWithMembershipProof,
   type PrivateFunction,
   SerializableContractInstance,
-  type UtilityFunctionWithMembershipProof,
   computeContractClassId,
+  computePartialAddress,
   computePublicBytecodeCommitment,
 } from '../contract/index.js';
 import { Gas, GasFees, GasSettings } from '../gas/index.js';
@@ -178,7 +175,7 @@ import { TxHash } from '../tx/tx_hash.js';
 import { TxRequest } from '../tx/tx_request.js';
 import { Vector } from '../types/index.js';
 import { VkData } from '../vks/index.js';
-import { VerificationKey, VerificationKeyAsFields, VerificationKeyData } from '../vks/verification_key.js';
+import { VerificationKeyAsFields, VerificationKeyData } from '../vks/verification_key.js';
 
 /**
  * Creates an arbitrary side effect object with the given seed.
@@ -575,14 +572,6 @@ export function makeVerificationKeyAsFields(size: number): VerificationKeyAsFiel
   return VerificationKeyAsFields.makeFake(size);
 }
 
-/**
- * Creates arbitrary/mocked verification key.
- * @returns A verification key object
- */
-export function makeVerificationKey(): VerificationKey {
-  return VerificationKey.makeFake();
-}
-
 /**
  * Creates an arbitrary point in a curve.
  * @param seed - Seed to generate the point values.
@@ -865,11 +854,16 @@ export function makeParityPublicInputs(seed = 0): ParityPublicInputs {
     new Fr(BigInt(seed + 0x200)),
     new Fr(BigInt(seed + 0x300)),
     new Fr(BigInt(seed + 0x400)),
+    new Fr(BigInt(seed + 0x500)),
   );
 }
 
 export function makeParityBasePrivateInputs(seed = 0): ParityBasePrivateInputs {
-  return new ParityBasePrivateInputs(makeTuple(NUM_MSGS_PER_BASE_PARITY, fr, seed + 0x3000), new Fr(seed + 0x4000));
+  return new ParityBasePrivateInputs(
+    makeTuple(NUM_MSGS_PER_BASE_PARITY, fr, seed + 0x3000),
+    new Fr(seed + 0x4000),
+    new Fr(seed + 0x5000),
+  );
 }
 
 export function makeParityRootPrivateInputs(seed = 0) {
@@ -1183,35 +1177,6 @@ export function makePublicTxBaseRollupPrivateInputs(seed = 0) {
   });
 }
 
-export function makeExecutablePrivateFunctionWithMembershipProof(
-  seed = 0,
-): ExecutablePrivateFunctionWithMembershipProof {
-  return {
-    selector: makeSelector(seed),
-    bytecode: makeBytes(100, seed + 1),
-    artifactTreeSiblingPath: makeTuple(3, fr, seed + 2),
-    artifactTreeLeafIndex: seed + 2,
-    privateFunctionTreeSiblingPath: makeTuple(3, fr, seed + 3),
-    privateFunctionTreeLeafIndex: seed + 3,
-    artifactMetadataHash: fr(seed + 4),
-    functionMetadataHash: fr(seed + 5),
-    utilityFunctionsTreeRoot: fr(seed + 6),
-    vkHash: fr(seed + 7),
-  };
-}
-
-export function makeUtilityFunctionWithMembershipProof(seed = 0): UtilityFunctionWithMembershipProof {
-  return {
-    selector: makeSelector(seed),
-    bytecode: makeBytes(100, seed + 1),
-    artifactTreeSiblingPath: makeTuple(3, fr, seed + 2),
-    artifactTreeLeafIndex: seed + 2,
-    artifactMetadataHash: fr(seed + 4),
-    functionMetadataHash: fr(seed + 5),
-    privateFunctionsArtifactTreeRoot: fr(seed + 6),
-  };
-}
-
 export async function makeContractClassPublic(seed = 0, publicBytecode?: Buffer): Promise<ContractClassPublic> {
   const artifactHash = fr(seed + 1);
   const privateFunctionsRoot = fr(seed + 3);
@@ -1223,8 +1188,6 @@ export async function makeContractClassPublic(seed = 0, publicBytecode?: Buffer)
     artifactHash,
     packedBytecode,
     privateFunctionsRoot,
-    privateFunctions: [],
-    utilityFunctions: [],
     version: 1,
   };
 }
@@ -1286,14 +1249,12 @@ export async function makeContractInstanceFromClassId(
   const deployer = overrides?.deployer ?? new AztecAddress(new Fr(seed + 2));
   const publicKeys = overrides?.publicKeys ?? (await makePublicKeys(seed + 3));
 
-  const saltedInitializationHash = await poseidon2HashWithSeparator(
-    [salt, initializationHash, deployer],
-    DomainSeparator.PARTIAL_ADDRESS,
-  );
-  const partialAddress = await poseidon2HashWithSeparator(
-    [classId, saltedInitializationHash],
-    DomainSeparator.PARTIAL_ADDRESS,
-  );
+  const partialAddress = await computePartialAddress({
+    originalContractClassId: classId,
+    salt,
+    initializationHash,
+    deployer,
+  });
   const address = await computeAddress(publicKeys, partialAddress);
   return new SerializableContractInstance({
     version: 1,
@@ -1748,6 +1709,10 @@ export function makeL2Tips(
       block: { number: bn, hash },
       checkpoint: { number: cpn, hash: cph },
     },
+    proposedCheckpoint: {
+      block: { number: bn, hash },
+      checkpoint: { number: cpn, hash: cph },
+    },
     proven: {
       block: { number: bn, hash },
       checkpoint: { number: cpn, hash: cph },

package/src/tests/mocks.ts

@@ -587,6 +587,7 @@ export const makeBlockProposal = (options?: MakeBlockProposalOptions): Promise<B
 
   return BlockProposal.createProposalFromSigner(
     blockHeader,
+    CheckpointNumber(1),
     indexWithinCheckpoint,
     inHash,
     archiveRoot,
@@ -596,28 +597,31 @@ export const makeBlockProposal = (options?: MakeBlockProposalOptions): Promise<B
   );
 };
 
-export const makeCheckpointProposal = (options?: MakeCheckpointProposalOptions): Promise<CheckpointProposal> => {
-  const blockHeader = options?.lastBlock?.blockHeader ?? makeBlockHeader(1);
+export const makeCheckpointProposal = async (options?: MakeCheckpointProposalOptions): Promise<CheckpointProposal> => {
   const checkpointHeader = options?.checkpointHeader ?? makeCheckpointHeader(1);
   const archiveRoot = options?.archiveRoot ?? Fr.random();
   const feeAssetPriceModifier = options?.feeAssetPriceModifier ?? 0n;
   const signer = options?.signer ?? Secp256k1Signer.random();
 
-  // Build lastBlock info if provided
-  const lastBlockInfo = options?.lastBlock
-    ? {
-        blockHeader,
-        indexWithinCheckpoint: options.lastBlock.indexWithinCheckpoint ?? IndexWithinCheckpoint(4), // Last block in a 5-block checkpoint
-        txHashes: options.lastBlock.txHashes ?? [0, 1, 2, 3, 4, 5].map(() => TxHash.random()),
+  // Build a signed block proposal if lastBlock options are provided
+  const lastBlockProposal = options?.lastBlock
+    ? await makeBlockProposal({
+        blockHeader: options.lastBlock.blockHeader,
+        indexWithinCheckpoint: options.lastBlock.indexWithinCheckpoint ?? IndexWithinCheckpoint(4),
+        inHash: checkpointHeader.inHash,
+        archiveRoot,
+        txHashes: options.lastBlock.txHashes,
         txs: options.lastBlock.txs,
-      }
+        signer,
+      })
     : undefined;
 
   return CheckpointProposal.createProposalFromSigner(
     checkpointHeader,
     archiveRoot,
+    CheckpointNumber(1),
     feeAssetPriceModifier,
-    lastBlockInfo,
+    lastBlockProposal,
     payload => Promise.resolve(signer.signMessage(payload)),
   );
 };