@aztec/stdlib 3.0.0-nightly.20251127 → 3.0.0-nightly.20251128

package/src/checkpoint/checkpoint.ts

@@ -1,6 +1,8 @@
 import { encodeCheckpointBlobDataFromBlocks } from '@aztec/blob-lib/encoding';
 import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
@@ -16,6 +18,8 @@ export class Checkpoint {
     public header: CheckpointHeader,
     /** L2 blocks in the checkpoint. */
     public blocks: L2BlockNew[],
+    /** Number of the checkpoint. */
+    public number: number,
   ) {}
 
   static get schema() {
@@ -24,24 +28,61 @@ export class Checkpoint {
         archive: AppendOnlyTreeSnapshot.schema,
         header: CheckpointHeader.schema,
         blocks: z.array(L2BlockNew.schema),
+        number: schemas.UInt32,
       })
-      .transform(({ archive, header, blocks }) => new Checkpoint(archive, header, blocks));
+      .transform(({ archive, header, blocks, number }) => new Checkpoint(archive, header, blocks, number));
+  }
+
+  static from(fields: FieldsOf<Checkpoint>) {
+    return new Checkpoint(...Checkpoint.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<Checkpoint>) {
+    return [fields.archive, fields.header, fields.blocks, fields.number] as const;
   }
 
   static fromBuffer(buf: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buf);
-    const archive = reader.readObject(AppendOnlyTreeSnapshot);
-    const header = reader.readObject(CheckpointHeader);
-    const blocks = reader.readVector(L2BlockNew);
-    return new Checkpoint(archive, header, blocks);
+    return new Checkpoint(
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(CheckpointHeader),
+      reader.readVector(L2BlockNew),
+      reader.readNumber(),
+    );
   }
 
-  toBuffer() {
-    return serializeToBuffer(this.archive, this.header, this.blocks.length, this.blocks);
+  public toBuffer() {
+    return serializeToBuffer(this.archive, this.header, this.blocks.length, this.blocks, this.number);
   }
 
   public toBlobFields(): Fr[] {
     const blocks = this.blocks.map((block, i) => block.toBlockBlobData(i === 0));
     return encodeCheckpointBlobDataFromBlocks(blocks);
   }
+
+  public hash(): Fr {
+    return this.header.hash();
+  }
+
+  public getState() {
+    return this.blocks.at(-1)!.header.state;
+  }
+
+  static async random(
+    checkpointNumber = 1,
+    {
+      numBlocks = 1,
+      startBlockNumber = 1,
+      ...options
+    }: { numBlocks?: number; startBlockNumber?: number } & Partial<FieldsOf<CheckpointHeader>> &
+      Partial<Parameters<typeof L2BlockNew.random>[1]> = {},
+  ) {
+    const header = CheckpointHeader.random(options);
+
+    const blocks = await Promise.all(
+      Array.from({ length: numBlocks }, (_, i) => L2BlockNew.random(startBlockNumber + i, options)),
+    );
+
+    return new Checkpoint(AppendOnlyTreeSnapshot.random(), header, blocks, checkpointNumber);
+  }
 }

package/src/checkpoint/index.ts

@@ -1 +1,2 @@
 export * from './checkpoint.js';
+export * from './published_checkpoint.js';

package/src/checkpoint/published_checkpoint.ts

