@aztec/archiver 0.23.0 → 0.24.0

package/src/archiver/kv_archiver_store/block_store.ts

@@ -0,0 +1,164 @@
+import { INITIAL_L2_BLOCK_NUM, L2Block, L2Tx, TxHash } from '@aztec/circuit-types';
+import { AztecAddress } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { AztecKVStore, AztecMap, Range } from '@aztec/kv-store';
+
+type BlockIndexValue = [blockNumber: number, index: number];
+
+type BlockContext = {
+  blockNumber: number;
+  l1BlockNumber: bigint;
+  block: Buffer;
+};
+
+/**
+ * LMDB implementation of the ArchiverDataStore interface.
+ */
+export class BlockStore {
+  /** Map block number to block data */
+  #blocks: AztecMap<number, BlockContext>;
+
+  /** Index mapping transaction hash (as a string) to its location in a block */
+  #txIndex: AztecMap<string, BlockIndexValue>;
+
+  /** Index mapping a contract's address (as a string) to its location in a block */
+  #contractIndex: AztecMap<string, BlockIndexValue>;
+
+  #log = createDebugLogger('aztec:archiver:block_store');
+
+  constructor(private db: AztecKVStore) {
+    this.#blocks = db.openMap('archiver_blocks');
+
+    this.#txIndex = db.openMap('archiver_tx_index');
+    this.#contractIndex = db.openMap('archiver_contract_index');
+  }
+
+  /**
+   * Append new blocks to the store's list.
+   * @param blocks - The L2 blocks to be added to the store.
+   * @returns True if the operation is successful.
+   */
+  addBlocks(blocks: L2Block[]): Promise<boolean> {
+    return this.db.transaction(() => {
+      for (const block of blocks) {
+        void this.#blocks.set(block.number, {
+          blockNumber: block.number,
+          block: block.toBuffer(),
+          l1BlockNumber: block.getL1BlockNumber(),
+        });
+
+        for (const [i, tx] of block.getTxs().entries()) {
+          if (tx.txHash.isZero()) {
+            continue;
+          }
+          void this.#txIndex.set(tx.txHash.toString(), [block.number, i]);
+        }
+
+        for (const [i, contractData] of block.newContractData.entries()) {
+          if (contractData.contractAddress.isZero()) {
+            continue;
+          }
+
+          void this.#contractIndex.set(contractData.contractAddress.toString(), [block.number, i]);
+        }
+      }
+
+      return true;
+    });
+  }
+
+  /**
+   * Gets up to `limit` amount of L2 blocks starting from `from`.
+   * @param start - Number of the first block to return (inclusive).
+   * @param limit - The number of blocks to return.
+   * @returns The requested L2 blocks, without logs attached
+   */
+  *getBlocks(start: number, limit: number): IterableIterator<L2Block> {
+    for (const blockCtx of this.#blocks.values(this.#computeBlockRange(start, limit))) {
+      yield L2Block.fromBuffer(blockCtx.block);
+    }
+  }
+
+  /**
+   * Gets an L2 block.
+   * @param blockNumber - The number of the block to return.
+   * @returns The requested L2 block, without logs attached
+   */
+  getBlock(blockNumber: number): L2Block | undefined {
+    const blockCtx = this.#blocks.get(blockNumber);
+    if (!blockCtx || !blockCtx.block) {
+      return undefined;
+    }
+
+    return L2Block.fromBuffer(blockCtx.block);
+  }
+
+  /**
+   * Gets an l2 tx.
+   * @param txHash - The txHash of the l2 tx.
+   * @returns The requested L2 tx.
+   */
+  getL2Tx(txHash: TxHash): L2Tx | undefined {
+    const [blockNumber, txIndex] = this.getL2TxLocation(txHash) ?? [];
+    if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
+      return undefined;
+    }
+
+    const block = this.getBlock(blockNumber);
+    return block?.getTx(txIndex);
+  }
+
+  /**
+   * Looks up which block included the requested L2 tx.
+   * @param txHash - The txHash of the l2 tx.
+   * @returns The block number and index of the tx.
+   */
+  getL2TxLocation(txHash: TxHash): [blockNumber: number, txIndex: number] | undefined {
+    return this.#txIndex.get(txHash.toString());
+  }
+
+  /**
+   * Looks up which block deployed a particular contract.
+   * @param contractAddress - The address of the contract to look up.
+   * @returns The block number and index of the contract.
+   */
+  getContractLocation(contractAddress: AztecAddress): [blockNumber: number, index: number] | undefined {
+    return this.#contractIndex.get(contractAddress.toString());
+  }
+
+  /**
+   * Gets the number of the latest L2 block processed.
+   * @returns The number of the latest L2 block processed.
+   */
+  getBlockNumber(): number {
+    const [lastBlockNumber] = this.#blocks.keys({ reverse: true, limit: 1 });
+    return typeof lastBlockNumber === 'number' ? lastBlockNumber : INITIAL_L2_BLOCK_NUM - 1;
+  }
+
+  /**
+   * Gets the most recent L1 block processed.
+   * @returns The L1 block that published the latest L2 block
+   */
+  getL1BlockNumber(): bigint {
+    const [lastBlock] = this.#blocks.values({ reverse: true, limit: 1 });
+    if (!lastBlock) {
+      return 0n;
+    } else {
+      return lastBlock.l1BlockNumber;
+    }
+  }
+
+  #computeBlockRange(start: number, limit: number): Required<Pick<Range<number>, 'start' | 'end'>> {
+    if (limit < 1) {
+      throw new Error(`Invalid limit: ${limit}`);
+    }
+
+    if (start < INITIAL_L2_BLOCK_NUM) {
+      this.#log(`Clamping start block ${start} to ${INITIAL_L2_BLOCK_NUM}`);
+      start = INITIAL_L2_BLOCK_NUM;
+    }
+
+    const end = start + limit;
+    return { start, end };
+  }
+}

