@aztec/archiver 0.16.4 → 0.16.6

package/src/archiver/memory_archiver_store/l1_to_l2_message_store.ts

@@ -1,110 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { L1ToL2Message } from '@aztec/types';
-
-/**
- * A simple in-memory implementation of an L1 to L2 message store
- * that handles message duplication.
- */
-export class L1ToL2MessageStore {
-  /**
-   * A map containing the message key to the corresponding L1 to L2
-   * messages (and the number of times the message has been seen).
-   */
-  protected store: Map<bigint, L1ToL2MessageAndCount> = new Map();
-  private messagesByBlock = new Set<string>();
-
-  constructor() {}
-
-  addMessage(messageKey: Fr, message: L1ToL2Message, l1BlocKNumber: bigint, messageIndex: number) {
-    if (this.messagesByBlock.has(`${l1BlocKNumber}-${messageIndex}`)) {
-      return;
-    }
-    this.messagesByBlock.add(`${l1BlocKNumber}-${messageIndex}`);
-
-    this.addMessageUnsafe(messageKey, message);
-  }
-
-  addMessageUnsafe(messageKey: Fr, message: L1ToL2Message) {
-    const messageKeyBigInt = messageKey.value;
-    const msgAndCount = this.store.get(messageKeyBigInt);
-    if (msgAndCount) {
-      msgAndCount.count++;
-    } else {
-      this.store.set(messageKeyBigInt, { message, count: 1 });
-    }
-  }
-
-  getMessage(messageKey: Fr): L1ToL2Message | undefined {
-    return this.store.get(messageKey.value)?.message;
-  }
-
-  getMessageAndCount(messageKey: Fr): L1ToL2MessageAndCount | undefined {
-    return this.store.get(messageKey.value);
-  }
-}
-
-/**
- * Specifically for the store that will hold pending messages
- * for removing messages or fetching multiple messages.
- */
-export class PendingL1ToL2MessageStore extends L1ToL2MessageStore {
-  private cancelledMessagesByBlock = new Set<string>();
-  getMessageKeys(limit: number): Fr[] {
-    if (limit < 1) {
-      return [];
-    }
-    // fetch `limit` number of messages from the store with the highest fee.
-    // Note the store has multiple of the same message. So if a message has count 2, include both of them in the result:
-    const messages: Fr[] = [];
-    const sortedMessages = Array.from(this.store.values()).sort((a, b) => b.message.fee - a.message.fee);
-    for (const messageAndCount of sortedMessages) {
-      for (let i = 0; i < messageAndCount.count; i++) {
-        messages.push(messageAndCount.message.entryKey!);
-        if (messages.length === limit) {
-          return messages;
-        }
-      }
-    }
-    return messages;
-  }
-
-  removeMessage(messageKey: Fr, l1BlockNumber: bigint, messageIndex: number) {
-    // ignore 0 - messageKey is a hash, so a 0 can probabilistically never occur. It is best to skip it.
-    if (messageKey.equals(Fr.ZERO)) {
-      return;
-    }
-
-    if (this.cancelledMessagesByBlock.has(`${l1BlockNumber}-${messageIndex}`)) {
-      return;
-    }
-    this.cancelledMessagesByBlock.add(`${l1BlockNumber}-${messageIndex}`);
-    this.removeMessageUnsafe(messageKey);
-  }
-
-  removeMessageUnsafe(messageKey: Fr) {
-    const messageKeyBigInt = messageKey.value;
-    const msgAndCount = this.store.get(messageKeyBigInt);
-    if (!msgAndCount) {
-      throw new Error(`Unable to remove message: L1 to L2 Message with key ${messageKeyBigInt} not found in store`);
-    }
-    if (msgAndCount.count > 1) {
-      msgAndCount.count--;
-    } else {
-      this.store.delete(messageKeyBigInt);
-    }
-  }
-}
-
-/**
- * Useful to keep track of the number of times a message has been seen.
- */
-type L1ToL2MessageAndCount = {
-  /**
-   * The message.
-   */
-  message: L1ToL2Message;
-  /**
-   * The number of times the message has been seen.
-   */
-  count: number;
-};

package/src/archiver/memory_archiver_store/memory_archiver_store.ts

