@aztec/archiver 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/archiver/kv_archiver_store/message_store.ts

@@ -1,71 +1,172 @@
-import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
+import type { L1BlockId } from '@aztec/ethereum';
+import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
 import { Fr } from '@aztec/foundation/fields';
+import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
-import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncSingleton } from '@aztec/kv-store';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import {
+  type AztecAsyncKVStore,
+  type AztecAsyncMap,
+  type AztecAsyncSingleton,
+  type CustomRange,
+  mapRange,
+} from '@aztec/kv-store';
 import { InboxLeaf } from '@aztec/stdlib/messaging';
 
-import type { DataRetrieval } from '../structs/data_retrieval.js';
+import {
+  type InboxMessage,
+  deserializeInboxMessage,
+  serializeInboxMessage,
+  updateRollingHash,
+} from '../structs/inbox_message.js';
+
+export class MessageStoreError extends Error {
+  constructor(
+    message: string,
+    public readonly inboxMessage: InboxMessage,
+  ) {
+    super(message);
+    this.name = 'MessageStoreError';
+  }
+}
 
-/**
- * LMDB implementation of the ArchiverDataStore interface.
- */
 export class MessageStore {
-  #l1ToL2Messages: AztecAsyncMap<string, Buffer>;
+  /** Maps from message index to serialized InboxMessage */
+  #l1ToL2Messages: AztecAsyncMap<number, Buffer>;
+  /** Maps from hex-stringified message leaf to its index */
   #l1ToL2MessageIndices: AztecAsyncMap<string, bigint>;
-  #lastSynchedL1Block: AztecAsyncSingleton<bigint>;
+  /** Stores L1 block number and hash of the L1 synchpoint */
+  #lastSynchedL1Block: AztecAsyncSingleton<Buffer>;
+  /** Stores total messages stored */
   #totalMessageCount: AztecAsyncSingleton<bigint>;
 
   #log = createLogger('archiver:message_store');
 
-  #l1ToL2MessagesSubtreeSize = 2 ** L1_TO_L2_MSG_SUBTREE_HEIGHT;
-
   constructor(private db: AztecAsyncKVStore) {
     this.#l1ToL2Messages = db.openMap('archiver_l1_to_l2_messages');
     this.#l1ToL2MessageIndices = db.openMap('archiver_l1_to_l2_message_indices');
-    this.#lastSynchedL1Block = db.openSingleton('archiver_last_l1_block_new_messages');
+    this.#lastSynchedL1Block = db.openSingleton('archiver_last_l1_block_id');
     this.#totalMessageCount = db.openSingleton('archiver_l1_to_l2_message_count');
   }
 
-  async getTotalL1ToL2MessageCount(): Promise<bigint> {
+  public async getTotalL1ToL2MessageCount(): Promise<bigint> {
     return (await this.#totalMessageCount.getAsync()) ?? 0n;
   }
 
-  /**
-   * Gets the last L1 block number that emitted new messages.
-   * @returns The last L1 block number processed
-   */
-  getSynchedL1BlockNumber(): Promise<bigint | undefined> {
-    return this.#lastSynchedL1Block.getAsync();
+  /** Gets the last L1 block synced. */
+  public async getSynchedL1Block(): Promise<L1BlockId | undefined> {
+    const buffer = await this.#lastSynchedL1Block.getAsync();
+    if (!buffer) {
+      return undefined;
+    }
+
+    const reader = BufferReader.asReader(buffer);
+    return { l1BlockNumber: reader.readUInt256(), l1BlockHash: Buffer32.fromBuffer(reader.readBytes(Buffer32.SIZE)) };
   }
 
-  async setSynchedL1BlockNumber(l1BlockNumber: bigint): Promise<void> {
-    await this.#lastSynchedL1Block.set(l1BlockNumber);
+  /** Sets the last L1 block synced */
+  public async setSynchedL1Block(l1Block: L1BlockId): Promise<void> {
+    const buffer = serializeToBuffer([l1Block.l1BlockNumber, l1Block.l1BlockHash]);
+    await this.#lastSynchedL1Block.set(buffer);
   }
 
   /**
    * Append L1 to L2 messages to the store.
-   * @param messages - The L1 to L2 messages to be added to the store and the last processed L1 block.
-   * @returns True if the operation is successful.
+   * Requires new messages to be in order and strictly after the last message added.
+   * Throws if out of order messages are added or if the rolling hash is invalid.
    */
-  addL1ToL2Messages(messages: DataRetrieval<InboxLeaf>): Promise<boolean> {
+  public addL1ToL2Messages(messages: InboxMessage[]): Promise<void> {
+    if (messages.length === 0) {
+      return Promise.resolve();
+    }
+
     return this.db.transactionAsync(async () => {
-      const lastL1BlockNumber = (await this.#lastSynchedL1Block.getAsync()) ?? 0n;
-      if (lastL1BlockNumber >= messages.lastProcessedL1BlockNumber) {
-        return false;
-      }
+      let lastMessage = await this.getLastMessage();
+      let messageCount = 0;
+
+      for (const message of messages) {
+        // Check messages are inserted in increasing order, but allow reinserting messages.
+        if (lastMessage && message.index <= lastMessage.index) {
+          const existing = await this.#l1ToL2Messages.getAsync(this.indexToKey(message.index));
+          if (existing && deserializeInboxMessage(existing).rollingHash.equals(message.rollingHash)) {
+            // We reinsert instead of skipping in case the message was re-orged and got added in a different L1 block.
+            this.#log.trace(`Reinserting message with index ${message.index} in the store`);
+            await this.#l1ToL2Messages.set(this.indexToKey(message.index), serializeInboxMessage(message));
+            continue;
+          }
 
-      await this.#lastSynchedL1Block.set(messages.lastProcessedL1BlockNumber);
+          throw new MessageStoreError(
+            `Cannot insert L1 to L2 message with index ${message.index} before last message with index ${lastMessage.index}`,
+            message,
+          );
+        }
 
-      for (const message of messages.retrievedData) {
-        const key = `${message.index}`;
-        await this.#l1ToL2Messages.set(key, message.leaf.toBuffer());
-        await this.#l1ToL2MessageIndices.set(message.leaf.toString(), message.index);
+        // Check rolling hash is valid.
+        const previousRollingHash = lastMessage?.rollingHash ?? Buffer16.ZERO;
+        const expectedRollingHash = updateRollingHash(previousRollingHash, message.leaf);
+        if (!expectedRollingHash.equals(message.rollingHash)) {
+          throw new MessageStoreError(
+            `Invalid rolling hash for incoming L1 to L2 message ${message.leaf.toString()} ` +
+              `with index ${message.index} ` +
+              `(expected ${expectedRollingHash.toString()} from previous hash ${previousRollingHash} but got ${message.rollingHash.toString()})`,
+            message,
+          );
+        }
+
+        // Check index corresponds to the L2 block number.
+        const [expectedStart, expectedEnd] = InboxLeaf.indexRangeFromL2Block(message.l2BlockNumber);
+        if (message.index < expectedStart || message.index >= expectedEnd) {
+          throw new MessageStoreError(
+            `Invalid index ${message.index} for incoming L1 to L2 message ${message.leaf.toString()} ` +
+              `at block ${message.l2BlockNumber} (expected value in range [${expectedStart}, ${expectedEnd}))`,
+            message,
+          );
+        }
+
+        // Check there are no gaps in the indices within the same block.
+        if (
+          lastMessage &&
+          message.l2BlockNumber === lastMessage.l2BlockNumber &&
+          message.index !== lastMessage.index + 1n
+        ) {
+          throw new MessageStoreError(
+            `Missing prior message for incoming L1 to L2 message ${message.leaf.toString()} ` +
+              `with index ${message.index}`,
+            message,
+          );
+        }
+
+        // Check the first message in a block has the correct index.
+        if (
+          (!lastMessage || message.l2BlockNumber > lastMessage.l2BlockNumber) &&
+          message.index !== InboxLeaf.smallestIndexFromL2Block(message.l2BlockNumber)
+        ) {
+          throw new MessageStoreError(
+            `Message ${message.leaf.toString()} for L2 block ${message.l2BlockNumber} has wrong index ` +
+              `${message.index} (expected ${InboxLeaf.smallestIndexFromL2Block(message.l2BlockNumber)})`,
+            message,
+          );
+        }
+
+        // Perform the insertions.
+        await this.#l1ToL2Messages.set(this.indexToKey(message.index), serializeInboxMessage(message));
+        await this.#l1ToL2MessageIndices.set(this.leafToIndexKey(message.leaf), message.index);
+        messageCount++;
+        this.#log.trace(`Inserted L1 to L2 message ${message.leaf} with index ${message.index} into the store`);
+        lastMessage = message;
       }
 
-      const lastTotalMessageCount = await this.getTotalL1ToL2MessageCount();
-      await this.#totalMessageCount.set(lastTotalMessageCount + BigInt(messages.retrievedData.length));
+      // Update the L1 sync point to that of the last message added.
+      const currentSyncPoint = await this.getSynchedL1Block();
+      if (!currentSyncPoint || currentSyncPoint.l1BlockNumber < lastMessage!.l1BlockNumber) {
+        await this.setSynchedL1Block({
+          l1BlockNumber: lastMessage!.l1BlockNumber,
+          l1BlockHash: lastMessage!.l1BlockHash,
+        });
+      }
 
-      return true;
+      // Update total message count with the number of inserted messages.
+      await this.increaseTotalMessageCount(messageCount);
     });
   }
 
@@ -74,29 +175,84 @@ export class MessageStore {
    * @param l1ToL2Message - The L1 to L2 message.
    * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
    */
-  getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined> {
-    return this.#l1ToL2MessageIndices.getAsync(l1ToL2Message.toString());
+  public getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined> {
+    return this.#l1ToL2MessageIndices.getAsync(this.leafToIndexKey(l1ToL2Message));
+  }
+
+  public async getLastMessage(): Promise<InboxMessage | undefined> {
+    const [msg] = await toArray(this.#l1ToL2Messages.valuesAsync({ reverse: true, limit: 1 }));
+    return msg ? deserializeInboxMessage(msg) : undefined;
   }
 
-  async getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
+  public async getL1ToL2Messages(blockNumber: number): Promise<Fr[]> {
     const messages: Fr[] = [];
-    let undefinedMessageFound = false;
-    const startIndex = Number(InboxLeaf.smallestIndexFromL2Block(blockNumber));
-    for (let i = startIndex; i < startIndex + this.#l1ToL2MessagesSubtreeSize; i++) {
-      // This is inefficient but probably fine for now.
-      const key = `${i}`;
-      const message = await this.#l1ToL2Messages.getAsync(key);
-      if (message) {
-        if (undefinedMessageFound) {
-          throw new Error(`L1 to L2 message gap found in block ${blockNumber}`);
-        }
-        messages.push(Fr.fromBuffer(message));
-      } else {
-        undefinedMessageFound = true;
-        // We continue iterating over messages here to verify that there are no more messages after the undefined one.
-        // --> If this was the case this would imply there is some issue with log fetching.
+
+    const [startIndex, endIndex] = InboxLeaf.indexRangeFromL2Block(blockNumber);
+    let lastIndex = startIndex - 1n;
+
+    for await (const msgBuffer of this.#l1ToL2Messages.valuesAsync({
+      start: this.indexToKey(startIndex),
+      end: this.indexToKey(endIndex),
+    })) {
+      const msg = deserializeInboxMessage(msgBuffer);
+      if (msg.l2BlockNumber !== blockNumber) {
+        throw new Error(`L1 to L2 message with index ${msg.index} has invalid block number ${msg.l2BlockNumber}`);
+      } else if (msg.index !== lastIndex + 1n) {
+        throw new Error(`Expected L1 to L2 message with index ${lastIndex + 1n} but got ${msg.index}`);
       }
+      lastIndex = msg.index;
+      messages.push(msg.leaf);
     }
+
     return messages;
   }
+
+  public async *iterateL1ToL2Messages(range: CustomRange<bigint> = {}): AsyncIterableIterator<InboxMessage> {
+    const entriesRange = mapRange(range, this.indexToKey);
+    for await (const msgBuffer of this.#l1ToL2Messages.valuesAsync(entriesRange)) {
+      yield deserializeInboxMessage(msgBuffer);
+    }
+  }
+
+  public removeL1ToL2Messages(startIndex: bigint): Promise<void> {
+    this.#log.debug(`Deleting L1 to L2 messages from index ${startIndex}`);
+    let deleteCount = 0;
+
+    return this.db.transactionAsync(async () => {
+      for await (const [key, msgBuffer] of this.#l1ToL2Messages.entriesAsync({
+        start: this.indexToKey(startIndex),
+      })) {
+        this.#log.trace(`Deleting L1 to L2 message with index ${key - 1} from the store`);
+        await this.#l1ToL2Messages.delete(key);
+        await this.#l1ToL2MessageIndices.delete(this.leafToIndexKey(deserializeInboxMessage(msgBuffer).leaf));
+        deleteCount++;
+      }
+      await this.increaseTotalMessageCount(-deleteCount);
+      this.#log.warn(`Deleted ${deleteCount} L1 to L2 messages from index ${startIndex} from the store`);
+    });
+  }
+
+  public rollbackL1ToL2MessagesToL2Block(targetBlockNumber: number): Promise<void> {
+    this.#log.debug(`Deleting L1 to L2 messages up to target L2 block ${targetBlockNumber}`);
+    const startIndex = InboxLeaf.smallestIndexFromL2Block(targetBlockNumber + 1);
+    return this.removeL1ToL2Messages(startIndex);
+  }
+
+  private indexToKey(index: bigint): number {
+    return Number(index);
+  }
+
+  private leafToIndexKey(leaf: Fr): string {
+    return leaf.toString();
+  }
+
+  private async increaseTotalMessageCount(count: bigint | number): Promise<void> {
+    if (count === 0) {
+      return;
+    }
+    return await this.db.transactionAsync(async () => {
+      const lastTotalMessageCount = await this.getTotalL1ToL2MessageCount();
+      await this.#totalMessageCount.set(lastTotalMessageCount + BigInt(count));
+    });
+  }
 }

package/src/archiver/structs/inbox_message.ts

@@ -0,0 +1,41 @@
+import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
+import { keccak256 } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, bigintToUInt64BE, numToUInt32BE, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { UInt32 } from '@aztec/stdlib/types';
+
+export type InboxMessage = {
+  index: bigint;
+  leaf: Fr;
+  l2BlockNumber: UInt32;
+  l1BlockNumber: bigint;
+  l1BlockHash: Buffer32;
+  rollingHash: Buffer16;
+};
+
+export function updateRollingHash(currentRollingHash: Buffer16, leaf: Fr): Buffer16 {
+  const input = Buffer.concat([currentRollingHash.toBuffer(), leaf.toBuffer()]);
+  return Buffer16.fromBuffer(keccak256(input));
+}
+
+export function serializeInboxMessage(message: InboxMessage): Buffer {
+  return serializeToBuffer([
+    bigintToUInt64BE(message.index),
+    message.leaf,
+    message.l1BlockHash,
+    numToUInt32BE(Number(message.l1BlockNumber)),
+    numToUInt32BE(message.l2BlockNumber),
+    message.rollingHash,
+  ]);
+}
+
+export function deserializeInboxMessage(buffer: Buffer): InboxMessage {
+  const reader = BufferReader.asReader(buffer);
+  const index = reader.readUInt64();
+  const leaf = reader.readObject(Fr);
+  const l1BlockHash = reader.readObject(Buffer32);
+  const l1BlockNumber = BigInt(reader.readNumber());
+  const l2BlockNumber = reader.readNumber();
+  const rollingHash = reader.readObject(Buffer16);
+  return { index, leaf, l1BlockHash, l1BlockNumber, l2BlockNumber, rollingHash };
+}

package/src/archiver/structs/published.ts

@@ -1,11 +1,2 @@
-/** 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;
-};
+export type { PublishedL2Block } from '@aztec/stdlib/block';
+export type { L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';

package/src/archiver/validation.ts

@@ -0,0 +1,124 @@
+import type { EpochCache } from '@aztec/epoch-cache';
+import { EpochNumber } from '@aztec/foundation/branded-types';
+import { compactArray } from '@aztec/foundation/collection';
+import type { Logger } from '@aztec/foundation/log';
+import {
+  type AttestationInfo,
+  type ValidateBlockNegativeResult,
+  type ValidateBlockResult,
+  getAttestationInfoFromPayload,
+} from '@aztec/stdlib/block';
+import type { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { type L1RollupConstants, getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import { ConsensusPayload } from '@aztec/stdlib/p2p';
+
+export type { ValidateBlockResult };
+
+/**
+ * Extracts attestation information from a published checkpoint.
+ * Returns info for each attestation, preserving array indices.
+ */
+export function getAttestationInfoFromPublishedCheckpoint({
+  checkpoint,
+  attestations,
+}: PublishedCheckpoint): AttestationInfo[] {
+  const payload = ConsensusPayload.fromCheckpoint(checkpoint);
+  return getAttestationInfoFromPayload(payload, attestations);
+}
+
+/**
+ * Validates the attestations submitted for the given checkpoint.
+ * Returns true if the attestations are valid and sufficient, false otherwise.
+ */
+export async function validateCheckpointAttestations(
+  publishedCheckpoint: PublishedCheckpoint,
+  epochCache: EpochCache,
+  constants: Pick<L1RollupConstants, 'epochDuration'>,
+  logger?: Logger,
+): Promise<ValidateBlockResult> {
+  const attestorInfos = getAttestationInfoFromPublishedCheckpoint(publishedCheckpoint);
+  const attestors = compactArray(attestorInfos.map(info => ('address' in info ? info.address : undefined)));
+  const { checkpoint, attestations } = publishedCheckpoint;
+  const headerHash = checkpoint.header.hash();
+  const archiveRoot = checkpoint.archive.root.toString();
+  const slot = checkpoint.header.slotNumber;
+  const epoch: EpochNumber = getEpochAtSlot(slot, constants);
+  const { committee, seed } = await epochCache.getCommitteeForEpoch(epoch);
+  const logData = { checkpointNumber: checkpoint.number, slot, epoch, headerHash, archiveRoot };
+
+  logger?.debug(`Validating attestations for checkpoint ${checkpoint.number} at slot ${slot} in epoch ${epoch}`, {
+    committee: (committee ?? []).map(member => member.toString()),
+    recoveredAttestors: attestorInfos,
+    postedAttestations: attestations.map(a => (a.address.isZero() ? a.signature : a.address).toString()),
+    ...logData,
+  });
+
+  if (!committee || committee.length === 0) {
+    logger?.warn(
+      `No committee found for epoch ${epoch} at slot ${slot}. Accepting checkpoint without validation.`,
+      logData,
+    );
+    return { valid: true };
+  }
+
+  const requiredAttestationCount = Math.floor((committee.length * 2) / 3) + 1;
+
+  const failedValidationResult = <TReason extends ValidateBlockNegativeResult['reason']>(reason: TReason) => ({
+    valid: false as const,
+    reason,
+    block: checkpoint.blocks[0].toBlockInfo(),
+    committee,
+    seed,
+    epoch,
+    attestors,
+    attestations,
+  });
+
+  for (let i = 0; i < attestorInfos.length; i++) {
+    const info = attestorInfos[i];
+
+    // Fail on invalid signatures (no address recovered)
+    if (info.status === 'invalid-signature' || info.status === 'empty') {
+      logger?.warn(`Attestation with empty or invalid signature at slot ${slot}`, {
+        committee,
+        invalidIndex: i,
+        ...logData,
+      });
+      return { ...failedValidationResult('invalid-attestation'), invalidIndex: i };
+    }
+
+    // Check if the attestor at this index matches the committee member at the same index
+    if (info.status === 'recovered-from-signature' || info.status === 'provided-as-address') {
+      const signer = info.address.toString();
+      const expectedCommitteeMember = committee[i]?.toString();
+
+      if (!expectedCommitteeMember || signer !== expectedCommitteeMember) {
+        logger?.warn(
+          `Attestation at index ${i} from ${signer} does not match expected committee member ${expectedCommitteeMember} at slot ${slot}`,
+          {
+            committee,
+            invalidIndex: i,
+            ...logData,
+          },
+        );
+        return { ...failedValidationResult('invalid-attestation'), invalidIndex: i };
+      }
+    }
+  }
+
+  const validAttestationCount = attestorInfos.filter(info => info.status === 'recovered-from-signature').length;
+  if (validAttestationCount < requiredAttestationCount) {
+    logger?.warn(`Insufficient attestations for checkpoint at slot ${slot}`, {
+      requiredAttestations: requiredAttestationCount,
+      actualAttestations: validAttestationCount,
+      ...logData,
+    });
+    return failedValidationResult('insufficient-attestations');
+  }
+
+  logger?.debug(
+    `Checkpoint attestations validated successfully for checkpoint ${checkpoint.number} at slot ${slot}`,
+    logData,
+  );
+  return { valid: true };
+}

package/src/factory.ts

@@ -1,27 +1,28 @@
-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 { protocolContractNames } 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 { type ContractClassPublic, computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
 
-import { Archiver } from './archiver/archiver.js';
+import { Archiver, type ArchiverDeps } from './archiver/archiver.js';
 import type { ArchiverConfig } from './archiver/config.js';
-import { KVArchiverDataStore } from './archiver/index.js';
-import { createArchiverClient } from './rpc/index.js';
+import { ARCHIVER_DB_VERSION, KVArchiverDataStore } from './archiver/kv_archiver_store/kv_archiver_store.js';
+
+export const ARCHIVER_STORE_NAME = 'archiver';
+
+/** Creates an archiver store. */
+export async function createArchiverStore(
+  userConfig: Pick<ArchiverConfig, 'archiverStoreMapSizeKb' | 'maxLogs'> & DataStoreConfig,
+) {
+  const config = {
+    ...userConfig,
+    dataStoreMapSizeKb: userConfig.archiverStoreMapSizeKb ?? userConfig.dataStoreMapSizeKb,
+  };
+  const store = await createStore(ARCHIVER_STORE_NAME, ARCHIVER_DB_VERSION, config, createLogger('archiver:lmdb'));
+  return new KVArchiverDataStore(store, config.maxLogs);
+}
 
 /**
  * Creates a local archiver.
@@ -33,36 +34,12 @@ import { createArchiverClient } from './rpc/index.js';
  */
 export async function createArchiver(
   config: ArchiverConfig & DataStoreConfig,
-  blobSinkClient: BlobSinkClientInterface,
+  deps: ArchiverDeps,
   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);
+): Promise<Archiver> {
+  const archiverStore = await createArchiverStore(config);
   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()),
-  );
+  return Archiver.createAndSync(config, archiverStore, deps, opts.blockUntilSync);
 }
 
 async function registerProtocolContracts(store: KVArchiverDataStore) {
@@ -73,35 +50,16 @@ async function registerProtocolContracts(store: KVArchiverDataStore) {
     const contractClassPublic: ContractClassPublic = {
       ...contract.contractClass,
       privateFunctions: [],
-      unconstrainedFunctions: [],
+      utilityFunctions: [],
     };
 
     const publicFunctionSignatures = contract.artifact.functions
       .filter(fn => fn.functionType === FunctionType.PUBLIC)
       .map(fn => decodeFunctionSignature(fn.name, fn.parameters));
 
-    await store.registerContractFunctionSignatures(contract.address, publicFunctionSignatures);
+    await store.registerContractFunctionSignatures(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

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

package/src/rpc/index.ts

@@ -1,7 +1,7 @@
 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';
+import { makeTracedFetch } from '@aztec/telemetry-client';
 
 export function createArchiverClient(
   url: string,
@@ -14,7 +14,3 @@ export function createArchiverClient(
     onResponse: getVersioningResponseHandler(versions),
   });
 }
-
-export function createArchiverRpcServer(handler: ArchiverApi) {
-  return createTracedJsonRpcServer(handler, ArchiverApiSchema);
-}

package/src/test/mock_archiver.ts

@@ -15,7 +15,7 @@ export class MockArchiver extends MockL2BlockSource implements L2BlockSource, L1
     this.messageSource.setL1ToL2Messages(blockNumber, msgs);
   }
 
-  getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
+  getL1ToL2Messages(blockNumber: number): Promise<Fr[]> {
     return this.messageSource.getL1ToL2Messages(blockNumber);
   }