package/src/archiver/kv_archiver_store/contract_class_store.ts

@@ -0,0 +1,64 @@
+import { Fr, FunctionSelector } from '@aztec/circuits.js';
+import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
+import { AztecKVStore, AztecMap } from '@aztec/kv-store';
+import { ContractClassPublic } from '@aztec/types/contracts';
+
+/**
+ * LMDB implementation of the ArchiverDataStore interface.
+ */
+export class ContractClassStore {
+  #contractClasses: AztecMap<string, Buffer>;
+
+  constructor(db: AztecKVStore) {
+    this.#contractClasses = db.openMap('archiver_contract_classes');
+  }
+
+  addContractClass(contractClass: ContractClassPublic): Promise<boolean> {
+    return this.#contractClasses.set(contractClass.id.toString(), serializeContractClassPublic(contractClass));
+  }
+
+  getContractClass(id: Fr): ContractClassPublic | undefined {
+    const contractClass = this.#contractClasses.get(id.toString());
+    return contractClass && { ...deserializeContractClassPublic(contractClass), id };
+  }
+}
+
+export function serializeContractClassPublic(contractClass: ContractClassPublic): Buffer {
+  return serializeToBuffer(
+    numToUInt8(contractClass.version),
+    contractClass.artifactHash,
+    contractClass.privateFunctions?.length ?? 0,
+    contractClass.privateFunctions?.map(f => serializeToBuffer(f.selector, f.vkHash, f.isInternal)) ?? [],
+    contractClass.publicFunctions.length,
+    contractClass.publicFunctions?.map(f =>
+      serializeToBuffer(f.selector, f.bytecode.length, f.bytecode, f.isInternal),
+    ) ?? [],
+    contractClass.packedBytecode.length,
+    contractClass.packedBytecode,
+    contractClass.privateFunctionsRoot,
+  );
+}
+
+export function deserializeContractClassPublic(buffer: Buffer): Omit<ContractClassPublic, 'id'> {
+  const reader = BufferReader.asReader(buffer);
+  return {
+    version: reader.readUInt8() as 1,
+    artifactHash: reader.readObject(Fr),
+    privateFunctions: reader.readVector({
+      fromBuffer: reader => ({
+        selector: reader.readObject(FunctionSelector),
+        vkHash: reader.readObject(Fr),
+        isInternal: reader.readBoolean(),
+      }),
+    }),
+    publicFunctions: reader.readVector({
+      fromBuffer: reader => ({
+        selector: reader.readObject(FunctionSelector),
+        bytecode: reader.readBuffer(),
+        isInternal: reader.readBoolean(),
+      }),
+    }),
+    packedBytecode: reader.readBuffer(),
+    privateFunctionsRoot: reader.readObject(Fr),
+  };
+}