@@ -1,399 +0,0 @@
-import { Fr, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/circuits.js';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
-import {
-  CancelledL1ToL2Message,
-  ContractData,
-  ExtendedContractData,
-  ExtendedUnencryptedL2Log,
-  GetUnencryptedLogsResponse,
-  INITIAL_L2_BLOCK_NUM,
-  L1ToL2Message,
-  L2Block,
-  L2BlockContext,
-  L2BlockL2Logs,
-  L2Tx,
-  LogFilter,
-  LogId,
-  LogType,
-  PendingL1ToL2Message,
-  TxHash,
-  UnencryptedL2Log,
-} from '@aztec/types';
-
-import { ArchiverDataStore } from '../archiver_store.js';
-import { L1ToL2MessageStore, PendingL1ToL2MessageStore } from './l1_to_l2_message_store.js';
-
-/**
- * Simple, in-memory implementation of an archiver data store.
- */
-export class MemoryArchiverStore implements ArchiverDataStore {
-  /**
-   * An array containing all the L2 blocks that have been fetched so far.
-   */
-  private l2BlockContexts: L2BlockContext[] = [];
-
-  /**
-   * An array containing all the L2 Txs in the L2 blocks that have been fetched so far.
-   */
-  private l2Txs: L2Tx[] = [];
-
-  /**
-   * An array containing all the encrypted logs that have been fetched so far.
-   * Note: Index in the "outer" array equals to (corresponding L2 block's number - INITIAL_L2_BLOCK_NUM).
-   */
-  private encryptedLogsPerBlock: L2BlockL2Logs[] = [];
-
-  /**
-   * An array containing all the unencrypted logs that have been fetched so far.
-   * Note: Index in the "outer" array equals to (corresponding L2 block's number - INITIAL_L2_BLOCK_NUM).
-   */
-  private unencryptedLogsPerBlock: L2BlockL2Logs[] = [];
-
-  /**
-   * A sparse array containing all the extended contract data that have been fetched so far.
-   */
-  private extendedContractDataByBlock: (ExtendedContractData[] | undefined)[] = [];
-
-  /**
-   * A mapping of contract address to extended contract data.
-   */
-  private extendedContractData: Map<string, ExtendedContractData> = new Map();
-
-  /**
-   * Contains all the confirmed L1 to L2 messages (i.e. messages that were consumed in an L2 block)
-   * It is a map of entryKey to the corresponding L1 to L2 message and the number of times it has appeared
-   */
-  private confirmedL1ToL2Messages: L1ToL2MessageStore = new L1ToL2MessageStore();
-
-  /**
-   * Contains all the pending L1 to L2 messages (accounts for duplication of messages)
-   */
-  private pendingL1ToL2Messages: PendingL1ToL2MessageStore = new PendingL1ToL2MessageStore();
-
-  constructor(
-    /** The max number of logs that can be obtained in 1 "getUnencryptedLogs" call. */
-    public readonly maxLogs: number,
-  ) {}
-
-  /**
-   * 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 (always in this implementation).
-   */
-  public addBlocks(blocks: L2Block[]): Promise<boolean> {
-    this.l2BlockContexts.push(...blocks.map(block => new L2BlockContext(block)));
-    this.l2Txs.push(...blocks.flatMap(b => b.getTxs()));
-    return Promise.resolve(true);
-  }
-
-  /**
-   * Append new logs to the store's list.
-   * @param encryptedLogs - The encrypted logs to be added to the store.
-   * @param unencryptedLogs - The unencrypted 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, unencryptedLogs: L2BlockL2Logs, blockNumber: number): Promise<boolean> {
-    if (encryptedLogs) {
-      this.encryptedLogsPerBlock[blockNumber - INITIAL_L2_BLOCK_NUM] = encryptedLogs;
-    }
-
-    if (unencryptedLogs) {
-      this.unencryptedLogsPerBlock[blockNumber - INITIAL_L2_BLOCK_NUM] = unencryptedLogs;
-    }
-
-    return Promise.resolve(true);
-  }
-
-  /**
-   * Append new pending L1 to L2 messages to the store.
-   * @param messages - The L1 to L2 messages to be added to the store.
-   * @returns True if the operation is successful (always in this implementation).
-   */
-  public addPendingL1ToL2Messages(messages: PendingL1ToL2Message[]): Promise<boolean> {
-    for (const { message, blockNumber, indexInBlock } of messages) {
-      this.pendingL1ToL2Messages.addMessage(message.entryKey!, message, blockNumber, indexInBlock);
-    }
-    return Promise.resolve(true);
-  }
-
-  /**
-   * Remove pending L1 to L2 messages from the store (if they were cancelled).
-   * @param messages - The message keys to be removed from the store.
-   * @returns True if the operation is successful (always in this implementation).
-   */
-  public cancelPendingL1ToL2Messages(messages: CancelledL1ToL2Message[]): Promise<boolean> {
-    messages.forEach(({ entryKey, blockNumber, indexInBlock }) => {
-      this.pendingL1ToL2Messages.removeMessage(entryKey, blockNumber, indexInBlock);
-    });
-    return Promise.resolve(true);
-  }
-
-  /**
-   * 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 messageKeys - The message keys to be removed from the store.
-   * @returns True if the operation is successful (always in this implementation).
-   */
-  public confirmL1ToL2Messages(messageKeys: Fr[]): Promise<boolean> {
-    messageKeys.forEach(messageKey => {
-      this.confirmedL1ToL2Messages.addMessageUnsafe(messageKey, this.pendingL1ToL2Messages.getMessage(messageKey)!);
-      this.pendingL1ToL2Messages.removeMessageUnsafe(messageKey);
-    });
-    return Promise.resolve(true);
-  }
-
-  /**
-   * Store 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 (always in this implementation).
-   */
-  public addExtendedContractData(data: ExtendedContractData[], blockNum: number): Promise<boolean> {
-    // Add to the contracts mapping
-    for (const contractData of data) {
-      const key = contractData.contractData.contractAddress.toString();
-      this.extendedContractData.set(key, contractData);
-    }
-
-    // Add the index per block
-    if (this.extendedContractDataByBlock[blockNum]?.length) {
-      this.extendedContractDataByBlock[blockNum]?.push(...data);
-    } else {
-      this.extendedContractDataByBlock[blockNum] = [...data];
-    }
-    return Promise.resolve(true);
-  }
-
-  /**
-   * Gets up to `limit` amount of L2 blocks starting from `from`.
-   * @param from - Number of the first block to return (inclusive).
-   * @param limit - The number of blocks to return.
-   * @returns The requested L2 blocks.
-   * @remarks When "from" is smaller than genesis block number, blocks from the beginning are returned.
-   */
-  public getBlocks(from: number, limit: number): Promise<L2Block[]> {
-    // Return an empty array if we are outside of range
-    if (limit < 1) {
-      return Promise.reject(new Error(`Invalid limit: ${limit}`));
-    }
-
-    const fromIndex = Math.max(from - INITIAL_L2_BLOCK_NUM, 0);
-    if (fromIndex >= this.l2BlockContexts.length) {
-      return Promise.resolve([]);
-    }
-
-    const toIndex = fromIndex + limit;
-    return Promise.resolve(this.l2BlockContexts.slice(fromIndex, toIndex).map(blockContext => blockContext.block));
-  }
-
-  /**
-   * Gets an l2 tx.
-   * @param txHash - The txHash of the l2 tx.
-   * @returns The requested L2 tx.
-   */
-  public getL2Tx(txHash: TxHash): Promise<L2Tx | undefined> {
-    const l2Tx = this.l2Txs.find(tx => tx.txHash.equals(txHash));
-    return Promise.resolve(l2Tx);
-  }
-
-  /**
-   * 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.
-   */
-  public getPendingL1ToL2MessageKeys(limit: number = NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP): Promise<Fr[]> {
-    return Promise.resolve(this.pendingL1ToL2Messages.getMessageKeys(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.
-   */
-  public getConfirmedL1ToL2Message(messageKey: Fr): Promise<L1ToL2Message> {
-    const message = this.confirmedL1ToL2Messages.getMessage(messageKey);
-    if (!message) {
-      throw new Error(`L1 to L2 Message with key ${messageKey.toString()} not found in the confirmed messages store`);
-    }
-    return Promise.resolve(message);
-  }
-
-  /**
-   * Gets up to `limit` amount of logs starting from `from`.
-   * @param from - 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(from: number, limit: number, logType: LogType): Promise<L2BlockL2Logs[]> {
-    if (from < INITIAL_L2_BLOCK_NUM || limit < 1) {
-      throw new Error(`Invalid limit: ${limit}`);
-    }
-    const logs = logType === LogType.ENCRYPTED ? this.encryptedLogsPerBlock : this.unencryptedLogsPerBlock;
-    if (from > logs.length) {
-      return Promise.resolve([]);
-    }
-    const startIndex = from - INITIAL_L2_BLOCK_NUM;
-    const endIndex = startIndex + limit;
-    return Promise.resolve(logs.slice(startIndex, endIndex));
-  }
-
-  /**
-   * Gets unencrypted logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   * @remarks Works by doing an intersection of all params in the filter.
-   */
-  getUnencryptedLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
-    let txHash: TxHash | undefined;
-    let fromBlockIndex = 0;
-    let toBlockIndex = this.unencryptedLogsPerBlock.length;
-    let txIndexInBlock = 0;
-    let logIndexInTx = 0;
-
-    if (filter.afterLog) {
-      // Continuation parameter is set --> tx hash is ignored
-      if (filter.fromBlock == undefined || filter.fromBlock <= filter.afterLog.blockNumber) {
-        fromBlockIndex = filter.afterLog.blockNumber - INITIAL_L2_BLOCK_NUM;
-        txIndexInBlock = filter.afterLog.txIndex;
-        logIndexInTx = filter.afterLog.logIndex + 1; // We want to start from the next log
-      } else {
-        fromBlockIndex = filter.fromBlock - INITIAL_L2_BLOCK_NUM;
-      }
-    } else {
-      txHash = filter.txHash;
-
-      if (filter.fromBlock !== undefined) {
-        fromBlockIndex = filter.fromBlock - INITIAL_L2_BLOCK_NUM;
-      }
-    }
-
-    if (filter.toBlock !== undefined) {
-      toBlockIndex = filter.toBlock - INITIAL_L2_BLOCK_NUM;
-    }
-
-    // Ensure the indices are within block array bounds
-    fromBlockIndex = Math.max(fromBlockIndex, 0);
-    toBlockIndex = Math.min(toBlockIndex, this.unencryptedLogsPerBlock.length);
-
-    if (fromBlockIndex > this.unencryptedLogsPerBlock.length || toBlockIndex < fromBlockIndex || toBlockIndex <= 0) {
-      return Promise.resolve({
-        logs: [],
-        maxLogsHit: false,
-      });
-    }
-
-    const contractAddress = filter.contractAddress;
-    const selector = filter.selector;
-
-    const logs: ExtendedUnencryptedL2Log[] = [];
-
-    for (; fromBlockIndex < toBlockIndex; fromBlockIndex++) {
-      const blockContext = this.l2BlockContexts[fromBlockIndex];
-      const blockLogs = this.unencryptedLogsPerBlock[fromBlockIndex];
-      for (; txIndexInBlock < blockLogs.txLogs.length; txIndexInBlock++) {
-        const txLogs = blockLogs.txLogs[txIndexInBlock].unrollLogs().map(log => UnencryptedL2Log.fromBuffer(log));
-        for (; logIndexInTx < txLogs.length; logIndexInTx++) {
-          const log = txLogs[logIndexInTx];
-          if (
-            (!txHash || blockContext.getTxHash(txIndexInBlock).equals(txHash)) &&
-            (!contractAddress || log.contractAddress.equals(contractAddress)) &&
-            (!selector || log.selector.equals(selector))
-          ) {
-            logs.push(
-              new ExtendedUnencryptedL2Log(new LogId(blockContext.block.number, txIndexInBlock, logIndexInTx), log),
-            );
-            if (logs.length === this.maxLogs) {
-              return Promise.resolve({
-                logs,
-                maxLogsHit: true,
-              });
-            }
-          }
-        }
-        logIndexInTx = 0;
-      }
-      txIndexInBlock = 0;
-    }
-
-    return Promise.resolve({
-      logs,
-      maxLogsHit: false,
-    });
-  }
-
-  /**
-   * 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> {
-    const result = this.extendedContractData.get(contractAddress.toString());
-    return Promise.resolve(result);
-  }
-
-  /**
-   * Lookup all contract data in an L2 block.
-   * @param blockNum - The block number to get all contract data from.
-   * @returns All extended contract data in the block (if found).
-   */
-  public getExtendedContractDataInBlock(blockNum: number): Promise<ExtendedContractData[]> {
-    if (blockNum > this.l2BlockContexts.length) {
-      return Promise.resolve([]);
-    }
-    return Promise.resolve(this.extendedContractDataByBlock[blockNum] || []);
-  }
-
-  /**
-   * 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).
-   */
-  public getContractData(contractAddress: AztecAddress): Promise<ContractData | undefined> {
-    if (contractAddress.isZero()) {
-      return Promise.resolve(undefined);
-    }
-    for (const blockContext of this.l2BlockContexts) {
-      for (const contractData of blockContext.block.newContractData) {
-        if (contractData.contractAddress.equals(contractAddress)) {
-          return Promise.resolve(contractData);
-        }
-      }
-    }
-    return Promise.resolve(undefined);
-  }
-
-  /**
-   * Get basic info for an all L2 contracts deployed in a block.
-   * Contains contract address & the ethereum portal address.
-   * @param l2BlockNum - Number of the L2 block where contracts were deployed.
-   * @returns ContractData with the portal address (if we didn't throw an error).
-   */
-  public getContractDataInBlock(l2BlockNum: number): Promise<ContractData[] | undefined> {
-    if (l2BlockNum > this.l2BlockContexts.length) {
-      return Promise.resolve([]);
-    }
-    const block: L2Block | undefined = this.l2BlockContexts[l2BlockNum - INITIAL_L2_BLOCK_NUM]?.block;
-    return Promise.resolve(block?.newContractData);
-  }
-
-  /**
-   * Gets the number of the latest L2 block processed.
-   * @returns The number of the latest L2 block processed.
-   */
-  public getBlockNumber(): Promise<number> {
-    if (this.l2BlockContexts.length === 0) {
-      return Promise.resolve(INITIAL_L2_BLOCK_NUM - 1);
-    }
-    return Promise.resolve(this.l2BlockContexts[this.l2BlockContexts.length - 1].block.number);
-  }
-
-  public getL1BlockNumber(): Promise<bigint> {
-    if (this.l2BlockContexts.length === 0) {
-      return Promise.resolve(0n);
-    }
-    return Promise.resolve(this.l2BlockContexts[this.l2BlockContexts.length - 1].block.getL1BlockNumber());
-  }
-}

package/src/index.ts

@@ -1,53 +0,0 @@
-import { createDebugLogger } from '@aztec/foundation/log';
-import { fileURLToPath } from '@aztec/foundation/url';
-
-import { createPublicClient, http } from 'viem';
-import { localhost } from 'viem/chains';
-
-import { Archiver, getConfigEnvVars } from './archiver/index.js';
-import { MemoryArchiverStore } from './archiver/memory_archiver_store/memory_archiver_store.js';
-
-export * from './archiver/index.js';
-
-const log = createDebugLogger('aztec:archiver');
-
-/**
- * A function which instantiates and starts Archiver.
- */
-// eslint-disable-next-line require-await
-async function main() {
-  const config = getConfigEnvVars();
-  const { rpcUrl, l1Contracts } = config;
-
-  const publicClient = createPublicClient({
-    chain: localhost,
-    transport: http(rpcUrl),
-  });
-
-  const archiverStore = new MemoryArchiverStore(1000);
-
-  const archiver = new Archiver(
-    publicClient,
-    l1Contracts.rollupAddress,
-    l1Contracts.inboxAddress,
-    l1Contracts.registryAddress,
-    l1Contracts.contractDeploymentEmitterAddress,
-    archiverStore,
-  );
-
-  const shutdown = async () => {
-    await archiver.stop();
-    process.exit(0);
-  };
-  process.once('SIGINT', shutdown);
-  process.once('SIGTERM', shutdown);
-}
-
-// See https://twitter.com/Rich_Harris/status/1355289863130673153
-if (process.argv[1] === fileURLToPath(import.meta.url).replace(/\/index\.js$/, '')) {
-  // eslint-disable-next-line @typescript-eslint/no-floating-promises
-  main().catch(err => {
-    log.error(err);
-    process.exit(1);
-  });
-}