@aztec/archiver 0.0.1-commit.7d4e6cd → 0.0.1-commit.858058eac

package/src/test/mock_l2_block_source.ts

@@ -8,19 +8,17 @@ import { createLogger } from '@aztec/foundation/log';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
+  BlockHash,
   CheckpointedL2Block,
   L2Block,
-  L2BlockHash,
-  L2BlockNew,
   type L2BlockSource,
   type L2Tips,
-  PublishedL2Block,
   type ValidateCheckpointResult,
 } from '@aztec/stdlib/block';
-import { type Checkpoint, L1PublishedData } from '@aztec/stdlib/checkpoint';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { EmptyL1RollupConstants, type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
-import { type BlockHeader, TxHash, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+import { type BlockHeader, TxExecutionResult, TxHash, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
 /**
@@ -38,16 +36,16 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
   public async createBlocks(numBlocks: number) {
     for (let i = 0; i < numBlocks; i++) {
       const blockNum = this.l2Blocks.length + 1;
-      const block = await L2Block.random(BlockNumber(blockNum));
+      const block = await L2Block.random(BlockNumber(blockNum), { slotNumber: SlotNumber(blockNum) });
       this.l2Blocks.push(block);
     }
 
     this.log.verbose(`Created ${numBlocks} blocks in the mock L2 block source`);
   }
 
-  public addBlocks(blocks: L2Block[]) {
+  public addProposedBlocks(blocks: L2Block[]) {
     this.l2Blocks.push(...blocks);
-    this.log.verbose(`Added ${blocks.length} blocks to the mock L2 block source`);
+    this.log.verbose(`Added ${blocks.length} proposed blocks to the mock L2 block source`);
   }
 
   public removeBlocks(numBlocks: number) {
@@ -98,6 +96,14 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return Promise.resolve(BlockNumber(this.provenBlockNumber));
   }
 
+  public getCheckpointedL2BlockNumber() {
+    return Promise.resolve(BlockNumber(this.checkpointedBlockNumber));
+  }
+
+  public getFinalizedL2BlockNumber() {
+    return Promise.resolve(BlockNumber(this.finalizedBlockNumber));
+  }
+
   public getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined> {
     if (number > this.checkpointedBlockNumber) {
       return Promise.resolve(undefined);
@@ -107,19 +113,15 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
       return Promise.resolve(undefined);
     }
     const checkpointedBlock = new CheckpointedL2Block(
-      CheckpointNumber(number),
-      block.toL2Block(),
+      CheckpointNumber.fromBlockNumber(number),
+      block,
       new L1PublishedData(BigInt(number), BigInt(number), `0x${number.toString(16).padStart(64, '0')}`),
       [],
     );
     return Promise.resolve(checkpointedBlock);
   }
 
-  public async getCheckpointedBlocks(
-    from: BlockNumber,
-    limit: number,
-    _proven?: boolean,
-  ): Promise<CheckpointedL2Block[]> {
+  public async getCheckpointedBlocks(from: BlockNumber, limit: number): Promise<CheckpointedL2Block[]> {
     const result: CheckpointedL2Block[] = [];
     for (let i = 0; i < limit; i++) {
       const blockNum = from + i;
@@ -139,8 +141,9 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
    * @param number - The block number to return (inclusive).
    * @returns The requested L2 block.
    */
-  public getBlock(number: number) {
-    return Promise.resolve(this.l2Blocks[number - 1]);
+  public getBlock(number: number): Promise<L2Block | undefined> {
+    const block = this.l2Blocks[number - 1];
+    return Promise.resolve(block);
   }
 
   /**
@@ -148,9 +151,9 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
    * @param number - The block number to return.
    * @returns The requested L2 block.
    */
-  public getL2BlockNew(number: BlockNumber): Promise<L2BlockNew | undefined> {
+  public getL2Block(number: BlockNumber): Promise<L2Block | undefined> {
     const block = this.l2Blocks[number - 1];
-    return Promise.resolve(block?.toL2Block());
+    return Promise.resolve(block);
   }
 
   /**
@@ -159,45 +162,45 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
    * @param limit - The maximum number of blocks to return.
    * @returns The requested mocked L2 blocks.
    */
-  public getBlocks(from: number, limit: number, proven?: boolean) {
-    return Promise.resolve(
-      this.l2Blocks
-        .slice(from - 1, from - 1 + limit)
-        .filter(b => !proven || this.provenBlockNumber === undefined || b.number <= this.provenBlockNumber),
-    );
-  }
-
-  public async getPublishedCheckpoints(from: CheckpointNumber, limit: number) {
-    // TODO: Implement this properly. This only works when we have one block per checkpoint.
-    return (await this.getPublishedBlocks(from, limit)).map(block => block.toPublishedCheckpoint());
-  }
-
-  public async getCheckpointByArchive(archive: Fr): Promise<Checkpoint | undefined> {
-    // TODO: Implement this properly. This only works when we have one block per checkpoint.
-    return (await this.getPublishedBlockByArchive(archive))?.block.toCheckpoint();
-  }
-
-  public async getPublishedBlocks(from: number, limit: number, proven?: boolean) {
-    const blocks = await this.getBlocks(from, limit, proven);
-    return blocks.map(block =>
-      PublishedL2Block.fromFields({
-        block,
-        l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
-        attestations: [],
+  public getBlocks(from: number, limit: number): Promise<L2Block[]> {
+    return Promise.resolve(this.l2Blocks.slice(from - 1, from - 1 + limit));
+  }
+
+  public getCheckpoints(from: CheckpointNumber, limit: number) {
+    // TODO(mbps): Implement this properly. This only works when we have one block per checkpoint.
+    const blocks = this.l2Blocks.slice(from - 1, from - 1 + limit);
+    return Promise.all(
+      blocks.map(async block => {
+        // Create a checkpoint from the block - manually construct since L2Block doesn't have toCheckpoint()
+        const checkpoint = await Checkpoint.random(block.checkpointNumber, { numBlocks: 1 });
+        checkpoint.blocks = [block];
+        return new PublishedCheckpoint(
+          checkpoint,
+          new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
+          [],
+        );
       }),
     );
   }
 
-  async getL2BlocksNew(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]> {
-    const blocks = await this.getBlocks(from, limit, proven);
-    return blocks.map(x => x.toL2Block());
+  public async getCheckpointByArchive(archive: Fr): Promise<Checkpoint | undefined> {
+    // TODO(mbps): Implement this properly. This only works when we have one block per checkpoint.
+    const block = this.l2Blocks.find(b => b.archive.root.equals(archive));
+    if (!block) {
+      return undefined;
+    }
+    // Create a checkpoint from the block - manually construct since L2Block doesn't have toCheckpoint()
+    const checkpoint = await Checkpoint.random(block.checkpointNumber, { numBlocks: 1 });
+    checkpoint.blocks = [block];
+    return checkpoint;
   }
 
-  public async getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined> {
+  public async getCheckpointedBlockByHash(blockHash: BlockHash): Promise<CheckpointedL2Block | undefined> {
     for (const block of this.l2Blocks) {
       const hash = await block.hash();
       if (hash.equals(blockHash)) {
-        return PublishedL2Block.fromFields({
+        return CheckpointedL2Block.fromFields({
+          checkpointNumber: CheckpointNumber.fromBlockNumber(block.number),
           block,
           l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
           attestations: [],
@@ -207,13 +210,14 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return undefined;
   }
 
-  public getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined> {
+  public getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined> {
     const block = this.l2Blocks.find(b => b.archive.root.equals(archive));
     if (!block) {
       return Promise.resolve(undefined);
     }
     return Promise.resolve(
-      PublishedL2Block.fromFields({
+      CheckpointedL2Block.fromFields({
+        checkpointNumber: CheckpointNumber.fromBlockNumber(block.number),
         block,
         l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
         attestations: [],
@@ -221,11 +225,26 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     );
   }
 
-  public async getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined> {
+  public async getL2BlockByHash(blockHash: BlockHash): Promise<L2Block | undefined> {
     for (const block of this.l2Blocks) {
       const hash = await block.hash();
       if (hash.equals(blockHash)) {
-        return block.getBlockHeader();
+        return block;
+      }
+    }
+    return undefined;
+  }
+
+  public getL2BlockByArchive(archive: Fr): Promise<L2Block | undefined> {
+    const block = this.l2Blocks.find(b => b.archive.root.equals(archive));
+    return Promise.resolve(block);
+  }
+
+  public async getBlockHeaderByHash(blockHash: BlockHash): Promise<BlockHeader | undefined> {
+    for (const block of this.l2Blocks) {
+      const hash = await block.hash();
+      if (hash.equals(blockHash)) {
+        return block.header;
       }
     }
     return undefined;
@@ -233,31 +252,58 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
 
   public getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined> {
     const block = this.l2Blocks.find(b => b.archive.root.equals(archive));
-    return Promise.resolve(block?.getBlockHeader());
+    return Promise.resolve(block?.header);
   }
 
   getBlockHeader(number: number | 'latest'): Promise<BlockHeader | undefined> {
-    return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.getBlockHeader());
+    return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.header);
   }
 
   getCheckpointsForEpoch(epochNumber: EpochNumber): Promise<Checkpoint[]> {
-    // TODO: Implement this properly. This only works when we have one block per checkpoint.
-    return this.getBlocksForEpoch(epochNumber).then(blocks => blocks.map(b => b.toCheckpoint()));
+    // TODO(mbps): Implement this properly. This only works when we have one block per checkpoint.
+    const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
+    const [start, end] = getSlotRangeForEpoch(epochNumber, { epochDuration });
+    const blocks = this.l2Blocks.filter(b => {
+      const slot = b.header.globalVariables.slotNumber;
+      return slot >= start && slot <= end;
+    });
+    // Create checkpoints from blocks - manually construct since L2Block doesn't have toCheckpoint()
+    return Promise.all(
+      blocks.map(async block => {
+        const checkpoint = await Checkpoint.random(block.checkpointNumber, { numBlocks: 1 });
+        checkpoint.blocks = [block];
+        return checkpoint;
+      }),
+    );
   }
 
-  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]> {
+  getCheckpointedBlocksForEpoch(epochNumber: EpochNumber): Promise<CheckpointedL2Block[]> {
     const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
     const [start, end] = getSlotRangeForEpoch(epochNumber, { epochDuration });
     const blocks = this.l2Blocks.filter(b => {
       const slot = b.header.globalVariables.slotNumber;
       return slot >= start && slot <= end;
     });
+    return Promise.resolve(
+      blocks.map(block =>
+        CheckpointedL2Block.fromFields({
+          checkpointNumber: CheckpointNumber.fromBlockNumber(block.number),
+          block,
+          l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
+          attestations: [],
+        }),
+      ),
+    );
+  }
+
+  getBlocksForSlot(slotNumber: SlotNumber): Promise<L2Block[]> {
+    const blocks = this.l2Blocks.filter(b => b.header.globalVariables.slotNumber === slotNumber);
     return Promise.resolve(blocks);
   }
 
-  async getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
-    const blocks = await this.getBlocksForEpoch(epochNumber);
-    return blocks.map(b => b.getBlockHeader());
+  async getCheckpointedBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
+    const checkpointedBlocks = await this.getCheckpointedBlocksForEpoch(epochNumber);
+    return checkpointedBlocks.map(b => b.block.header);
   }
 
   /**
@@ -276,7 +322,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     return {
       data: txEffect,
       l2BlockNumber: block.number,
-      l2BlockHash: L2BlockHash.fromField(await block.hash()),
+      l2BlockHash: await block.hash(),
       txIndexInBlock: block.body.txEffects.indexOf(txEffect),
     };
   }
@@ -290,12 +336,14 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
     for (const block of this.l2Blocks) {
       for (const txEffect of block.body.txEffects) {
         if (txEffect.txHash.equals(txHash)) {
+          // In mock, assume all txs are checkpointed with successful execution
           return new TxReceipt(
             txHash,
-            TxStatus.SUCCESS,
-            '',
+            TxStatus.CHECKPOINTED,
+            TxExecutionResult.SUCCESS,
+            undefined,
             txEffect.transactionFee.toBigInt(),
-            L2BlockHash.fromField(await block.hash()),
+            await block.hash(),
             block.number,
           );
         }
@@ -336,7 +384,7 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
 
     const makeTipId = (blockId: typeof latestBlockId) => ({
       block: blockId,
-      checkpoint: { number: CheckpointNumber(blockId.number), hash: blockId.hash },
+      checkpoint: { number: CheckpointNumber.fromBlockNumber(blockId.number), hash: blockId.hash },
     });
 
     return {

package/src/test/mock_structs.ts

@@ -1,10 +1,28 @@
-import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import {
+  MAX_NOTE_HASHES_PER_TX,
+  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+  PRIVATE_LOG_SIZE_IN_FIELDS,
+} from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { BlockNumber, CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
+import { times, timesParallel } from '@aztec/foundation/collection';
 import { randomBigInt, randomInt } from '@aztec/foundation/crypto/random';
+import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { CommitteeAttestation, L2Block } from '@aztec/stdlib/block';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { PrivateLog, PublicLog, SiloedTag, Tag } from '@aztec/stdlib/logs';
 import { InboxLeaf } from '@aztec/stdlib/messaging';
+import { orderAttestations } from '@aztec/stdlib/p2p';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { makeCheckpointAttestationFromCheckpoint } from '@aztec/stdlib/testing';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { PartialStateReference, StateReference, TxEffect } from '@aztec/stdlib/tx';
 
-import { type InboxMessage, updateRollingHash } from '../archiver/structs/inbox_message.js';
+import { type InboxMessage, updateRollingHash } from '../structs/inbox_message.js';
 
 export function makeInboxMessage(
   previousRollingHash = Buffer16.ZERO,
@@ -28,23 +46,266 @@ export function makeInboxMessage(
 }
 
 export function makeInboxMessages(
-  count: number,
+  totalCount: number,
   opts: {
     initialHash?: Buffer16;
     initialCheckpointNumber?: CheckpointNumber;
+    messagesPerCheckpoint?: number;
     overrideFn?: (msg: InboxMessage, index: number) => InboxMessage;
   } = {},
 ): InboxMessage[] {
-  const { initialHash = Buffer16.ZERO, overrideFn = msg => msg, initialCheckpointNumber = 1 } = opts;
+  const {
+    initialHash = Buffer16.ZERO,
+    overrideFn = msg => msg,
+    initialCheckpointNumber = CheckpointNumber(1),
+    messagesPerCheckpoint = 1,
+  } = opts;
+
   const messages: InboxMessage[] = [];
   let rollingHash = initialHash;
-  for (let i = 0; i < count; i++) {
+  for (let i = 0; i < totalCount; i++) {
+    const msgIndex = i % messagesPerCheckpoint;
+    const checkpointNumber = CheckpointNumber.fromBigInt(
+      BigInt(initialCheckpointNumber) + BigInt(i) / BigInt(messagesPerCheckpoint),
+    );
     const leaf = Fr.random();
-    const checkpointNumber = CheckpointNumber(i + initialCheckpointNumber);
-    const message = overrideFn(makeInboxMessage(rollingHash, { leaf, checkpointNumber }), i);
+    const message = overrideFn(
+      makeInboxMessage(rollingHash, {
+        leaf,
+        checkpointNumber,
+        index: InboxLeaf.smallestIndexForCheckpoint(checkpointNumber) + BigInt(msgIndex),
+      }),
+      i,
+    );
     rollingHash = message.rollingHash;
     messages.push(message);
   }
-
   return messages;
 }
+
+/** Creates inbox messages distributed across multiple blocks with proper checkpoint numbering. */
+export function makeInboxMessagesWithFullBlocks(
+  blockCount: number,
+  opts: { initialCheckpointNumber?: CheckpointNumber } = {},
+): InboxMessage[] {
+  const { initialCheckpointNumber = CheckpointNumber(13) } = opts;
+  return makeInboxMessages(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * blockCount, {
+    overrideFn: (msg, i) => {
+      const checkpointNumber = CheckpointNumber(
+        initialCheckpointNumber + Math.floor(i / NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
+      );
+      const index =
+        InboxLeaf.smallestIndexForCheckpoint(checkpointNumber) + BigInt(i % NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+      return { ...msg, checkpointNumber, index };
+    },
+  });
+}
+
+/** Creates a deterministic block hash from a block number. */
+export function makeBlockHash(blockNumber: number): `0x${string}` {
+  return `0x${blockNumber.toString(16).padStart(64, '0')}`;
+}
+
+/**
+ * Creates a StateReference with properly calculated noteHashTree.nextAvailableLeafIndex.
+ * This ensures LogStore's dataStartIndexForBlock calculation doesn't produce negative values.
+ */
+export function makeStateForBlock(blockNumber: number, txsPerBlock: number): StateReference {
+  const noteHashIndex = blockNumber * txsPerBlock * MAX_NOTE_HASHES_PER_TX;
+  return new StateReference(
+    AppendOnlyTreeSnapshot.random(),
+    new PartialStateReference(
+      new AppendOnlyTreeSnapshot(Fr.random(), noteHashIndex),
+      AppendOnlyTreeSnapshot.random(),
+      AppendOnlyTreeSnapshot.random(),
+    ),
+  );
+}
+
+/** Creates L1PublishedData with deterministic values based on l1BlockNumber. */
+export function makeL1PublishedData(l1BlockNumber: number): L1PublishedData {
+  return new L1PublishedData(BigInt(l1BlockNumber), BigInt(l1BlockNumber * 1000), makeBlockHash(l1BlockNumber));
+}
+
+/** Wraps a Checkpoint with L1 published data and random attestations. */
+export function makePublishedCheckpoint(
+  checkpoint: Checkpoint,
+  l1BlockNumber: number,
+  attestationCount = 3,
+): PublishedCheckpoint {
+  return new PublishedCheckpoint(
+    checkpoint,
+    makeL1PublishedData(l1BlockNumber),
+    times(attestationCount, CommitteeAttestation.random),
+  );
+}
+
+export interface MakeChainedCheckpointsOptions {
+  /** Number of L2 blocks per checkpoint. Default: 1 */
+  blocksPerCheckpoint?: number;
+  /** Number of transactions per block. Default: 4 */
+  txsPerBlock?: number;
+  /** Starting checkpoint number. Default: CheckpointNumber(1) */
+  startCheckpointNumber?: CheckpointNumber;
+  /** Starting block number. Default: 1 */
+  startBlockNumber?: number;
+  /** Starting L1 block number. Default: 10 */
+  startL1BlockNumber?: number;
+  /** Previous archive to chain from. Default: undefined */
+  previousArchive?: AppendOnlyTreeSnapshot;
+  /** Optional function to provide per-checkpoint overrides */
+  makeCheckpointOptions?: (cpNumber: CheckpointNumber) => Partial<Parameters<typeof Checkpoint.random>[1]>;
+}
+
+/**
+ * Creates multiple checkpoints with properly chained archives.
+ * Each checkpoint's blocks have their lastArchive set to the previous block's archive,
+ * ensuring archive chain continuity for testing.
+ */
+export async function makeChainedCheckpoints(
+  count: number,
+  options: MakeChainedCheckpointsOptions = {},
+): Promise<PublishedCheckpoint[]> {
+  const {
+    blocksPerCheckpoint = 1,
+    txsPerBlock = 4,
+    startCheckpointNumber = CheckpointNumber(1),
+    startBlockNumber = 1,
+    startL1BlockNumber = 10,
+    makeCheckpointOptions,
+  } = options;
+
+  let previousArchive = options.previousArchive;
+  const checkpoints: PublishedCheckpoint[] = [];
+
+  for (let i = 0; i < count; i++) {
+    const cpNumber = CheckpointNumber(startCheckpointNumber + i);
+    const blockStart = startBlockNumber + i * blocksPerCheckpoint;
+    const customOptions = makeCheckpointOptions?.(cpNumber) ?? {};
+
+    const checkpoint = await Checkpoint.random(cpNumber, {
+      numBlocks: blocksPerCheckpoint,
+      startBlockNumber: blockStart,
+      previousArchive,
+      txsPerBlock,
+      state: makeStateForBlock(blockStart, txsPerBlock),
+      txOptions: { numPublicCallsPerTx: 2, numPublicLogsPerCall: 2 },
+      ...customOptions,
+    });
+
+    previousArchive = checkpoint.blocks.at(-1)!.archive;
+    checkpoints.push(makePublishedCheckpoint(checkpoint, startL1BlockNumber + i * 10));
+  }
+
+  return checkpoints;
+}
+
+/**
+ * Creates a PublishedCheckpoint with attestations signed by the provided signers.
+ * Useful for testing attestation validation.
+ */
+export function makeSignedPublishedCheckpoint(
+  checkpoint: Checkpoint,
+  signers: Secp256k1Signer[],
+  committee: EthAddress[],
+  l1BlockNumber = 1,
+): PublishedCheckpoint {
+  const attestations = signers.map(signer => makeCheckpointAttestationFromCheckpoint(checkpoint, signer));
+  const committeeAttestations = orderAttestations(attestations, committee);
+  return new PublishedCheckpoint(checkpoint, makeL1PublishedData(l1BlockNumber), committeeAttestations);
+}
+
+/** Creates a deterministic SiloedTag for private log testing. */
+export function makePrivateLogTag(blockNumber: number, txIndex: number, logIndex: number): SiloedTag {
+  return new SiloedTag(
+    blockNumber === 1 && txIndex === 0 && logIndex === 0
+      ? Fr.ZERO
+      : new Fr(blockNumber * 100 + txIndex * 10 + logIndex),
+  );
+}
+
+/** Creates a PrivateLog with fields derived from the tag. */
+export function makePrivateLog(tag: SiloedTag): PrivateLog {
+  return PrivateLog.from({
+    fields: makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, i => (!i ? tag.value : new Fr(tag.value.toBigInt() + BigInt(i)))),
+    emittedLength: PRIVATE_LOG_SIZE_IN_FIELDS,
+  });
+}
+
+/** Creates multiple private logs for a transaction. */
+export function mockPrivateLogs(blockNumber: number, txIndex: number, numLogsPerTx: number): PrivateLog[] {
+  return times(numLogsPerTx, logIndex => {
+    const tag = makePrivateLogTag(blockNumber, txIndex, logIndex);
+    return makePrivateLog(tag);
+  });
+}
+
+/** Creates a deterministic Tag for public log testing. */
+export function makePublicLogTag(blockNumber: number, txIndex: number, logIndex: number): Tag {
+  return new Tag(
+    blockNumber === 1 && txIndex === 0 && logIndex === 0
+      ? Fr.ZERO
+      : new Fr((blockNumber * 100 + txIndex * 10 + logIndex) * 123),
+  );
+}
+
+/** Creates a PublicLog with fields derived from the tag. */
+export function makePublicLog(tag: Tag, contractAddress: AztecAddress = AztecAddress.fromNumber(543254)): PublicLog {
+  return PublicLog.from({
+    contractAddress,
+    fields: new Array(10).fill(null).map((_, i) => (!i ? tag.value : new Fr(tag.value.toBigInt() + BigInt(i)))),
+  });
+}
+
+/** Creates multiple public logs for a transaction. */
+export function makePublicLogs(
+  blockNumber: number,
+  txIndex: number,
+  numLogsPerTx: number,
+  contractAddress: AztecAddress = AztecAddress.fromNumber(543254),
+): PublicLog[] {
+  return times(numLogsPerTx, logIndex => {
+    const tag = makePublicLogTag(blockNumber, txIndex, logIndex);
+    return makePublicLog(tag, contractAddress);
+  });
+}
+
+export interface MockCheckpointWithLogsOptions {
+  previousArchive?: AppendOnlyTreeSnapshot;
+  numTxsPerBlock?: number;
+  privateLogs?: { numLogsPerTx: number };
+  publicLogs?: { numLogsPerTx: number; contractAddress?: AztecAddress };
+}
+
+/** Creates a checkpoint with specified logs on each tx effect. */
+export async function makeCheckpointWithLogs(
+  blockNumber: number,
+  options: MockCheckpointWithLogsOptions = {},
+): Promise<PublishedCheckpoint> {
+  const { previousArchive, numTxsPerBlock = 4, privateLogs, publicLogs } = options;
+
+  const block = await L2Block.random(BlockNumber(blockNumber), {
+    checkpointNumber: CheckpointNumber.fromBlockNumber(BlockNumber(blockNumber)),
+    indexWithinCheckpoint: IndexWithinCheckpoint(0),
+    state: makeStateForBlock(blockNumber, numTxsPerBlock),
+    ...(previousArchive ? { lastArchive: previousArchive } : {}),
+  });
+  block.header.globalVariables.blockNumber = BlockNumber(blockNumber);
+
+  block.body.txEffects = await timesParallel(numTxsPerBlock, async (txIndex: number) => {
+    const txEffect = await TxEffect.random();
+    txEffect.privateLogs = privateLogs ? mockPrivateLogs(blockNumber, txIndex, privateLogs.numLogsPerTx) : [];
+    txEffect.publicLogs = publicLogs
+      ? makePublicLogs(blockNumber, txIndex, publicLogs.numLogsPerTx, publicLogs.contractAddress)
+      : [];
+    return txEffect;
+  });
+
+  const checkpoint = new Checkpoint(
+    AppendOnlyTreeSnapshot.random(),
+    CheckpointHeader.random(),
+    [block],
+    CheckpointNumber.fromBlockNumber(BlockNumber(blockNumber)),
+  );
+  return makePublishedCheckpoint(checkpoint, blockNumber);
+}