@aztec/archiver 0.8.9 → 0.8.11

package/src/archiver/archiver_store.ts

@@ -3,13 +3,19 @@ import { AztecAddress } from '@aztec/foundation/aztec-address';
 import {
   ContractData,
   ExtendedContractData,
+  ExtendedUnencryptedL2Log,
+  GetUnencryptedLogsResponse,
   INITIAL_L2_BLOCK_NUM,
   L1ToL2Message,
   L2Block,
+  L2BlockContext,
   L2BlockL2Logs,
   L2Tx,
+  LogFilter,
+  LogId,
   LogType,
   TxHash,
+  UnencryptedL2Log,
 } from '@aztec/types';
 
 import { L1ToL2MessageStore, PendingL1ToL2MessageStore } from './l1_to_l2_message_store.js';
@@ -24,7 +30,7 @@ export interface ArchiverDataStore {
    * @param blocks - The L2 blocks to be added to the store.
    * @returns True if the operation is successful.
    */
-  addL2Blocks(blocks: L2Block[]): Promise<boolean>;
+  addBlocks(blocks: L2Block[]): Promise<boolean>;
 
   /**
    * Gets up to `limit` amount of L2 blocks starting from `from`.
@@ -32,7 +38,7 @@ export interface ArchiverDataStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks.
    */
-  getL2Blocks(from: number, limit: number): Promise<L2Block[]>;
+  getBlocks(from: number, limit: number): Promise<L2Block[]>;
 
   /**
    * Gets an l2 tx.
@@ -94,6 +100,13 @@ export interface ArchiverDataStore {
    */
   getLogs(from: number, limit: number, logType: LogType): Promise<L2BlockL2Logs[]>;
 
+  /**
+   * 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>;
+
   /**
    * Add new extended contract data from an L2 block to the store's list.
    * @param data - List of contracts' data to be added.
@@ -137,12 +150,6 @@ export interface ArchiverDataStore {
    * @returns The number of the latest L2 block processed.
    */
   getBlockNumber(): Promise<number>;
-
-  /**
-   * Gets the length of L2 blocks in store.
-   * @returns The length of L2 Blocks stored.
-   */
-  getBlocksLength(): number;
 }
 
 /**
@@ -152,7 +159,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   /**
    * An array containing all the L2 blocks that have been fetched so far.
    */
-  private l2Blocks: L2Block[] = [];
+  private l2BlockContexts: L2BlockContext[] = [];
 
   /**
    * An array containing all the L2 Txs in the L2 blocks that have been fetched so far.
@@ -163,13 +170,13 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * 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 encryptedLogs: L2BlockL2Logs[] = [];
+  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 unencryptedLogs: L2BlockL2Logs[] = [];
+  private unencryptedLogsPerBlock: L2BlockL2Logs[] = [];
 
   /**
    * A sparse array containing all the extended contract data that have been fetched so far.
@@ -192,15 +199,18 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    */
   private pendingL1ToL2Messages: PendingL1ToL2MessageStore = new PendingL1ToL2MessageStore();
 
-  constructor() {}
+  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 addL2Blocks(blocks: L2Block[]): Promise<boolean> {
-    this.l2Blocks.push(...blocks);
+  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);
   }
@@ -212,7 +222,9 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @returns True if the operation is successful.
    */
   addLogs(data: L2BlockL2Logs[], logType: LogType): Promise<boolean> {
-    logType === LogType.ENCRYPTED ? this.encryptedLogs.push(...data) : this.unencryptedLogs.push(...data);
+    logType === LogType.ENCRYPTED
+      ? this.encryptedLogsPerBlock.push(...data)
+      : this.unencryptedLogsPerBlock.push(...data);
     return Promise.resolve(true);
   }
 
