@aztec/archiver 0.0.0-test.0

package/src/archiver/structs/data_retrieval.ts

@@ -0,0 +1,27 @@
+/**
+ * Data retrieved from logs
+ */
+export type DataRetrieval<T> = {
+  /**
+   * Blocknumber of the last L1 block from which we obtained data.
+   */
+  lastProcessedL1BlockNumber: bigint;
+  /**
+   * The data returned.
+   */
+  retrievedData: T[];
+};
+
+/**
+ * Data retrieved from logs
+ */
+export type SingletonDataRetrieval<T> = {
+  /**
+   * Blocknumber of the last L1 block from which we obtained data.
+   */
+  lastProcessedL1BlockNumber: bigint;
+  /**
+   * The data returned.
+   */
+  retrievedData: T;
+};

package/src/archiver/structs/published.ts

@@ -0,0 +1,11 @@
+/** Extends a type with L1 published info (block number, hash, and timestamp) */
+export type L1Published<T> = {
+  data: T;
+  l1: L1PublishedData;
+};
+
+export type L1PublishedData = {
+  blockNumber: bigint;
+  timestamp: bigint;
+  blockHash: string;
+};

package/src/factory.ts

@@ -0,0 +1,107 @@
+import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
+import { createLogger } from '@aztec/foundation/log';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import { createStore } from '@aztec/kv-store/lmdb-v2';
+import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
+import { TokenBridgeContractArtifact } from '@aztec/noir-contracts.js/TokenBridge';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractNames, protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { BundledProtocolContractsProvider } from '@aztec/protocol-contracts/providers/bundle';
+import { FunctionType, decodeFunctionSignature } from '@aztec/stdlib/abi';
+import type { L2BlockSourceEventEmitter } from '@aztec/stdlib/block';
+import {
+  type ContractClassPublic,
+  computePublicBytecodeCommitment,
+  getContractClassFromArtifact,
+} from '@aztec/stdlib/contract';
+import type { ArchiverApi, Service } from '@aztec/stdlib/interfaces/server';
+import { getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { Archiver } from './archiver/archiver.js';
+import type { ArchiverConfig } from './archiver/config.js';
+import { KVArchiverDataStore } from './archiver/index.js';
+import { createArchiverClient } from './rpc/index.js';
+
+/**
+ * Creates a local archiver.
+ * @param config - The archiver configuration.
+ * @param blobSinkClient - The blob sink client.
+ * @param opts - The options.
+ * @param telemetry - The telemetry client.
+ * @returns The local archiver.
+ */
+export async function createArchiver(
+  config: ArchiverConfig & DataStoreConfig,
+  blobSinkClient: BlobSinkClientInterface,
+  opts: { blockUntilSync: boolean } = { blockUntilSync: true },
+  telemetry: TelemetryClient = getTelemetryClient(),
+): Promise<ArchiverApi & Service & L2BlockSourceEventEmitter> {
+  const store = await createStore(
+    'archiver',
+    KVArchiverDataStore.SCHEMA_VERSION,
+    config,
+    createLogger('archiver:lmdb'),
+  );
+  const archiverStore = new KVArchiverDataStore(store, config.maxLogs);
+  await registerProtocolContracts(archiverStore);
+  await registerCommonContracts(archiverStore);
+  return Archiver.createAndSync(config, archiverStore, { telemetry, blobSinkClient }, opts.blockUntilSync);
+}
+
+/**
+ * Creates a remote archiver client.
+ * @param config - The archiver configuration.
+ * @returns The remote archiver client.
+ */
+export function createRemoteArchiver(config: ArchiverConfig): ArchiverApi {
+  if (!config.archiverUrl) {
+    throw new Error('Archiver URL is required');
+  }
+
+  return createArchiverClient(
+    config.archiverUrl,
+    getComponentsVersionsFromConfig(config, protocolContractTreeRoot, getVKTreeRoot()),
+  );
+}
+
+async function registerProtocolContracts(store: KVArchiverDataStore) {
+  const blockNumber = 0;
+  for (const name of protocolContractNames) {
+    const provider = new BundledProtocolContractsProvider();
+    const contract = await provider.getProtocolContractArtifact(name);
+    const contractClassPublic: ContractClassPublic = {
+      ...contract.contractClass,
+      privateFunctions: [],
+      unconstrainedFunctions: [],
+    };
+
+    const publicFunctionSignatures = contract.artifact.functions
+      .filter(fn => fn.functionType === FunctionType.PUBLIC)
+      .map(fn => decodeFunctionSignature(fn.name, fn.parameters));
+
+    await store.registerContractFunctionSignatures(contract.address, publicFunctionSignatures);
+    const bytecodeCommitment = await computePublicBytecodeCommitment(contractClassPublic.packedBytecode);
+    await store.addContractClasses([contractClassPublic], [bytecodeCommitment], blockNumber);
+    await store.addContractInstances([contract.instance], blockNumber);
+  }
+}
+
+// TODO(#10007): Remove this method. We are explicitly registering these contracts
+// here to ensure they are available to all nodes and all prover nodes, since the PXE
+// was tweaked to automatically push contract classes to the node it is registered,
+// but other nodes in the network may require the contract classes to be registered as well.
+// TODO(#10007): Remove the dependency on noir-contracts.js from this package once we remove this.
+async function registerCommonContracts(store: KVArchiverDataStore) {
+  const blockNumber = 0;
+  const artifacts = [TokenBridgeContractArtifact, TokenContractArtifact];
+  const classes = await Promise.all(
+    artifacts.map(async artifact => ({
+      ...(await getContractClassFromArtifact(artifact)),
+      privateFunctions: [],
+      unconstrainedFunctions: [],
+    })),
+  );
+  const bytecodeCommitments = await Promise.all(classes.map(x => computePublicBytecodeCommitment(x.packedBytecode)));
+  await store.addContractClasses(classes, bytecodeCommitments, blockNumber);
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './archiver/index.js';
+export * from './factory.js';
+export * from './rpc/index.js';
+
+export { retrieveBlocksFromRollup, retrieveL2ProofVerifiedEvents } from './archiver/data_retrieval.js';

package/src/rpc/index.ts

@@ -0,0 +1,20 @@
+import { createSafeJsonRpcClient } from '@aztec/foundation/json-rpc/client';
+import { type ArchiverApi, ArchiverApiSchema } from '@aztec/stdlib/interfaces/server';
+import { type ComponentsVersions, getVersioningResponseHandler } from '@aztec/stdlib/versioning';
+import { createTracedJsonRpcServer, makeTracedFetch } from '@aztec/telemetry-client';
+
+export function createArchiverClient(
+  url: string,
+  versions: Partial<ComponentsVersions>,
+  fetch = makeTracedFetch([1, 2, 3], true),
+): ArchiverApi {
+  return createSafeJsonRpcClient<ArchiverApi>(url, ArchiverApiSchema, {
+    namespaceMethods: 'archiver',
+    fetch,
+    onResponse: getVersioningResponseHandler(versions),
+  });
+}
+
+export function createArchiverRpcServer(handler: ArchiverApi) {
+  return createTracedJsonRpcServer(handler, ArchiverApiSchema);
+}

package/src/test/index.ts

@@ -0,0 +1,3 @@
+export * from './mock_l2_block_source.js';
+export * from './mock_l1_to_l2_message_source.js';
+export * from './mock_archiver.js';

package/src/test/mock_archiver.ts

@@ -0,0 +1,57 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { L2Block, L2BlockSource } from '@aztec/stdlib/block';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+
+import { MockL1ToL2MessageSource } from './mock_l1_to_l2_message_source.js';
+import { MockL2BlockSource } from './mock_l2_block_source.js';
+
+/**
+ * A mocked implementation of the archiver that implements L2BlockSource and L1ToL2MessageSource.
+ */
+export class MockArchiver extends MockL2BlockSource implements L2BlockSource, L1ToL2MessageSource {
+  private messageSource = new MockL1ToL2MessageSource(0);
+
+  public setL1ToL2Messages(blockNumber: number, msgs: Fr[]) {
+    this.messageSource.setL1ToL2Messages(blockNumber, msgs);
+  }
+
+  getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
+    return this.messageSource.getL1ToL2Messages(blockNumber);
+  }
+
+  getL1ToL2MessageIndex(_l1ToL2Message: Fr): Promise<bigint | undefined> {
+    return this.messageSource.getL1ToL2MessageIndex(_l1ToL2Message);
+  }
+}
+
+/**
+ * A mocked implementation of the archiver with a set of precomputed blocks and messages.
+ */
+export class MockPrefilledArchiver extends MockArchiver {
+  private precomputed: L2Block[];
+
+  constructor(precomputed: L2Block[], messages: Fr[][]) {
+    super();
+    this.precomputed = precomputed.slice();
+    messages.forEach((msgs, i) => this.setL1ToL2Messages(i + 1, msgs));
+  }
+
+  public setPrefilledBlocks(blocks: L2Block[], messages: Fr[][]) {
+    for (const block of blocks) {
+      this.precomputed[block.number - 1] = block;
+    }
+    messages.forEach((msgs, i) => this.setL1ToL2Messages(blocks[i].number, msgs));
+  }
+
+  public override createBlocks(numBlocks: number) {
+    if (this.l2Blocks.length + numBlocks > this.precomputed.length) {
+      throw new Error(
+        `Not enough precomputed blocks to create ${numBlocks} more blocks (already at ${this.l2Blocks.length})`,
+      );
+    }
+
+    const fromBlock = this.l2Blocks.length;
+    this.addBlocks(this.precomputed.slice(fromBlock, fromBlock + numBlocks));
+    return Promise.resolve();
+  }
+}

package/src/test/mock_l1_to_l2_message_source.ts

@@ -0,0 +1,31 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+
+/**
+ * A mocked implementation of L1ToL2MessageSource to be used in tests.
+ */
+export class MockL1ToL2MessageSource implements L1ToL2MessageSource {
+  private messagesPerBlock = new Map<number, Fr[]>();
+
+  constructor(private blockNumber: number) {}
+
+  public setL1ToL2Messages(blockNumber: number, msgs: Fr[]) {
+    this.messagesPerBlock.set(blockNumber, msgs);
+  }
+
+  public setBlockNumber(blockNumber: number) {
+    this.blockNumber = blockNumber;
+  }
+
+  getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
+    return Promise.resolve(this.messagesPerBlock.get(Number(blockNumber)) ?? []);
+  }
+
+  getL1ToL2MessageIndex(_l1ToL2Message: Fr): Promise<bigint | undefined> {
+    throw new Error('Method not implemented.');
+  }
+
+  getBlockNumber(): Promise<number> {
+    return Promise.resolve(this.blockNumber);
+  }
+}