@@ -0,0 +1,91 @@
+// Ignoring import issue to fix portable inferred type issue in zod schema
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { randomBigInt } from '@aztec/foundation/crypto';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { CommitteeAttestation } from '../block/proposal/committee_attestation.js';
+import { Checkpoint } from './checkpoint.js';
+
+export class L1PublishedData {
+  constructor(
+    public blockNumber: bigint,
+    public timestamp: bigint,
+    public blockHash: string,
+  ) {}
+
+  static get schema() {
+    return z.object({
+      blockNumber: schemas.BigInt,
+      timestamp: schemas.BigInt,
+      blockHash: z.string(),
+    });
+  }
+
+  static random() {
+    return new L1PublishedData(
+      randomBigInt(1000n) + 1n,
+      BigInt(Math.floor(Date.now() / 1000)),
+      Buffer32.random().toString(),
+    );
+  }
+
+  static fromFields(fields: FieldsOf<L1PublishedData>) {
+    return new L1PublishedData(fields.blockNumber, fields.timestamp, fields.blockHash);
+  }
+}
+
+export class PublishedCheckpoint {
+  constructor(
+    public checkpoint: Checkpoint,
+    public l1: L1PublishedData,
+    // The attestations for the last block in the checkpoint.
+    public attestations: CommitteeAttestation[],
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        checkpoint: Checkpoint.schema,
+        l1: L1PublishedData.schema,
+        attestations: z.array(CommitteeAttestation.schema),
+      })
+      .transform(obj => PublishedCheckpoint.from(obj));
+  }
+
+  static getFields(fields: FieldsOf<PublishedCheckpoint>) {
+    return [fields.checkpoint, fields.l1, fields.attestations] as const;
+  }
+
+  static from(fields: FieldsOf<PublishedCheckpoint>) {
+    return new PublishedCheckpoint(...PublishedCheckpoint.getFields(fields));
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): PublishedCheckpoint {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const checkpoint = reader.readObject(Checkpoint);
+    const l1BlockNumber = reader.readBigInt();
+    const l1BlockHash = reader.readString();
+    const l1Timestamp = reader.readBigInt();
+    const attestations = reader.readVector(CommitteeAttestation);
+    return new PublishedCheckpoint(
+      checkpoint,
+      new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash),
+      attestations,
+    );
+  }
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(
+      this.checkpoint,
+      this.l1.blockNumber,
+      this.l1.blockHash,
+      this.l1.timestamp,
+      this.attestations.length,
+      this.attestations,
+    );
+  }
+}

package/src/epoch-helpers/index.ts

@@ -1,3 +1,5 @@
+import { EpochNumber } from '@aztec/foundation/branded-types';
+
 import { z } from 'zod';
 
 import { type ZodFor, schemas } from '../schemas/index.js';
