@aztec/archiver 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/src/archiver/config.ts

@@ -1,92 +0,0 @@
-import { type BlobSinkConfig, blobSinkConfigMapping } from '@aztec/blob-sink/client';
-import {
-  type L1ContractAddresses,
-  type L1ContractsConfig,
-  type L1ReaderConfig,
-  l1ContractsConfigMappings,
-  l1ReaderConfigMappings,
-} from '@aztec/ethereum';
-import { type ConfigMappingsType, getConfigFromMappings, numberConfigHelper } from '@aztec/foundation/config';
-import { type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
-
-/**
- * There are 2 polling intervals used in this configuration. The first is the archiver polling interval, archiverPollingIntervalMS.
- * This is the interval between successive calls to eth_blockNumber via viem.
- * Results of calls to eth_blockNumber are cached by viem with this cache being updated periodically at the interval specified by viemPollingIntervalMS.
- * As a result the maximum observed polling time for new blocks will be viemPollingIntervalMS + archiverPollingIntervalMS.
- */
-
-/**
- * The archiver configuration.
- */
-export type ArchiverConfig = {
-  /** URL for an archiver service. If set, will return an archiver client as opposed to starting a new one. */
-  archiverUrl?: string;
-
-  /** URL for an L1 consensus client */
-  l1ConsensusHostUrl?: string;
-
-  /** The polling interval in ms for retrieving new L2 blocks and encrypted logs. */
-  archiverPollingIntervalMS?: number;
-
-  /** The number of L2 blocks the archiver will attempt to download at a time. */
-  archiverBatchSize?: number;
-
-  /** The polling interval viem uses in ms */
-  viemPollingIntervalMS?: number;
-
-  /** The deployed L1 contract addresses */
-  l1Contracts: L1ContractAddresses;
-
-  /** The max number of logs that can be obtained in 1 "getPublicLogs" call. */
-  maxLogs?: number;
-} & L1ReaderConfig &
-  L1ContractsConfig &
-  BlobSinkConfig &
-  ChainConfig;
-
-export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
-  ...blobSinkConfigMapping,
-  archiverUrl: {
-    env: 'ARCHIVER_URL',
-    description:
-      'URL for an archiver service. If set, will return an archiver client as opposed to starting a new one.',
-  },
-  l1ConsensusHostUrl: {
-    env: 'L1_CONSENSUS_HOST_URL',
-    description: 'URL for an L1 consensus client.',
-    parseEnv: (val: string) => val,
-  },
-  archiverPollingIntervalMS: {
-    env: 'ARCHIVER_POLLING_INTERVAL_MS',
-    description: 'The polling interval in ms for retrieving new L2 blocks and encrypted logs.',
-    ...numberConfigHelper(500),
-  },
-  archiverBatchSize: {
-    env: 'ARCHIVER_BATCH_SIZE',
-    description: 'The number of L2 blocks the archiver will attempt to download at a time.',
-    ...numberConfigHelper(100),
-  },
-  maxLogs: {
-    env: 'ARCHIVER_MAX_LOGS',
-    description: 'The max number of logs that can be obtained in 1 "getPublicLogs" call.',
-    ...numberConfigHelper(1_000),
-  },
-  ...chainConfigMappings,
-  ...l1ReaderConfigMappings,
-  viemPollingIntervalMS: {
-    env: 'ARCHIVER_VIEM_POLLING_INTERVAL_MS',
-    description: 'The polling interval viem uses in ms',
-    ...numberConfigHelper(1000),
-  },
-  ...l1ContractsConfigMappings,
-};
-
-/**
- * Returns the archiver configuration from the environment variables.
- * Note: If an environment variable is not set, the default value is used.
- * @returns The archiver configuration.
- */
-export function getArchiverConfigFromEnv(): ArchiverConfig {
-  return getConfigFromMappings<ArchiverConfig>(archiverConfigMappings);
-}

package/src/archiver/data_retrieval.ts