@@ -281,18 +293,21 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @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 getL2Blocks(from: number, limit: number): Promise<L2Block[]> {
+  public getBlocks(from: number, limit: number): Promise<L2Block[]> {
     // Return an empty array if we are outside of range
     if (limit < 1) {
-      throw new Error(`Invalid block range from: ${from}, limit: ${limit}`);
+      throw new Error(`Invalid limit: ${limit}`);
     }
-    if (from < INITIAL_L2_BLOCK_NUM || from > this.l2Blocks.length) {
+
+    const fromIndex = Math.max(from - INITIAL_L2_BLOCK_NUM, 0);
+    if (fromIndex >= this.l2BlockContexts.length) {
       return Promise.resolve([]);
     }
-    const startIndex = from - INITIAL_L2_BLOCK_NUM;
-    const endIndex = startIndex + limit;
-    return Promise.resolve(this.l2Blocks.slice(startIndex, endIndex));
+
+    const toIndex = fromIndex + limit;
+    return Promise.resolve(this.l2BlockContexts.slice(fromIndex, toIndex).map(blockContext => blockContext.block));
   }
 
   /**
@@ -336,9 +351,9 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    */
   getLogs(from: number, limit: number, logType: LogType): Promise<L2BlockL2Logs[]> {
     if (from < INITIAL_L2_BLOCK_NUM || limit < 1) {
-      throw new Error(`Invalid block range from: ${from}, limit: ${limit}`);
+      throw new Error(`Invalid limit: ${limit}`);
     }
-    const logs = logType === LogType.ENCRYPTED ? this.encryptedLogs : this.unencryptedLogs;
+    const logs = logType === LogType.ENCRYPTED ? this.encryptedLogsPerBlock : this.unencryptedLogsPerBlock;
     if (from > logs.length) {
       return Promise.resolve([]);
     }
@@ -347,6 +362,90 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     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.
@@ -363,7 +462,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @returns All extended contract data in the block (if found).
    */
   public getExtendedContractDataInBlock(blockNum: number): Promise<ExtendedContractData[]> {
-    if (blockNum > this.l2Blocks.length) {
+    if (blockNum > this.l2BlockContexts.length) {
       return Promise.resolve([]);
     }
     return Promise.resolve(this.extendedContractDataByBlock[blockNum] || []);
@@ -379,8 +478,8 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     if (contractAddress.isZero()) {
       return Promise.resolve(undefined);
     }
-    for (const block of this.l2Blocks) {
-      for (const contractData of block.newContractData) {
+    for (const blockContext of this.l2BlockContexts) {
+      for (const contractData of blockContext.block.newContractData) {
         if (contractData.contractAddress.equals(contractAddress)) {
           return Promise.resolve(contractData);
         }
@@ -396,10 +495,10 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @returns ContractData with the portal address (if we didn't throw an error).
    */
   public getContractDataInBlock(l2BlockNum: number): Promise<ContractData[] | undefined> {
-    if (l2BlockNum > this.l2Blocks.length) {
+    if (l2BlockNum > this.l2BlockContexts.length) {
       return Promise.resolve([]);
     }
-    const block = this.l2Blocks[l2BlockNum];
+    const block = this.l2BlockContexts[l2BlockNum].block;
     return Promise.resolve(block.newContractData);
   }
 
@@ -408,15 +507,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @returns The number of the latest L2 block processed.
    */
   public getBlockNumber(): Promise<number> {
-    if (this.l2Blocks.length === 0) return Promise.resolve(INITIAL_L2_BLOCK_NUM - 1);
-    return Promise.resolve(this.l2Blocks[this.l2Blocks.length - 1].number);
-  }
-
-  /**
-   * Gets the length of L2 blocks in store.
-   * @returns The length of L2 Blocks array.
-   */
-  public getBlocksLength(): number {
-    return this.l2Blocks.length;
+    if (this.l2BlockContexts.length === 0) return Promise.resolve(INITIAL_L2_BLOCK_NUM - 1);
+    return Promise.resolve(this.l2BlockContexts[this.l2BlockContexts.length - 1].block.number);
   }
 }

package/src/archiver/config.ts

@@ -32,11 +32,6 @@ export interface ArchiverConfig {
    */
   viemPollingIntervalMS?: number;
 
-  /**
-   * Eth block from which we start scanning for L2Blocks.
-   */
-  searchStartBlock: number;
-
   /**
    * The deployed L1 contract addresses
    */
@@ -46,6 +41,9 @@ export interface ArchiverConfig {
    * Optional dir to store data. If omitted will store in memory.
    */
   dataDirectory?: string;
+
+  /** The max number of logs that can be obtained in 1 "getUnencryptedLogs" call. */
+  maxLogs?: number;
 }
 
 /**
@@ -60,9 +58,9 @@ export function getConfigEnvVars(): ArchiverConfig {
     ARCHIVER_VIEM_POLLING_INTERVAL_MS,
     ROLLUP_CONTRACT_ADDRESS,
     CONTRACT_DEPLOYMENT_EMITTER_ADDRESS,
-    SEARCH_START_BLOCK,
     API_KEY,
     INBOX_CONTRACT_ADDRESS,
+    OUTBOX_CONTRACT_ADDRESS,
     REGISTRY_CONTRACT_ADDRESS,
     DATA_DIRECTORY,
   } = process.env;
@@ -71,7 +69,7 @@ export function getConfigEnvVars(): ArchiverConfig {
     rollupAddress: ROLLUP_CONTRACT_ADDRESS ? EthAddress.fromString(ROLLUP_CONTRACT_ADDRESS) : EthAddress.ZERO,
     registryAddress: REGISTRY_CONTRACT_ADDRESS ? EthAddress.fromString(REGISTRY_CONTRACT_ADDRESS) : EthAddress.ZERO,
     inboxAddress: INBOX_CONTRACT_ADDRESS ? EthAddress.fromString(INBOX_CONTRACT_ADDRESS) : EthAddress.ZERO,
-    outboxAddress: EthAddress.ZERO,
+    outboxAddress: OUTBOX_CONTRACT_ADDRESS ? EthAddress.fromString(OUTBOX_CONTRACT_ADDRESS) : EthAddress.ZERO,
     contractDeploymentEmitterAddress: CONTRACT_DEPLOYMENT_EMITTER_ADDRESS
       ? EthAddress.fromString(CONTRACT_DEPLOYMENT_EMITTER_ADDRESS)
       : EthAddress.ZERO,
@@ -81,7 +79,6 @@ export function getConfigEnvVars(): ArchiverConfig {
     rpcUrl: ETHEREUM_HOST || 'http://127.0.0.1:8545/',
     archiverPollingIntervalMS: ARCHIVER_POLLING_INTERVAL_MS ? +ARCHIVER_POLLING_INTERVAL_MS : 1_000,
     viemPollingIntervalMS: ARCHIVER_VIEM_POLLING_INTERVAL_MS ? +ARCHIVER_VIEM_POLLING_INTERVAL_MS : 1_000,
-    searchStartBlock: SEARCH_START_BLOCK ? +SEARCH_START_BLOCK : 0,
     apiKey: API_KEY,
     l1Contracts: addresses,
     dataDirectory: DATA_DIRECTORY,

package/src/index.ts

@@ -17,14 +17,14 @@ const log = createDebugLogger('aztec:archiver');
 // eslint-disable-next-line require-await
 async function main() {
   const config = getConfigEnvVars();
-  const { rpcUrl, l1Contracts, searchStartBlock } = config;
+  const { rpcUrl, l1Contracts } = config;
 
   const publicClient = createPublicClient({
     chain: localhost,
     transport: http(rpcUrl),
   });
 
-  const archiverStore = new MemoryArchiverStore();
+  const archiverStore = new MemoryArchiverStore(1000);
 
   const archiver = new Archiver(
     publicClient,
@@ -32,7 +32,7 @@ async function main() {
     l1Contracts.inboxAddress,
     l1Contracts.registryAddress,
     l1Contracts.contractDeploymentEmitterAddress,
-    searchStartBlock,
+    0, // searchStartBlock
     archiverStore,
   );