@@ -46,21 +48,21 @@ export function getSlotAtTimestamp(ts: bigint, constants: Pick<L1RollupConstants
 export function getEpochNumberAtTimestamp(
   ts: bigint,
   constants: Pick<L1RollupConstants, 'epochDuration' | 'slotDuration' | 'l1GenesisTime'>,
-) {
+): EpochNumber {
   return getEpochAtSlot(getSlotAtTimestamp(ts, constants), constants);
 }
 
 /** Returns the epoch number for a given slot. */
-export function getEpochAtSlot(slot: bigint, constants: Pick<L1RollupConstants, 'epochDuration'>) {
-  return slot / BigInt(constants.epochDuration);
+export function getEpochAtSlot(slot: bigint, constants: Pick<L1RollupConstants, 'epochDuration'>): EpochNumber {
+  return EpochNumber.fromBigInt(slot / BigInt(constants.epochDuration));
 }
 
 /** Returns the range of L2 slots (inclusive) for a given epoch number. */
 export function getSlotRangeForEpoch(
-  epochNumber: bigint,
+  epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'epochDuration'>,
 ): [bigint, bigint] {
-  const startSlot = epochNumber * BigInt(constants.epochDuration);
+  const startSlot = BigInt(epochNumber) * BigInt(constants.epochDuration);
   return [startSlot, startSlot + BigInt(constants.epochDuration) - 1n];
 }
 
@@ -69,7 +71,7 @@ export function getSlotRangeForEpoch(
  * Note that the endTimestamp is the start timestamp of the last L1 slot for the epoch.
  */
 export function getTimestampRangeForEpoch(
-  epochNumber: bigint,
+  epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration' | 'ethereumSlotDuration'>,
 ): [bigint, bigint] {
   const [startSlot, endSlot] = getSlotRangeForEpoch(epochNumber, constants);
@@ -86,7 +88,7 @@ export function getTimestampRangeForEpoch(
  * Returns the start timestamp for a given epoch number.
  */
 export function getStartTimestampForEpoch(
-  epochNumber: bigint,
+  epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration'>,
 ) {
   const [startSlot] = getSlotRangeForEpoch(epochNumber, constants);
@@ -98,10 +100,10 @@ export function getStartTimestampForEpoch(
  * See l1-contracts/src/core/libraries/TimeLib.sol
  */
 export function getProofSubmissionDeadlineEpoch(
-  epochNumber: bigint,
+  epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'proofSubmissionEpochs'>,
-) {
-  return epochNumber + BigInt(constants.proofSubmissionEpochs + 1);
+): EpochNumber {
+  return EpochNumber(epochNumber + constants.proofSubmissionEpochs + 1);
 }
 
 /**
@@ -109,7 +111,7 @@ export function getProofSubmissionDeadlineEpoch(
  * Computed as the start of the given epoch plus the proof submission window.
  */
 export function getProofSubmissionDeadlineTimestamp(
-  epochNumber: bigint,
+  epochNumber: EpochNumber,
   constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration' | 'proofSubmissionEpochs'>,
 ) {
   // See l1-contracts/src/core/libraries/TimeLib.sol:

package/src/interfaces/archiver.ts

@@ -1,4 +1,5 @@
 import type { L1ContractAddresses } from '@aztec/ethereum';
+import { EpochNumberSchema } from '@aztec/foundation/branded-types';
 import type { ApiSchemaFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
@@ -94,10 +95,10 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   getTxEffect: z.function().args(TxHash.schema).returns(indexedTxSchema().optional()),
   getSettledTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema.optional()),
   getL2SlotNumber: z.function().args().returns(schemas.BigInt.optional()),
-  getL2EpochNumber: z.function().args().returns(schemas.BigInt.optional()),
-  getBlocksForEpoch: z.function().args(schemas.BigInt).returns(z.array(L2Block.schema)),
-  getBlockHeadersForEpoch: z.function().args(schemas.BigInt).returns(z.array(BlockHeader.schema)),
-  isEpochComplete: z.function().args(schemas.BigInt).returns(z.boolean()),
+  getL2EpochNumber: z.function().args().returns(EpochNumberSchema.optional()),
+  getBlocksForEpoch: z.function().args(EpochNumberSchema).returns(z.array(L2Block.schema)),
+  getBlockHeadersForEpoch: z.function().args(EpochNumberSchema).returns(z.array(BlockHeader.schema)),
+  isEpochComplete: z.function().args(EpochNumberSchema).returns(z.boolean()),
   getL2Tips: z.function().args().returns(L2TipsSchema),
   getPrivateLogs: z.function().args(z.number(), z.number()).returns(z.array(PrivateLog.schema)),
   getLogsByTags: z

package/src/interfaces/epoch-prover.ts

@@ -1,4 +1,5 @@
-import type { BatchedBlob, FinalBlobBatchingChallenges } from '@aztec/blob-lib';
+import type { BatchedBlob, FinalBlobBatchingChallenges } from '@aztec/blob-lib/types';
+import type { EpochNumber } from '@aztec/foundation/branded-types';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { Fr } from '@aztec/foundation/fields';
 
@@ -19,7 +20,7 @@ export interface EpochProver extends Omit<IBlockFactory, 'setBlockCompleted' | '
    * @param finalBlobBatchingChallenges - The final blob batching challenges for the epoch.
    **/
   startNewEpoch(
-    epochNumber: number,
+    epochNumber: EpochNumber,
     totalNumCheckpoints: number,
     finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
   ): void;

package/src/interfaces/proving-job.ts

@@ -4,6 +4,7 @@ import {
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
 } from '@aztec/constants';
+import { EpochNumber, EpochNumberSchema } from '@aztec/foundation/branded-types';
 import type { ZodFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
@@ -400,24 +401,32 @@ export const ProofUri = z.string().brand('ProvingJobUri');
 export type ProofUri = z.infer<typeof ProofUri>;
 
 export type ProvingJobId = z.infer<typeof ProvingJobId>;
-export const ProvingJob = z.object({
+
+type ProvingJobShape = {
+  id: ProvingJobId;
+  type: ProvingRequestType;
+  epochNumber: EpochNumber;
+  inputsUri: ProofUri;
+};
+
+export const ProvingJob: z.ZodType<ProvingJobShape, z.ZodTypeDef, any> = z.object({
   id: ProvingJobId,
   type: z.nativeEnum(ProvingRequestType),
-  epochNumber: z.number(),
+  epochNumber: EpochNumberSchema,
   inputsUri: ProofUri,
 });
 
-export const makeProvingJobId = (epochNumber: number, type: ProvingRequestType, inputsHash: string) => {
+export const makeProvingJobId = (epochNumber: EpochNumber, type: ProvingRequestType, inputsHash: string) => {
   return `${epochNumber}:${ProvingRequestType[type]}:${inputsHash}`;
 };
 
-export const getEpochFromProvingJobId = (id: ProvingJobId) => {
+export const getEpochFromProvingJobId = (id: ProvingJobId): EpochNumber => {
   const components = id.split(':');
   const epochNumber = components.length < 1 ? Number.NaN : parseInt(components[0], 10);
   if (!Number.isSafeInteger(epochNumber) || epochNumber < 0) {
     throw new Error(`Proving Job ID ${id} does not contain valid epoch`);
   }
-  return epochNumber;
+  return EpochNumber(epochNumber);
 };
 
 export type ProvingJob = z.infer<typeof ProvingJob>;

package/src/p2p/consensus_payload.ts

@@ -8,6 +8,7 @@ import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
 
 import type { L2Block } from '../block/l2_block.js';
+import type { Checkpoint } from '../checkpoint/checkpoint.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
 import { StateReference } from '../tx/state_reference.js';
 import type { Signable, SignatureDomainSeparator } from './signature_utils.js';
@@ -90,6 +91,11 @@ export class ConsensusPayload implements Signable {
     return new ConsensusPayload(block.header.toCheckpointHeader(), block.archive.root, block.header.state);
   }
 
+  static fromCheckpoint(checkpoint: Checkpoint): ConsensusPayload {
+    const lastBlock = checkpoint.blocks.at(-1)!;
+    return new ConsensusPayload(checkpoint.header, checkpoint.archive.root, lastBlock.header.state);
+  }
+
   static empty(): ConsensusPayload {
     return new ConsensusPayload(CheckpointHeader.empty(), Fr.ZERO, StateReference.empty());
   }

package/src/rollup/checkpoint_header.ts

@@ -136,18 +136,19 @@ export class CheckpointHeader {
     });
   }
 
-  static random(): CheckpointHeader {
-    return new CheckpointHeader(
-      Fr.random(),
-      Fr.random(),
-      ContentCommitment.random(),
-      new Fr(BigInt(Math.floor(Math.random() * 1000) + 1)),
-      BigInt(Math.floor(Date.now() / 1000)),
-      EthAddress.random(),
-      new AztecAddress(Fr.random()),
-      GasFees.random(),
-      new Fr(BigInt(Math.floor(Math.random() * 1000000))),
-    );
+  static random(overrides: Partial<FieldsOf<CheckpointHeader>> = {}): CheckpointHeader {
+    return CheckpointHeader.from({
+      lastArchiveRoot: Fr.random(),
+      blockHeadersHash: Fr.random(),
+      contentCommitment: ContentCommitment.random(),
+      slotNumber: new Fr(BigInt(Math.floor(Math.random() * 1000) + 1)),
+      timestamp: BigInt(Math.floor(Date.now() / 1000)),
+      coinbase: EthAddress.random(),
+      feeRecipient: new AztecAddress(Fr.random()),
+      gasFees: GasFees.random(),
+      totalManaUsed: new Fr(BigInt(Math.floor(Math.random() * 1000000))),
+      ...overrides,
+    });
   }
 
   isEmpty(): boolean {

package/src/slashing/empire.ts

@@ -1,3 +1,5 @@
+import { EpochNumber } from '@aztec/foundation/branded-types';
+
 import { getRoundForSlot, getRoundsForEpoch } from './helpers.js';
 import type { Offense, OffenseIdentifier, SlashPayload, SlashPayloadRound, ValidatorSlash } from './types.js';
 import { OffenseType } from './types.js';
@@ -66,7 +68,7 @@ export function getFirstEligibleRoundForOffense(
     // Inactivity is detected at the end of the epoch, so we flag it as detected in the first fresh round for the next epoch
     case OffenseType.INACTIVITY: {
       const epoch = offense.epochOrSlot;
-      const detectedEpoch = epoch + 1n;
+      const detectedEpoch = EpochNumber.fromBigInt(epoch + 1n);
       return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
     }
     // These offenses are detected once an epoch is pruned, which happens after the proof submission window
@@ -74,7 +76,7 @@ export function getFirstEligibleRoundForOffense(
     case OffenseType.DATA_WITHHOLDING: {
       // TODO(palla/slash): Check for off-by-ones especially here
       const epoch = offense.epochOrSlot;
-      const detectedEpoch = epoch + BigInt(constants.proofSubmissionEpochs);
+      const detectedEpoch = EpochNumber.fromBigInt(epoch + BigInt(constants.proofSubmissionEpochs));
       return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
     }
     // These offenses are detected immediately in the slot they occur, so we assume they are detected in the first round for the following slot
@@ -89,7 +91,7 @@ export function getFirstEligibleRoundForOffense(
     // Assume these are epoch-based offenses, even though we should never have to process these
     case OffenseType.UNKNOWN: {
       const epoch = offense.epochOrSlot;
-      const detectedEpoch = epoch + 1n;
+      const detectedEpoch = EpochNumber.fromBigInt(epoch + 1n);
       return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
     }
     default: {

package/src/slashing/helpers.ts

@@ -1,3 +1,5 @@
+import { EpochNumber } from '@aztec/foundation/branded-types';
+
 import { type L1RollupConstants, getEpochAtSlot, getSlotRangeForEpoch } from '../epoch-helpers/index.js';
 import type { SlasherConfig } from '../interfaces/slasher.js';
 import { type Offense, OffenseType } from './types.js';
@@ -15,7 +17,7 @@ export function getRoundForSlot(
 
 /** Returns the voting round(s) lower and upper bounds (inclusive) covered by the given epoch */
 export function getRoundsForEpoch(
-  epoch: bigint,
+  epoch: EpochNumber,
   constants: { slashingRoundSize: number; epochDuration: number },
 ): [bigint, bigint] {
   const [start, end] = getSlotRangeForEpoch(epoch, constants);
@@ -28,13 +30,13 @@ export function getRoundsForEpoch(
 export function getEpochsForRound(
   round: bigint,
   constants: { slashingRoundSize: number; epochDuration: number },
-): bigint[] {
-  const epochs: bigint[] = [];
+): EpochNumber[] {
+  const epochs: EpochNumber[] = [];
   const firstSlot = round * BigInt(constants.slashingRoundSize);
   const lastSlot = firstSlot + BigInt(constants.slashingRoundSize) - 1n;
   const startEpoch = getEpochAtSlot(firstSlot, constants);
   const endEpoch = getEpochAtSlot(lastSlot, constants);
-  for (let epoch = startEpoch; epoch <= endEpoch; epoch++) {
+  for (let epoch = startEpoch; epoch <= endEpoch; epoch = EpochNumber(epoch + 1)) {
     epochs.push(epoch);
   }
   return epochs;

package/src/tests/factories.ts

@@ -1,4 +1,9 @@
-import { makeBatchedBlobAccumulator, makeSpongeBlob } from '@aztec/blob-lib/testing';
+import {
+  makeBlobAccumulator,
+  makeFinalBlobAccumulator,
+  makeFinalBlobBatchingChallenges,
+  makeSpongeBlob,
+} from '@aztec/blob-lib/testing';
 import {
   ARCHIVE_HEIGHT,
   AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
@@ -77,7 +82,7 @@ import {
 import { PublicDataRead } from '../avm/public_data_read.js';
 import { PublicDataWrite } from '../avm/public_data_write.js';
 import { AztecAddress } from '../aztec-address/index.js';
-import { L2BlockHeader } from '../block/index.js';
+import { L2BlockHeader } from '../block/l2_block_header.js';
 import {
   type ContractClassPublic,
   ContractDeploymentData,
@@ -296,7 +301,12 @@ export function makeContractStorageRead(seed = 1): ContractStorageRead {
 }
 
 function makeTxConstantData(seed = 1) {
-  return new TxConstantData(makeHeader(seed), makeTxContext(seed + 0x100), new Fr(seed + 0x200), new Fr(seed + 0x201));
+  return new TxConstantData(
+    makeBlockHeader(seed),
+    makeTxContext(seed + 0x100),
+    new Fr(seed + 0x200),
+    new Fr(seed + 0x201),
+  );
 }
 
 function makePaddedTuple<T, N extends number>(
@@ -673,7 +683,7 @@ export function makePrivateCircuitPublicInputs(seed = 0): PrivateCircuitPublicIn
     endSideEffectCounter: fr(seed + 0x850),
     expectedNonRevertibleSideEffectCounter: fr(seed + 0x860),
     expectedRevertibleSideEffectCounter: fr(seed + 0x861),
-    anchorBlockHeader: makeHeader(seed + 0xd00, undefined),
+    anchorBlockHeader: makeBlockHeader(seed + 0xd00),
     txContext: makeTxContext(seed + 0x1400),
     isFeePayer: false,
   });
@@ -825,16 +835,15 @@ export function makeBlockRollupPublicInputs(seed = 0): BlockRollupPublicInputs {
 }
 
 export function makeCheckpointRollupPublicInputs(seed = 0) {
-  const startBlobAccumulator = makeBatchedBlobAccumulator(seed);
   return new CheckpointRollupPublicInputs(
     makeEpochConstantData(seed),
     makeAppendOnlyTreeSnapshot(seed + 0x100),
     makeAppendOnlyTreeSnapshot(seed + 0x200),
     makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x300),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x700),
-    startBlobAccumulator.toBlobAccumulator(),
-    makeBatchedBlobAccumulator(seed + 1).toBlobAccumulator(),
-    startBlobAccumulator.finalBlobChallenges,
+    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x400),
+    makeBlobAccumulator(seed + 0x500),
+    makeBlobAccumulator(seed + 0x600),
+    makeFinalBlobBatchingChallenges(seed + 0x700),
   );
 }
 
@@ -869,7 +878,7 @@ export function makeRootRollupPublicInputs(seed = 0): RootRollupPublicInputs {
     makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x300),
     makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x500),
     makeEpochConstantData(seed + 0x600),
-    makeBatchedBlobAccumulator(seed).toFinalBlobAccumulator(),
+    makeFinalBlobAccumulator(seed + 0x700),
   );
 }
 
@@ -880,23 +889,15 @@ export function makeContentCommitment(seed = 0): ContentCommitment {
   return new ContentCommitment(fr(seed + 0x100), fr(seed + 0x200), fr(seed + 0x300));
 }
 
-/**
- * Makes header.
- */
-export function makeHeader(
+export function makeBlockHeader(
   seed = 0,
-  blockNumber: number | undefined = undefined,
-  slotNumber: number | undefined = undefined,
-  overrides: Partial<FieldsOf<BlockHeader>> = {},
+  overrides: Partial<FieldsOf<Omit<BlockHeader, 'globalVariables'>>> & Partial<FieldsOf<GlobalVariables>> = {},
 ): BlockHeader {
   return BlockHeader.from({
     lastArchive: makeAppendOnlyTreeSnapshot(seed + 0x100),
     state: makeStateReference(seed + 0x200),
     spongeBlobHash: fr(seed + 0x300),
-    globalVariables: makeGlobalVariables((seed += 0x700), {
-      ...(blockNumber ? { blockNumber } : {}),
-      ...(slotNumber ? { slotNumber: new Fr(slotNumber) } : {}),
-    }),
+    globalVariables: makeGlobalVariables((seed += 0x700), overrides),
     totalFees: fr(seed + 0x800),
     totalManaUsed: fr(seed + 0x900),
     ...overrides,

package/src/tests/mocks.ts

@@ -17,10 +17,12 @@ import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
 import { PublicDataWrite } from '../avm/public_data_write.js';
 import { RevertCode } from '../avm/revert_code.js';
 import { AztecAddress } from '../aztec-address/index.js';
-import { CommitteeAttestation, L1PublishedData, L2BlockHeader } from '../block/index.js';
+import { CommitteeAttestation, L2BlockHeader } from '../block/index.js';
 import { L2Block } from '../block/l2_block.js';
 import type { CommitteeAttestationsAndSigners } from '../block/proposal/attestations_and_signers.js';
 import { PublishedL2Block } from '../block/published_l2_block.js';
+import type { Checkpoint } from '../checkpoint/checkpoint.js';
+import { L1PublishedData } from '../checkpoint/published_checkpoint.js';
 import { computeContractAddressFromInstance } from '../contract/contract_address.js';
 import { getContractClassFromArtifact } from '../contract/contract_class.js';
 import { SerializableContractInstance } from '../contract/contract_instance.js';
@@ -67,9 +69,9 @@ import { TxHash } from '../tx/tx_hash.js';
 import {
   makeAvmCircuitInputs,
   makeAztecAddress,
+  makeBlockHeader,
   makeGas,
   makeGlobalVariables,
-  makeHeader,
   makeL2BlockHeader,
   makePrivateToPublicAccumulatedData,
   makePrivateToRollupAccumulatedData,
@@ -211,7 +213,7 @@ export async function mockProcessedTx({
   privateOnly?: boolean;
 } & Parameters<typeof mockTx>[1] = {}) {
   seed *= 0x1000; // Avoid clashing with the previous mock values if seed only increases by 1.
-  anchorBlockHeader ??= db?.getInitialHeader() ?? makeHeader(seed);
+  anchorBlockHeader ??= db?.getInitialHeader() ?? makeBlockHeader(seed);
   feePayer ??= makeAztecAddress(seed + 0x100);
   feePaymentPublicDataWrite ??= makePublicDataWrite(seed + 0x200);
 
@@ -448,15 +450,15 @@ export const makeBlockProposal = (options?: MakeConsensusPayloadOptions): BlockP
 };
 
 // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8028)
-export const makeBlockAttestation = (options?: MakeConsensusPayloadOptions): BlockAttestation => {
-  const header = options?.header ?? makeL2BlockHeader(1);
+export const makeBlockAttestation = (options: MakeConsensusPayloadOptions = {}): BlockAttestation => {
+  const header = options.header ?? makeL2BlockHeader(1);
   const {
     signer,
-    attesterSigner = signer ?? Secp256k1Signer.random(),
-    proposerSigner = signer ?? Secp256k1Signer.random(),
+    attesterSigner = signer,
+    proposerSigner = signer,
     archive = Fr.random(),
     stateReference = header.state,
-  } = options ?? {};
+  } = options;
 
   const payload = ConsensusPayload.fromFields({
     header: header.toCheckpointHeader(),
@@ -464,15 +466,25 @@ export const makeBlockAttestation = (options?: MakeConsensusPayloadOptions): Blo
     stateReference,
   });
 
-  // Sign as attester
-  const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
-  const attestationSignature = attesterSigner.sign(attestationHash);
+  return makeBlockAttestationFromPayload(payload, attesterSigner, proposerSigner);
+};
 
-  // Sign as proposer
-  const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockProposal);
-  const proposerSignature = proposerSigner.sign(proposalHash);
+export const makeAttestationFromCheckpoint = (
+  checkpoint: Checkpoint,
+  attesterSigner?: Secp256k1Signer,
+  proposerSigner?: Secp256k1Signer,
+): BlockAttestation => {
+  const header = checkpoint.header;
+  const archive = checkpoint.archive.root;
+  const stateReference = checkpoint.blocks.at(-1)!.header.state;
 
-  return new BlockAttestation(payload, attestationSignature, proposerSignature);
+  const payload = ConsensusPayload.fromFields({
+    header,
+    archive,
+    stateReference,
+  });
+
+  return makeBlockAttestationFromPayload(payload, attesterSigner, proposerSigner);
 };
 
 export const makeBlockAttestationFromBlock = (
@@ -490,6 +502,14 @@ export const makeBlockAttestationFromBlock = (
     stateReference,
   });
 
+  return makeBlockAttestationFromPayload(payload, attesterSigner, proposerSigner);
+};
+
+export const makeBlockAttestationFromPayload = (
+  payload: ConsensusPayload,
+  attesterSigner?: Secp256k1Signer,
+  proposerSigner?: Secp256k1Signer,
+): BlockAttestation => {
   // Sign as attester
   const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
   const attestationSigner = attesterSigner ?? Secp256k1Signer.random();