package/src/archiver/kv_archiver_store/contract_instance_store.ts

@@ -0,0 +1,26 @@
+import { AztecAddress } from '@aztec/circuits.js';
+import { AztecKVStore, AztecMap } from '@aztec/kv-store';
+import { ContractInstanceWithAddress, SerializableContractInstance } from '@aztec/types/contracts';
+
+/**
+ * LMDB implementation of the ArchiverDataStore interface.
+ */
+export class ContractInstanceStore {
+  #contractInstances: AztecMap<string, Buffer>;
+
+  constructor(db: AztecKVStore) {
+    this.#contractInstances = db.openMap('archiver_contract_instances');
+  }
+
+  addContractInstance(contractInstance: ContractInstanceWithAddress): Promise<boolean> {
+    return this.#contractInstances.set(
+      contractInstance.address.toString(),
+      new SerializableContractInstance(contractInstance).toBuffer(),
+    );
+  }
+
+  getContractInstance(address: AztecAddress): ContractInstanceWithAddress | undefined {
+    const contractInstance = this.#contractInstances.get(address.toString());
+    return contractInstance && SerializableContractInstance.fromBuffer(contractInstance).withAddress(address);
+  }
+}

package/src/archiver/kv_archiver_store/contract_store.ts

@@ -0,0 +1,93 @@
+import { ContractData, ExtendedContractData } from '@aztec/circuit-types';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { AztecKVStore, AztecMap } from '@aztec/kv-store';
+
+import { BlockStore } from './block_store.js';
+
+/**
+ * LMDB implementation of the ArchiverDataStore interface.
+ */
+export class ContractStore {
+  #blockStore: BlockStore;
+  #extendedContractData: AztecMap<number, Buffer[]>;
+  #log = createDebugLogger('aztec:archiver:contract_store');
+
+  constructor(private db: AztecKVStore, blockStore: BlockStore) {
+    this.#extendedContractData = db.openMap('archiver_extended_contract_data');
+    this.#blockStore = blockStore;
+  }
+
+  /**
+   * Add new extended contract data from an L2 block to the store's list.
+   * @param data - List of contracts' data to be added.
+   * @param blockNum - Number of the L2 block the contract data was deployed in.
+   * @returns True if the operation is successful.
+   */
+  addExtendedContractData(data: ExtendedContractData[], blockNum: number): Promise<boolean> {
+    return this.#extendedContractData.swap(blockNum, (existingData = []) => {
+      existingData.push(...data.map(d => d.toBuffer()));
+      return existingData;
+    });
+  }
+
+  /**
+   * Get the extended contract data for this contract.
+   * @param contractAddress - The contract data address.
+   * @returns The extended contract data or undefined if not found.
+   */
+  getExtendedContractData(contractAddress: AztecAddress): ExtendedContractData | undefined {
+    const [blockNumber, _] = this.#blockStore.getContractLocation(contractAddress) ?? [];
+
+    if (typeof blockNumber !== 'number') {
+      return undefined;
+    }
+
+    for (const contract of this.#extendedContractData.get(blockNumber) ?? []) {
+      const extendedContractData = ExtendedContractData.fromBuffer(contract);
+      if (extendedContractData.contractData.contractAddress.equals(contractAddress)) {
+        return extendedContractData;
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Lookup all extended contract data in an L2 block.
+   * @param blockNumber - The block number to get all contract data from.
+   * @returns All extended contract data in the block (if found).
+   */
+  getExtendedContractDataInBlock(blockNumber: number): Array<ExtendedContractData> {
+    return (this.#extendedContractData.get(blockNumber) ?? []).map(contract =>
+      ExtendedContractData.fromBuffer(contract),
+    );
+  }
+
+  /**
+   * Get basic info for an L2 contract.
+   * Contains contract address & the ethereum portal address.
+   * @param contractAddress - The contract data address.
+   * @returns ContractData with the portal address (if we didn't throw an error).
+   */
+  getContractData(contractAddress: AztecAddress): ContractData | undefined {
+    const [blockNumber, index] = this.#blockStore.getContractLocation(contractAddress) ?? [];
+    if (typeof blockNumber !== 'number' || typeof index !== 'number') {
+      return undefined;
+    }
+
+    const block = this.#blockStore.getBlock(blockNumber);
+    return block?.newContractData[index];
+  }
+
+  /**
+   * Get basic info for an all L2 contracts deployed in a block.
+   * Contains contract address & the ethereum portal address.
+   * @param blockNumber - Number of the L2 block where contracts were deployed.
+   * @returns ContractData with the portal address (if we didn't throw an error).
+   */
+  getContractDataInBlock(blockNumber: number): ContractData[] {
+    const block = this.#blockStore.getBlock(blockNumber);
+    return block?.newContractData ?? [];
+  }
+}

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -0,0 +1,264 @@
+import {
+  ContractData,
+  ExtendedContractData,
+  GetUnencryptedLogsResponse,
+  L1ToL2Message,
+  L2Block,
+  L2BlockL2Logs,
+  L2Tx,
+  LogFilter,
+  LogType,
+  TxHash,
+} from '@aztec/circuit-types';
+import { Fr } from '@aztec/circuits.js';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { AztecKVStore } from '@aztec/kv-store';
+import { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/types/contracts';
+
+import { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
+import { BlockStore } from './block_store.js';
+import { ContractClassStore } from './contract_class_store.js';
+import { ContractInstanceStore } from './contract_instance_store.js';
+import { ContractStore } from './contract_store.js';
+import { LogStore } from './log_store.js';
+import { MessageStore } from './message_store.js';
+
+/**
+ * LMDB implementation of the ArchiverDataStore interface.
+ */
+export class KVArchiverDataStore implements ArchiverDataStore {
+  #blockStore: BlockStore;
+  #logStore: LogStore;
+  #contractStore: ContractStore;
+  #messageStore: MessageStore;
+  #contractClassStore: ContractClassStore;
+  #contractInstanceStore: ContractInstanceStore;
+
+  #log = createDebugLogger('aztec:archiver:data-store');
+
+  constructor(db: AztecKVStore, logsMaxPageSize: number = 1000) {
+    this.#blockStore = new BlockStore(db);
+    this.#logStore = new LogStore(db, this.#blockStore, logsMaxPageSize);
+    this.#contractStore = new ContractStore(db, this.#blockStore);
+    this.#messageStore = new MessageStore(db);
+    this.#contractClassStore = new ContractClassStore(db);
+    this.#contractInstanceStore = new ContractInstanceStore(db);
+  }
+
+  getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
+    return Promise.resolve(this.#contractClassStore.getContractClass(id));
+  }
+
+  getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    return Promise.resolve(this.#contractInstanceStore.getContractInstance(address));
+  }
+
+  async addContractClasses(data: ContractClassPublic[], _blockNumber: number): Promise<boolean> {
+    return (await Promise.all(data.map(c => this.#contractClassStore.addContractClass(c)))).every(Boolean);
+  }
+
+  async addContractInstances(data: ContractInstanceWithAddress[], _blockNumber: number): Promise<boolean> {
+    return (await Promise.all(data.map(c => this.#contractInstanceStore.addContractInstance(c)))).every(Boolean);
+  }
+
+  /**
+   * Append new blocks to the store's list.
+   * @param blocks - The L2 blocks to be added to the store.
+   * @returns True if the operation is successful.
+   */
+  addBlocks(blocks: L2Block[]): Promise<boolean> {
+    return this.#blockStore.addBlocks(blocks);
+  }
+
+  /**
+   * Gets up to `limit` amount of L2 blocks starting from `from`.
+   * The blocks returned do not contain any logs.
+   *
+   * @param start - Number of the first block to return (inclusive).
+   * @param limit - The number of blocks to return.
+   * @returns The requested L2 blocks, without any logs attached
+   */
+  getBlocks(start: number, limit: number): Promise<L2Block[]> {
+    try {
+      return Promise.resolve(Array.from(this.#blockStore.getBlocks(start, limit)));
+    } catch (err) {
+      // this function is sync so if any errors are thrown we need to make sure they're passed on as rejected Promises
+      return Promise.reject(err);
+    }
+  }
+
+  /**
+   * Gets an l2 tx.
+   * @param txHash - The txHash of the l2 tx.
+   * @returns The requested L2 tx.
+   */
+  getL2Tx(txHash: TxHash): Promise<L2Tx | undefined> {
+    return Promise.resolve(this.#blockStore.getL2Tx(txHash));
+  }
+
+  /**
+   * Append new logs to the store's list.
+   * @param encryptedLogs - The logs to be added to the store.
+   * @param unencryptedLogs - The type of the logs to be added to the store.
+   * @param blockNumber - The block for which to add the logs.
+   * @returns True if the operation is successful.
+   */
+  addLogs(
+    encryptedLogs: L2BlockL2Logs | undefined,
+    unencryptedLogs: L2BlockL2Logs | undefined,
+    blockNumber: number,
+  ): Promise<boolean> {
+    return this.#logStore.addLogs(encryptedLogs, unencryptedLogs, blockNumber);
+  }
+
+  /**
+   * Append new pending L1 to L2 messages to the store.
+   * @param messages - The L1 to L2 messages to be added to the store.
+   * @param l1BlockNumber - The L1 block number for which to add the messages.
+   * @returns True if the operation is successful.
+   */
+  addPendingL1ToL2Messages(messages: L1ToL2Message[], l1BlockNumber: bigint): Promise<boolean> {
+    return Promise.resolve(this.#messageStore.addPendingMessages(messages, l1BlockNumber));
+  }
+
+  /**
+   * Remove pending L1 to L2 messages from the store (if they were cancelled).
+   * @param messages - The message keys to be removed from the store.
+   * @param l1BlockNumber - The L1 block number for which to remove the messages.
+   * @returns True if the operation is successful.
+   */
+  cancelPendingL1ToL2Messages(messages: Fr[], l1BlockNumber: bigint): Promise<boolean> {
+    return Promise.resolve(this.#messageStore.cancelPendingMessages(messages, l1BlockNumber));
+  }
+
+  /**
+   * Messages that have been published in an L2 block are confirmed.
+   * Add them to the confirmed store, also remove them from the pending store.
+   * @param entryKeys - The message keys to be removed from the store.
+   * @param blockNumber - The block for which to add the messages.
+   * @returns True if the operation is successful.
+   */
+  confirmL1ToL2Messages(entryKeys: Fr[]): Promise<boolean> {
+    return this.#messageStore.confirmPendingMessages(entryKeys);
+  }
+
+  /**
+   * Gets up to `limit` amount of pending L1 to L2 messages, sorted by fee
+   * @param limit - The number of messages to return (by default NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).
+   * @returns The requested L1 to L2 message keys.
+   */
+  getPendingL1ToL2MessageKeys(limit: number): Promise<Fr[]> {
+    return Promise.resolve(this.#messageStore.getPendingMessageKeysByFee(limit));
+  }
+
+  /**
+   * Gets the confirmed L1 to L2 message corresponding to the given message key.
+   * @param messageKey - The message key to look up.
+   * @returns The requested L1 to L2 message or throws if not found.
+   */
+  getConfirmedL1ToL2Message(messageKey: Fr): Promise<L1ToL2Message> {
+    try {
+      return Promise.resolve(this.#messageStore.getConfirmedMessage(messageKey));
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+
+  /**
+   * Gets up to `limit` amount of logs starting from `from`.
+   * @param start - Number of the L2 block to which corresponds the first logs to be returned.
+   * @param limit - The number of logs to return.
+   * @param logType - Specifies whether to return encrypted or unencrypted logs.
+   * @returns The requested logs.
+   */
+  getLogs(start: number, limit: number, logType: LogType): Promise<L2BlockL2Logs[]> {
+    try {
+      return Promise.resolve(Array.from(this.#logStore.getLogs(start, limit, logType)));
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+
+  /**
+   * Gets unencrypted logs based on the provided filter.
+   * @param filter - The filter to apply to the logs.
+   * @returns The requested logs.
+   */
+  getUnencryptedLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
+    try {
+      return Promise.resolve(this.#logStore.getUnencryptedLogs(filter));
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+
+  /**
+   * Add new extended contract data from an L2 block to the store's list.
+   * @param data - List of contracts' data to be added.
+   * @param blockNum - Number of the L2 block the contract data was deployed in.
+   * @returns True if the operation is successful.
+   */
+  addExtendedContractData(data: ExtendedContractData[], blockNum: number): Promise<boolean> {
+    return this.#contractStore.addExtendedContractData(data, blockNum);
+  }
+
+  /**
+   * Get the extended contract data for this contract.
+   * @param contractAddress - The contract data address.
+   * @returns The extended contract data or undefined if not found.
+   */
+  getExtendedContractData(contractAddress: AztecAddress): Promise<ExtendedContractData | undefined> {
+    return Promise.resolve(this.#contractStore.getExtendedContractData(contractAddress));
+  }
+
+  /**
+   * Lookup all extended contract data in an L2 block.
+   * @param blockNumber - The block number to get all contract data from.
+   * @returns All extended contract data in the block (if found).
+   */
+  getExtendedContractDataInBlock(blockNumber: number): Promise<ExtendedContractData[]> {
+    return Promise.resolve(Array.from(this.#contractStore.getExtendedContractDataInBlock(blockNumber)));
+  }
+
+  /**
+   * Get basic info for an L2 contract.
+   * Contains contract address & the ethereum portal address.
+   * @param contractAddress - The contract data address.
+   * @returns ContractData with the portal address (if we didn't throw an error).
+   */
+  getContractData(contractAddress: AztecAddress): Promise<ContractData | undefined> {
+    return Promise.resolve(this.#contractStore.getContractData(contractAddress));
+  }
+
+  /**
+   * Get basic info for an all L2 contracts deployed in a block.
+   * Contains contract address & the ethereum portal address.
+   * @param blockNumber - Number of the L2 block where contracts were deployed.
+   * @returns ContractData with the portal address (if we didn't throw an error).
+   */
+  getContractDataInBlock(blockNumber: number): Promise<ContractData[]> {
+    return Promise.resolve(Array.from(this.#contractStore.getContractDataInBlock(blockNumber)));
+  }
+
+  /**
+   * Gets the number of the latest L2 block processed.
+   * @returns The number of the latest L2 block processed.
+   */
+  getBlockNumber(): Promise<number> {
+    return Promise.resolve(this.#blockStore.getBlockNumber());
+  }
+
+  /**
+   * Gets the last L1 block number processed by the archiver
+   */
+  getL1BlockNumber(): Promise<ArchiverL1SynchPoint> {
+    const addedBlock = this.#blockStore.getL1BlockNumber();
+    const { addedMessages, cancelledMessages } = this.#messageStore.getL1BlockNumber();
+    return Promise.resolve({
+      addedBlock,
+      addedMessages,
+      cancelledMessages,
+    });
+  }
+}