package/src/test/mock_l2_block_source.ts

@@ -0,0 +1,204 @@
+import { DefaultL1ContractsConfig } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { L2Block, L2BlockHash, type L2BlockSource, type L2Tips } from '@aztec/stdlib/block';
+import { type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import { type BlockHeader, TxHash, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+
+/**
+ * A mocked implementation of L2BlockSource to be used in tests.
+ */
+export class MockL2BlockSource implements L2BlockSource {
+  protected l2Blocks: L2Block[] = [];
+
+  private provenBlockNumber: number = 0;
+
+  private log = createLogger('archiver:mock_l2_block_source');
+
+  public async createBlocks(numBlocks: number) {
+    for (let i = 0; i < numBlocks; i++) {
+      const blockNum = this.l2Blocks.length + 1;
+      const block = await L2Block.random(blockNum);
+      this.l2Blocks.push(block);
+    }
+
+    this.log.verbose(`Created ${numBlocks} blocks in the mock L2 block source`);
+  }
+
+  public addBlocks(blocks: L2Block[]) {
+    this.l2Blocks.push(...blocks);
+    this.log.verbose(`Added ${blocks.length} blocks to the mock L2 block source`);
+  }
+
+  public removeBlocks(numBlocks: number) {
+    this.l2Blocks = this.l2Blocks.slice(0, -numBlocks);
+    this.log.verbose(`Removed ${numBlocks} blocks from the mock L2 block source`);
+  }
+
+  public setProvenBlockNumber(provenBlockNumber: number) {
+    this.provenBlockNumber = provenBlockNumber;
+  }
+
+  /**
+   * Method to fetch the rollup contract address at the base-layer.
+   * @returns The rollup address.
+   */
+  getRollupAddress(): Promise<EthAddress> {
+    return Promise.resolve(EthAddress.random());
+  }
+
+  /**
+   * Method to fetch the registry contract address at the base-layer.
+   * @returns The registry address.
+   */
+  getRegistryAddress(): Promise<EthAddress> {
+    return Promise.resolve(EthAddress.random());
+  }
+
+  /**
+   * Gets the number of the latest L2 block processed by the block source implementation.
+   * @returns In this mock instance, returns the number of L2 blocks that we've mocked.
+   */
+  public getBlockNumber() {
+    return Promise.resolve(this.l2Blocks.length);
+  }
+
+  public getProvenBlockNumber(): Promise<number> {
+    return Promise.resolve(this.provenBlockNumber);
+  }
+
+  /**
+   * Gets an l2 block.
+   * @param number - The block number to return (inclusive).
+   * @returns The requested L2 block.
+   */
+  public getBlock(number: number) {
+    return Promise.resolve(this.l2Blocks[number - 1]);
+  }
+
+  /**
+   * Gets up to `limit` amount of L2 blocks starting from `from`.
+   * @param from - Number of the first block to return (inclusive).
+   * @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),
+    );
+  }
+
+  getBlockHeader(number: number | 'latest'): Promise<BlockHeader | undefined> {
+    return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.header);
+  }
+
+  getBlocksForEpoch(epochNumber: bigint): Promise<L2Block[]> {
+    const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
+    const [start, end] = getSlotRangeForEpoch(epochNumber, { epochDuration });
+    const blocks = this.l2Blocks.filter(b => {
+      const slot = b.header.globalVariables.slotNumber.toBigInt();
+      return slot >= start && slot <= end;
+    });
+    return Promise.resolve(blocks);
+  }
+
+  /**
+   * Gets a tx effect.
+   * @param txHash - The hash of a transaction which resulted in the returned tx effect.
+   * @returns The requested tx effect.
+   */
+  public async getTxEffect(txHash: TxHash) {
+    const match = this.l2Blocks
+      .flatMap(b => b.body.txEffects.map(tx => [tx, b] as const))
+      .find(([tx]) => tx.txHash.equals(txHash));
+    if (!match) {
+      return Promise.resolve(undefined);
+    }
+    const [txEffect, block] = match;
+    return { data: txEffect, l2BlockNumber: block.number, l2BlockHash: (await block.hash()).toString() };
+  }
+
+  /**
+   * Gets a receipt of a settled tx.
+   * @param txHash - The hash of a tx we try to get the receipt for.
+   * @returns The requested tx receipt (or undefined if not found).
+   */
+  public async getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
+    for (const block of this.l2Blocks) {
+      for (const txEffect of block.body.txEffects) {
+        if (txEffect.txHash.equals(txHash)) {
+          return new TxReceipt(
+            txHash,
+            TxStatus.SUCCESS,
+            '',
+            txEffect.transactionFee.toBigInt(),
+            L2BlockHash.fromField(await block.hash()),
+            block.number,
+          );
+        }
+      }
+    }
+    return undefined;
+  }
+
+  async getL2Tips(): Promise<L2Tips> {
+    const [latest, proven, finalized] = [
+      await this.getBlockNumber(),
+      await this.getProvenBlockNumber(),
+      await this.getProvenBlockNumber(),
+    ] as const;
+
+    const latestBlock = this.l2Blocks[latest - 1];
+    const provenBlock = this.l2Blocks[proven - 1];
+    const finalizedBlock = this.l2Blocks[finalized - 1];
+
+    return {
+      latest: {
+        number: latest,
+        hash: (await latestBlock?.hash())?.toString(),
+      },
+      proven: {
+        number: proven,
+        hash: (await provenBlock?.hash())?.toString(),
+      },
+      finalized: {
+        number: finalized,
+        hash: (await finalizedBlock?.hash())?.toString(),
+      },
+    };
+  }
+
+  getL2EpochNumber(): Promise<bigint> {
+    throw new Error('Method not implemented.');
+  }
+
+  getL2SlotNumber(): Promise<bigint> {
+    throw new Error('Method not implemented.');
+  }
+
+  isEpochComplete(_epochNumber: bigint): Promise<boolean> {
+    throw new Error('Method not implemented.');
+  }
+
+  getL1Constants(): Promise<L1RollupConstants> {
+    throw new Error('Method not implemented.');
+  }
+
+  /**
+   * Starts the block source. In this mock implementation, this is a noop.
+   * @returns A promise that signals the initialization of the l2 block source on completion.
+   */
+  public start(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  /**
+   * Stops the block source. In this mock implementation, this is a noop.
+   * @returns A promise that signals the l2 block source is now stopped.
+   */
+  public stop(): Promise<void> {
+    return Promise.resolve();
+  }
+}