@@ -1,422 +0,0 @@
-import { Blob, BlobDeserializationError } from '@aztec/blob-lib';
-import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
-import type { EpochProofPublicInputArgs, ViemPublicClient } from '@aztec/ethereum';
-import { asyncPool } from '@aztec/foundation/async-pool';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { ViemSignature } from '@aztec/foundation/eth-signature';
-import { Fr } from '@aztec/foundation/fields';
-import { type Logger, createLogger } from '@aztec/foundation/log';
-import { numToUInt32BE } from '@aztec/foundation/serialize';
-import { ForwarderAbi, type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
-import { Body, L2Block } from '@aztec/stdlib/block';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
-import { Proof } from '@aztec/stdlib/proofs';
-import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
-import { BlockHeader } from '@aztec/stdlib/tx';
-
-import {
-  type GetContractEventsReturnType,
-  type GetContractReturnType,
-  type Hex,
-  decodeFunctionData,
-  getAbiItem,
-  hexToBytes,
-} from 'viem';
-
-import { NoBlobBodiesFoundError } from './errors.js';
-import type { DataRetrieval } from './structs/data_retrieval.js';
-import type { L1Published, L1PublishedData } from './structs/published.js';
-
-/**
- * Fetches new L2 blocks.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param rollupAddress - The address of the rollup contract.
- * @param searchStartBlock - The block number to use for starting the search.
- * @param searchEndBlock - The highest block number that we should search up to.
- * @param expectedNextL2BlockNum - The next L2 block number that we expect to find.
- * @returns An array of block; as well as the next eth block to search from.
- */
-export async function retrieveBlocksFromRollup(
-  rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>,
-  publicClient: ViemPublicClient,
-  blobSinkClient: BlobSinkClientInterface,
-  searchStartBlock: bigint,
-  searchEndBlock: bigint,
-  logger: Logger = createLogger('archiver'),
-): Promise<L1Published<L2Block>[]> {
-  const retrievedBlocks: L1Published<L2Block>[] = [];
-  do {
-    if (searchStartBlock > searchEndBlock) {
-      break;
-    }
-    const l2BlockProposedLogs = (
-      await rollup.getEvents.L2BlockProposed(
-        {},
-        {
-          fromBlock: searchStartBlock,
-          toBlock: searchEndBlock,
-        },
-      )
-    ).filter(log => log.blockNumber! >= searchStartBlock && log.blockNumber! <= searchEndBlock);
-
-    if (l2BlockProposedLogs.length === 0) {
-      break;
-    }
-
-    const lastLog = l2BlockProposedLogs[l2BlockProposedLogs.length - 1];
-    logger.debug(
-      `Got ${l2BlockProposedLogs.length} L2 block processed logs for L2 blocks ${l2BlockProposedLogs[0].args.blockNumber}-${lastLog.args.blockNumber} between L1 blocks ${searchStartBlock}-${searchEndBlock}`,
-    );
-
-    const newBlocks = await processL2BlockProposedLogs(
-      rollup,
-      publicClient,
-      blobSinkClient,
-      l2BlockProposedLogs,
-      logger,
-    );
-    retrievedBlocks.push(...newBlocks);
-    searchStartBlock = lastLog.blockNumber! + 1n;
-  } while (searchStartBlock <= searchEndBlock);
-
-  // The asyncpool from processL2BlockProposedLogs will not necessarily return the blocks in order, so we sort them before returning.
-  return retrievedBlocks.sort((a, b) => Number(a.l1.blockNumber - b.l1.blockNumber));
-}
-
-/**
- * Processes newly received L2BlockProposed logs.
- * @param rollup - The rollup contract
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param logs - L2BlockProposed logs.
- * @returns - An array blocks.
- */
-export async function processL2BlockProposedLogs(
-  rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>,
-  publicClient: ViemPublicClient,
-  blobSinkClient: BlobSinkClientInterface,
-  logs: GetContractEventsReturnType<typeof RollupAbi, 'L2BlockProposed'>,
-  logger: Logger,
-): Promise<L1Published<L2Block>[]> {
-  const retrievedBlocks: L1Published<L2Block>[] = [];
-  await asyncPool(10, logs, async log => {
-    const l2BlockNumber = log.args.blockNumber!;
-    const archive = log.args.archive!;
-    const archiveFromChain = await rollup.read.archiveAt([l2BlockNumber]);
-    const blobHashes = log.args.versionedBlobHashes!.map(blobHash => Buffer.from(blobHash.slice(2), 'hex'));
-
-    // The value from the event and contract will match only if the block is in the chain.
-    if (archive === archiveFromChain) {
-      const block = await getBlockFromRollupTx(
-        publicClient,
-        blobSinkClient,
-        log.transactionHash!,
-        blobHashes,
-        l2BlockNumber,
-        rollup.address,
-        logger,
-      );
-
-      const l1: L1PublishedData = {
-        blockNumber: log.blockNumber,
-        blockHash: log.blockHash,
-        timestamp: await getL1BlockTime(publicClient, log.blockNumber),
-      };
-
-      retrievedBlocks.push({ data: block, l1 });
-    } else {
-      logger.warn(`Ignoring L2 block ${l2BlockNumber} due to archive root mismatch`, {
-        actual: archive,
-        expected: archiveFromChain,
-      });
-    }
-  });
-
-  return retrievedBlocks;
-}
-
-export async function getL1BlockTime(publicClient: ViemPublicClient, blockNumber: bigint): Promise<bigint> {
-  const block = await publicClient.getBlock({ blockNumber, includeTransactions: false });
-  return block.timestamp;
-}
-
-/**
- * Extracts the first 'propose' method calldata from a forwarder transaction's data.
- * @param forwarderData - The forwarder transaction input data
- * @param rollupAddress - The address of the rollup contract
- * @returns The calldata for the first 'propose' method call to the rollup contract
- */
-function extractRollupProposeCalldata(forwarderData: Hex, rollupAddress: Hex): Hex {
-  // TODO(#11451): custom forwarders
-  const { functionName: forwarderFunctionName, args: forwarderArgs } = decodeFunctionData({
-    abi: ForwarderAbi,
-    data: forwarderData,
-  });
-
-  if (forwarderFunctionName !== 'forward') {
-    throw new Error(`Unexpected forwarder method called ${forwarderFunctionName}`);
-  }
-
-  if (forwarderArgs.length !== 2) {
-    throw new Error(`Unexpected number of arguments for forwarder`);
-  }
-
-  const [to, data] = forwarderArgs;
-
-  // Find all rollup calls
-  const rollupAddressLower = rollupAddress.toLowerCase();
-
-  for (let i = 0; i < to.length; i++) {
-    const addr = to[i];
-    if (addr.toLowerCase() !== rollupAddressLower) {
-      continue;
-    }
-    const callData = data[i];
-
-    try {
-      const { functionName: rollupFunctionName } = decodeFunctionData({
-        abi: RollupAbi,
-        data: callData,
-      });
-
-      if (rollupFunctionName === 'propose') {
-        return callData;
-      }
-    } catch (err) {
-      // Skip invalid function data
-      continue;
-    }
-  }
-
-  throw new Error(`Rollup address not found in forwarder args`);
-}
-
-/**
- * Gets block from the calldata of an L1 transaction.
- * Assumes that the block was published from an EOA.
- * TODO: Add retries and error management.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param txHash - Hash of the tx that published it.
- * @param l2BlockNum - L2 block number.
- * @returns L2 block from the calldata, deserialized
- */
-async function getBlockFromRollupTx(
-  publicClient: ViemPublicClient,
-  blobSinkClient: BlobSinkClientInterface,
-  txHash: `0x${string}`,
-  blobHashes: Buffer[], // WORKTODO(md): buffer32?
-  l2BlockNum: bigint,
-  rollupAddress: Hex,
-  logger: Logger,
-): Promise<L2Block> {
-  const { input: forwarderData, blockHash } = await publicClient.getTransaction({ hash: txHash });
-
-  const rollupData = extractRollupProposeCalldata(forwarderData, rollupAddress);
-  const { functionName: rollupFunctionName, args: rollupArgs } = decodeFunctionData({
-    abi: RollupAbi,
-    data: rollupData,
-  });
-
-  if (rollupFunctionName !== 'propose') {
-    throw new Error(`Unexpected rollup method called ${rollupFunctionName}`);
-  }
-
-  const [decodedArgs, ,] = rollupArgs! as readonly [
-    {
-      header: Hex;
-      archive: Hex;
-      blockHash: Hex;
-      oracleInput: {
-        feeAssetPriceModifier: bigint;
-      };
-      txHashes: Hex[];
-    },
-    ViemSignature[],
-    Hex,
-  ];
-
-  const header = BlockHeader.fromBuffer(Buffer.from(hexToBytes(decodedArgs.header)));
-  const blobBodies = await blobSinkClient.getBlobSidecar(blockHash, blobHashes);
-  if (blobBodies.length === 0) {
-    throw new NoBlobBodiesFoundError(Number(l2BlockNum));
-  }
-
-  let blockFields: Fr[];
-  try {
-    blockFields = Blob.toEncodedFields(blobBodies);
-  } catch (err: any) {
-    if (err instanceof BlobDeserializationError) {
-      logger.fatal(err.message);
-    } else {
-      logger.fatal('Unable to sync: failed to decode fetched blob, this blob was likely not created by us');
-    }
-    throw err;
-  }
-
-  // The blob source gives us blockFields, and we must construct the body from them:
-  const blockBody = Body.fromBlobFields(blockFields);
-
-  const blockNumberFromHeader = header.globalVariables.blockNumber.toBigInt();
-
-  if (blockNumberFromHeader !== l2BlockNum) {
-    throw new Error(`Block number mismatch: expected ${l2BlockNum} but got ${blockNumberFromHeader}`);
-  }
-
-  const archive = AppendOnlyTreeSnapshot.fromBuffer(
-    Buffer.concat([
-      Buffer.from(hexToBytes(decodedArgs.archive)), // L2Block.archive.root
-      numToUInt32BE(Number(l2BlockNum + 1n)), // L2Block.archive.nextAvailableLeafIndex
-    ]),
-  );
-
-  return new L2Block(archive, header, blockBody);
-}
-
-/**
- * Fetch L1 to L2 messages.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param inboxAddress - The address of the inbox contract to fetch messages from.
- * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
- * @param searchStartBlock - The block number to use for starting the search.
- * @param searchEndBlock - The highest block number that we should search up to.
- * @returns An array of InboxLeaf and next eth block to search from.
- */
-export async function retrieveL1ToL2Messages(
-  inbox: GetContractReturnType<typeof InboxAbi, ViemPublicClient>,
-  searchStartBlock: bigint,
-  searchEndBlock: bigint,
-): Promise<DataRetrieval<InboxLeaf>> {
-  const retrievedL1ToL2Messages: InboxLeaf[] = [];
-  do {
-    if (searchStartBlock > searchEndBlock) {
-      break;
-    }
-
-    const messageSentLogs = (
-      await inbox.getEvents.MessageSent(
-        {},
-        {
-          fromBlock: searchStartBlock,
-          toBlock: searchEndBlock,
-        },
-      )
-    ).filter(log => log.blockNumber! >= searchStartBlock && log.blockNumber! <= searchEndBlock);
-
-    if (messageSentLogs.length === 0) {
-      break;
-    }
-
-    for (const log of messageSentLogs) {
-      const { index, hash } = log.args;
-      retrievedL1ToL2Messages.push(new InboxLeaf(index!, Fr.fromHexString(hash!)));
-    }
-
-    // handles the case when there are no new messages:
-    searchStartBlock = (messageSentLogs.findLast(msgLog => !!msgLog)?.blockNumber || searchStartBlock) + 1n;
-  } while (searchStartBlock <= searchEndBlock);
-  return { lastProcessedL1BlockNumber: searchStartBlock - 1n, retrievedData: retrievedL1ToL2Messages };
-}
-
-/** Retrieves L2ProofVerified events from the rollup contract. */
-export async function retrieveL2ProofVerifiedEvents(
-  publicClient: ViemPublicClient,
-  rollupAddress: EthAddress,
-  searchStartBlock: bigint,
-  searchEndBlock?: bigint,
-): Promise<{ l1BlockNumber: bigint; l2BlockNumber: bigint; proverId: Fr; txHash: Hex }[]> {
-  const logs = await publicClient.getLogs({
-    address: rollupAddress.toString(),
-    fromBlock: searchStartBlock,
-    toBlock: searchEndBlock ? searchEndBlock : undefined,
-    strict: true,
-    event: getAbiItem({ abi: RollupAbi, name: 'L2ProofVerified' }),
-  });
-
-  return logs.map(log => ({
-    l1BlockNumber: log.blockNumber,
-    l2BlockNumber: log.args.blockNumber,
-    proverId: Fr.fromHexString(log.args.proverId),
-    txHash: log.transactionHash,
-  }));
-}
-
-/** Retrieve submitted proofs from the rollup contract */
-export async function retrieveL2ProofsFromRollup(
-  publicClient: ViemPublicClient,
-  rollupAddress: EthAddress,
-  searchStartBlock: bigint,
-  searchEndBlock?: bigint,
-): Promise<DataRetrieval<{ proof: Proof; proverId: Fr; l2BlockNumber: bigint; txHash: `0x${string}` }>> {
-  const logs = await retrieveL2ProofVerifiedEvents(publicClient, rollupAddress, searchStartBlock, searchEndBlock);
-  const retrievedData: { proof: Proof; proverId: Fr; l2BlockNumber: bigint; txHash: `0x${string}` }[] = [];
-  const lastProcessedL1BlockNumber = logs.length > 0 ? logs.at(-1)!.l1BlockNumber : searchStartBlock - 1n;
-
-  for (const { txHash, proverId, l2BlockNumber } of logs) {
-    const proofData = await getProofFromSubmitProofTx(publicClient, txHash, proverId);
-    retrievedData.push({ proof: proofData.proof, proverId: proofData.proverId, l2BlockNumber, txHash });
-  }
-  return {
-    retrievedData,
-    lastProcessedL1BlockNumber,
-  };
-}
-
-export type SubmitBlockProof = {
-  archiveRoot: Fr;
-  proverId: Fr;
-  aggregationObject: Buffer;
-  proof: Proof;
-};
-
-/**
- * Gets block metadata (header and archive snapshot) from the calldata of an L1 transaction.
- * Assumes that the block was published from an EOA.
- * TODO: Add retries and error management.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param txHash - Hash of the tx that published it.
- * @param l2BlockNum - L2 block number.
- * @returns L2 block metadata (header and archive) from the calldata, deserialized
- */
-export async function getProofFromSubmitProofTx(
-  publicClient: ViemPublicClient,
-  txHash: `0x${string}`,
-  expectedProverId: Fr,
-): Promise<SubmitBlockProof> {
-  const { input: data } = await publicClient.getTransaction({ hash: txHash });
-  const { functionName, args } = decodeFunctionData({ abi: RollupAbi, data });
-
-  let proverId: Fr;
-  let archiveRoot: Fr;
-  let aggregationObject: Buffer;
-  let proof: Proof;
-
-  if (functionName === 'submitEpochRootProof') {
-    const [decodedArgs] = args as readonly [
-      {
-        start: bigint;
-        end: bigint;
-        args: EpochProofPublicInputArgs;
-        fees: readonly Hex[];
-        aggregationObject: Hex;
-        proof: Hex;
-      },
-    ];
-
-    aggregationObject = Buffer.from(hexToBytes(decodedArgs.aggregationObject));
-    proverId = Fr.fromHexString(decodedArgs.args.proverId);
-    archiveRoot = Fr.fromHexString(decodedArgs.args.endArchive);
-    proof = Proof.fromBuffer(Buffer.from(hexToBytes(decodedArgs.proof)));
-  } else {
-    throw new Error(`Unexpected proof method called ${functionName}`);
-  }
-
-  if (!proverId.equals(expectedProverId)) {
-    throw new Error(`Prover ID mismatch: expected ${expectedProverId} but got ${proverId}`);
-  }
-
-  return {
-    proverId,
-    aggregationObject,
-    archiveRoot,
-    proof,
-  };
-}

package/src/archiver/errors.ts

@@ -1,5 +0,0 @@
-export class NoBlobBodiesFoundError extends Error {
-  constructor(l2BlockNum: number) {
-    super(`No blob bodies found for block ${l2BlockNum}`);
-  }
-}

package/src/archiver/index.ts

@@ -1,7 +0,0 @@
-export * from './archiver.js';
-export * from './config.js';
-export { type L1Published, type L1PublishedData } from './structs/published.js';
-export { MemoryArchiverStore } from './memory_archiver_store/memory_archiver_store.js';
-export type { ArchiverDataStore } from './archiver_store.js';
-export { KVArchiverDataStore } from './kv_archiver_store/kv_archiver_store.js';
-export { ContractInstanceStore } from './kv_archiver_store/contract_instance_store.js';

package/src/archiver/instrumentation.ts

@@ -1,132 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-import type { L2Block } from '@aztec/stdlib/block';
-import {
-  Attributes,
-  type Gauge,
-  type Histogram,
-  LmdbMetrics,
-  type LmdbStatsCallback,
-  Metrics,
-  type TelemetryClient,
-  type Tracer,
-  type UpDownCounter,
-  ValueType,
-} from '@aztec/telemetry-client';
-
-export class ArchiverInstrumentation {
-  public readonly tracer: Tracer;
-
-  private blockHeight: Gauge;
-  private txCount: UpDownCounter;
-  private syncDuration: Histogram;
-  private l1BlocksSynced: UpDownCounter;
-  private l1BlockHeight: Gauge;
-  private proofsSubmittedDelay: Histogram;
-  private proofsSubmittedCount: UpDownCounter;
-  private dbMetrics: LmdbMetrics;
-  private pruneCount: UpDownCounter;
-
-  private log = createLogger('archiver:instrumentation');
-
-  private constructor(private telemetry: TelemetryClient, lmdbStats?: LmdbStatsCallback) {
-    this.tracer = telemetry.getTracer('Archiver');
-    const meter = telemetry.getMeter('Archiver');
-    this.blockHeight = meter.createGauge(Metrics.ARCHIVER_BLOCK_HEIGHT, {
-      description: 'The height of the latest block processed by the archiver',
-      valueType: ValueType.INT,
-    });
-
-    this.txCount = meter.createUpDownCounter(Metrics.ARCHIVER_TX_COUNT, {
-      description: 'The total number of transactions',
-      valueType: ValueType.INT,
-    });
-
-    this.syncDuration = meter.createHistogram(Metrics.ARCHIVER_SYNC_DURATION, {
-      unit: 'ms',
-      description: 'Duration to sync a block',
-      valueType: ValueType.INT,
-    });
-
-    this.proofsSubmittedCount = meter.createUpDownCounter(Metrics.ARCHIVER_ROLLUP_PROOF_COUNT, {
-      description: 'Number of proofs submitted',
-      valueType: ValueType.INT,
-    });
-
-    this.proofsSubmittedDelay = meter.createHistogram(Metrics.ARCHIVER_ROLLUP_PROOF_DELAY, {
-      unit: 'ms',
-      description: 'Time after a block is submitted until its proof is published',
-      valueType: ValueType.INT,
-    });
-
-    this.l1BlocksSynced = meter.createUpDownCounter(Metrics.ARCHIVER_L1_BLOCKS_SYNCED, {
-      description: 'Number of blocks synced from L1',
-      valueType: ValueType.INT,
-    });
-
-    this.l1BlockHeight = meter.createGauge(Metrics.ARCHIVER_L1_BLOCK_HEIGHT, {
-      description: 'The height of the latest L1 block processed by the archiver',
-      valueType: ValueType.INT,
-    });
-
-    this.dbMetrics = new LmdbMetrics(
-      meter,
-      {
-        [Attributes.DB_DATA_TYPE]: 'archiver',
-      },
-      lmdbStats,
-    );
-
-    this.pruneCount = meter.createUpDownCounter(Metrics.ARCHIVER_PRUNE_COUNT, {
-      description: 'Number of prunes detected',
-      valueType: ValueType.INT,
-    });
-  }
-
-  public static async new(telemetry: TelemetryClient, lmdbStats?: LmdbStatsCallback) {
-    const instance = new ArchiverInstrumentation(telemetry, lmdbStats);
-
-    instance.l1BlocksSynced.add(0);
-
-    await instance.telemetry.flush();
-
-    return instance;
-  }
-
-  public isEnabled(): boolean {
-    return this.telemetry.isEnabled();
-  }
-
-  public processNewBlocks(syncTimePerBlock: number, blocks: L2Block[]) {
-    this.syncDuration.record(Math.ceil(syncTimePerBlock));
-    this.blockHeight.record(Math.max(...blocks.map(b => b.number)));
-    this.l1BlocksSynced.add(blocks.length);
-    for (const block of blocks) {
-      this.txCount.add(block.body.txEffects.length);
-    }
-  }
-
-  public processPrune() {
-    this.pruneCount.add(1);
-  }
-
-  public updateLastProvenBlock(blockNumber: number) {
-    this.blockHeight.record(blockNumber, { [Attributes.STATUS]: 'proven' });
-  }
-
-  public processProofsVerified(logs: { proverId: string; l2BlockNumber: bigint; delay: bigint }[]) {
-    for (const log of logs) {
-      this.log.debug('Recording proof verified event', log);
-      this.proofsSubmittedCount.add(1, {
-        [Attributes.ROLLUP_PROVER_ID]: log.proverId,
-        [Attributes.PROOF_TIMED_OUT]: log.delay > 20n * 60n * 1000n,
-      });
-      this.proofsSubmittedDelay.record(Math.ceil(Number(log.delay)), {
-        [Attributes.ROLLUP_PROVER_ID]: log.proverId,
-      });
-    }
-  }
-
-  public updateL1BlockHeight(blockNumber: bigint) {
-    this.l1BlockHeight.record(Number(blockNumber));
-  }
-}