@aztec/archiver 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/src/test/mock_structs.ts

@@ -1,26 +1,44 @@
-import { BlockNumber } 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 { randomBigInt, randomInt } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+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,
   overrides: Partial<InboxMessage> = {},
 ): InboxMessage {
-  const { l2BlockNumber = randomInt(100) + 1 } = overrides;
+  const { checkpointNumber = CheckpointNumber(randomInt(100) + 1) } = overrides;
   const { l1BlockNumber = randomBigInt(100n) + 1n } = overrides;
   const { l1BlockHash = Buffer32.random() } = overrides;
   const { leaf = Fr.random() } = overrides;
   const { rollingHash = updateRollingHash(previousRollingHash, leaf) } = overrides;
-  const { index = InboxLeaf.smallestIndexFromL2Block(l2BlockNumber) } = overrides;
+  const { index = InboxLeaf.smallestIndexForCheckpoint(checkpointNumber) } = overrides;
 
   return {
     index,
     leaf,
-    l2BlockNumber: BlockNumber(l2BlockNumber),
+    checkpointNumber,
     l1BlockNumber,
     l1BlockHash,
     rollingHash,
@@ -28,23 +46,283 @@ export function makeInboxMessage(
 }
 
 export function makeInboxMessages(
-  count: number,
+  totalCount: number,
   opts: {
     initialHash?: Buffer16;
-    initialL2BlockNumber?: number;
+    initialCheckpointNumber?: CheckpointNumber;
+    messagesPerCheckpoint?: number;
     overrideFn?: (msg: InboxMessage, index: number) => InboxMessage;
   } = {},
 ): InboxMessage[] {
-  const { initialHash = Buffer16.ZERO, overrideFn = msg => msg, initialL2BlockNumber = 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 l2BlockNumber = BlockNumber(i + initialL2BlockNumber);
-    const message = overrideFn(makeInboxMessage(rollingHash, { leaf, l2BlockNumber }), 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));
+}
+
+/** Creates a Checkpoint from a list of blocks with a header that matches the blocks' structure. */
+export function makeCheckpoint(blocks: L2Block[], checkpointNumber = CheckpointNumber(1)): Checkpoint {
+  const firstBlock = blocks[0];
+  const { slotNumber, timestamp, coinbase, feeRecipient, gasFees } = firstBlock.header.globalVariables;
+  return new Checkpoint(
+    blocks.at(-1)!.archive,
+    CheckpointHeader.random({
+      lastArchiveRoot: firstBlock.header.lastArchive.root,
+      slotNumber,
+      timestamp,
+      coinbase,
+      feeRecipient,
+      gasFees,
+    }),
+    blocks,
+    checkpointNumber,
+  );
+}
+
+/** 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.fromNumberUnsafe(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.fromNumberUnsafe(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 = makeCheckpoint([block], CheckpointNumber.fromBlockNumber(BlockNumber(blockNumber)));
+  return makePublishedCheckpoint(checkpoint, blockNumber);
+}

package/src/test/noop_l1_archiver.ts

@@ -0,0 +1,158 @@
+import type { BlobClientInterface } from '@aztec/blob-client/client';
+import type { OutboxContract, RollupContract } from '@aztec/ethereum/contracts';
+import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { DateProvider } from '@aztec/foundation/timer';
+import type { FunctionsOf } from '@aztec/foundation/types';
+import type { ArchiverEmitter, BlockHash, L2Block } from '@aztec/stdlib/block';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+import { type TelemetryClient, type Tracer, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { mock } from 'jest-mock-extended';
+import { EventEmitter } from 'node:events';
+
+import { Archiver } from '../archiver.js';
+import { ArchiverInstrumentation } from '../modules/instrumentation.js';
+import type { ArchiverL1Synchronizer } from '../modules/l1_synchronizer.js';
+import type { ArchiverDataStores } from '../store/data_stores.js';
+import { L2TipsCache } from '../store/l2_tips_cache.js';
+
+type NoopL1ArchiverConfigOverrides = Partial<{
+  skipOrphanProposedBlockPruning: boolean;
+}>;
+
+/** Noop L1 synchronizer for testing without L1 connectivity. */
+class NoopL1Synchronizer implements FunctionsOf<ArchiverL1Synchronizer> {
+  public readonly tracer: Tracer;
+
+  constructor(tracer: Tracer) {
+    this.tracer = tracer;
+  }
+
+  setConfig(_config: unknown) {}
+  getL1BlockNumber(): bigint | undefined {
+    return 0n;
+  }
+  getL1Timestamp(): bigint | undefined {
+    return undefined;
+  }
+  testEthereumNodeSynced(): Promise<void> {
+    return Promise.resolve();
+  }
+  syncFromL1(_initialSyncComplete: boolean): Promise<L2Block[]> {
+    return Promise.resolve([]);
+  }
+}
+
+/**
+ * Archiver with mocked L1 connectivity for testing.
+ * Uses mock L1 clients and a noop synchronizer, enabling tests that
+ * don't require real Ethereum connectivity.
+ */
+export class NoopL1Archiver extends Archiver {
+  constructor(
+    dataStores: ArchiverDataStores,
+    l1Constants: L1RollupConstants & { genesisArchiveRoot: Fr },
+    instrumentation: ArchiverInstrumentation,
+    initialHeader: BlockHeader,
+    initialBlockHash: BlockHash,
+    l2TipsCache: L2TipsCache,
+    dateProvider: DateProvider = new DateProvider(),
+    configOverrides: NoopL1ArchiverConfigOverrides = {},
+  ) {
+    // Create mocks for L1 clients
+    const publicClient = mock<ViemPublicClient>();
+    const debugClient = mock<ViemPublicDebugClient>();
+    const rollup = mock<RollupContract>();
+    const outbox = mock<OutboxContract>();
+    const blobClient = mock<BlobClientInterface>();
+
+    // Mock methods called during start()
+    blobClient.testSources.mockResolvedValue();
+    publicClient.getBlockNumber.mockResolvedValue(1n);
+
+    const events = new EventEmitter() as ArchiverEmitter;
+    const synchronizer = new NoopL1Synchronizer(instrumentation.tracer);
+
+    super(
+      publicClient,
+      debugClient,
+      rollup,
+      outbox,
+      {
+        rollupAddress: EthAddress.ZERO,
+        registryAddress: EthAddress.ZERO,
+        inboxAddress: EthAddress.ZERO,
+        governanceProposerAddress: EthAddress.ZERO,
+        slashingProposerAddress: EthAddress.ZERO,
+      },
+      dataStores,
+      {
+        pollingIntervalMs: 1000,
+        batchSize: 100,
+        skipValidateCheckpointAttestations: true,
+        maxAllowedEthClientDriftSeconds: 300,
+        ethereumAllowNoDebugHosts: true, // Skip trace validation
+        skipHistoricalLogsCheck: true, // Skip historical logs validation
+        checkpointProposalSyncGrace: 4,
+        orphanPruneNoProposalTolerance: 1,
+        skipOrphanProposedBlockPruning: true,
+        blockDuration: 2,
+        ...configOverrides,
+      },
+      blobClient,
+      instrumentation,
+      { ...l1Constants, l1StartBlockHash: Buffer32.random() },
+      synchronizer as ArchiverL1Synchronizer,
+      events,
+      initialHeader,
+      initialBlockHash,
+      l2TipsCache,
+      dateProvider,
+    );
+  }
+
+  /** Override start to skip L1 validation checks. */
+  public override start(_blockUntilSynced?: boolean): Promise<void> {
+    // Just start the running promise without L1 checks
+    this.runningPromise.start();
+    return Promise.resolve();
+  }
+
+  /** Always reports as fully synced since there is no real L1 to sync from. */
+  public override getSyncedL2SlotNumber(): Promise<SlotNumber | undefined> {
+    return Promise.resolve(SlotNumber(Number.MAX_SAFE_INTEGER));
+  }
+}
+
+/** Creates an archiver with mocked L1 connectivity for testing. */
+export async function createNoopL1Archiver(
+  dataStores: ArchiverDataStores,
+  l1Constants: L1RollupConstants & { genesisArchiveRoot: Fr },
+  telemetry: TelemetryClient = getTelemetryClient(),
+  initialHeader: BlockHeader,
+  dateProvider?: DateProvider,
+  configOverrides?: NoopL1ArchiverConfigOverrides,
+): Promise<NoopL1Archiver> {
+  const instrumentation = await ArchiverInstrumentation.new(telemetry, () => dataStores.db.estimateSize());
+  // Mirror the production factory: precompute the dynamic genesis block hash from the injected
+  // initial header so `L2TipsCache` reports the correct tip hash at block 0. Without this, the
+  // cache falls back to the static `GENESIS_BLOCK_HEADER_HASH`, which only matches deployments
+  // with default empty genesis.
+  const initialBlockHash = await initialHeader.hash();
+  const l2TipsCache = new L2TipsCache(dataStores.blocks, initialBlockHash);
+  return new NoopL1Archiver(
+    dataStores,
+    l1Constants,
+    instrumentation,
+    initialHeader,
+    initialBlockHash,
+    l2TipsCache,
+    dateProvider,
+    configOverrides,
+  );
+}