@aztec/archiver 0.56.0 → 0.57.0

package/src/archiver/kv_archiver_store/contract_instance_store.ts

@@ -19,6 +19,10 @@ export class ContractInstanceStore {
     );
   }
 
+  deleteContractInstance(contractInstance: ContractInstanceWithAddress): Promise<void> {
+    return this.#contractInstances.delete(contractInstance.address.toString());
+  }
+
   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/kv_archiver_store.ts

@@ -1,6 +1,4 @@
 import {
-  type EncryptedL2BlockL2Logs,
-  type EncryptedNoteL2BlockL2Logs,
   type FromLogType,
   type GetUnencryptedLogsResponse,
   type InboxLeaf,
@@ -11,9 +9,8 @@ import {
   type TxEffect,
   type TxHash,
   type TxReceipt,
-  type UnencryptedL2BlockL2Logs,
 } from '@aztec/circuit-types';
-import { type Fr } from '@aztec/circuits.js';
+import { type Fr, type Header } from '@aztec/circuits.js';
 import { type ContractArtifact } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -26,7 +23,7 @@ import {
 } from '@aztec/types/contracts';
 
 import { type ArchiverDataStore, type ArchiverL1SynchPoint } from '../archiver_store.js';
-import { type DataRetrieval, type SingletonDataRetrieval } from '../structs/data_retrieval.js';
+import { type DataRetrieval } from '../structs/data_retrieval.js';
 import { type L1Published } from '../structs/published.js';
 import { BlockStore } from './block_store.js';
 import { ContractArtifactsStore } from './contract_artifacts_store.js';
@@ -34,14 +31,12 @@ import { ContractClassStore } from './contract_class_store.js';
 import { ContractInstanceStore } from './contract_instance_store.js';
 import { LogStore } from './log_store.js';
 import { MessageStore } from './message_store.js';
-import { ProvenStore } from './proven_store.js';
 
 /**
  * LMDB implementation of the ArchiverDataStore interface.
  */
 export class KVArchiverDataStore implements ArchiverDataStore {
   #blockStore: BlockStore;
-  #provenStore: ProvenStore;
   #logStore: LogStore;
   #messageStore: MessageStore;
   #contractClassStore: ContractClassStore;
@@ -52,7 +47,6 @@ export class KVArchiverDataStore implements ArchiverDataStore {
 
   constructor(db: AztecKVStore, logsMaxPageSize: number = 1000) {
     this.#blockStore = new BlockStore(db);
-    this.#provenStore = new ProvenStore(db);
     this.#logStore = new LogStore(db, this.#blockStore, logsMaxPageSize);
     this.#messageStore = new MessageStore(db);
     this.#contractClassStore = new ContractClassStore(db);
@@ -80,8 +74,14 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     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 addContractClasses(data: ContractClassPublic[], blockNumber: number): Promise<boolean> {
+    return (await Promise.all(data.map(c => this.#contractClassStore.addContractClass(c, blockNumber)))).every(Boolean);
+  }
+
+  async deleteContractClasses(data: ContractClassPublic[], blockNumber: number): Promise<boolean> {
+    return (await Promise.all(data.map(c => this.#contractClassStore.deleteContractClasses(c, blockNumber)))).every(
+      Boolean,
+    );
   }
 
   addFunctions(
@@ -96,6 +96,10 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return (await Promise.all(data.map(c => this.#contractInstanceStore.addContractInstance(c)))).every(Boolean);
   }
 
+  async deleteContractInstances(data: ContractInstanceWithAddress[], _blockNumber: number): Promise<boolean> {
+    return (await Promise.all(data.map(c => this.#contractInstanceStore.deleteContractInstance(c)))).every(Boolean);
+  }
+
   /**
    * Append new blocks to the store's list.
    * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
@@ -105,6 +109,17 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return this.#blockStore.addBlocks(blocks);
   }
 
+  /**
+   * Unwinds blocks from the database
+   * @param from -  The tip of the chain, passed for verification purposes,
+   *                ensuring that we don't end up deleting something we did not intend
+   * @param blocksToUnwind - The number of blocks we are to unwind
+   * @returns True if the operation is successful
+   */
+  unwindBlocks(from: number, blocksToUnwind: number): Promise<boolean> {
+    return this.#blockStore.unwindBlocks(from, blocksToUnwind);
+  }
+
   /**
    * Gets up to `limit` amount of L2 blocks starting from `from`.
    *
@@ -121,6 +136,22 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     }
   }
 
+  /**
+   * Gets up to `limit` amount of L2 blocks headers 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
+   */
+  getBlockHeaders(start: number, limit: number): Promise<Header[]> {
+    try {
+      return Promise.resolve(Array.from(this.#blockStore.getBlockHeaders(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 a tx effect.
    * @param txHash - The txHash of the tx corresponding to the tx effect.
@@ -141,18 +172,19 @@ export class KVArchiverDataStore implements ArchiverDataStore {
 
   /**
    * 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.
+   * @param blocks - The blocks for which to add the logs.
    * @returns True if the operation is successful.
    */
-  addLogs(
-    noteEncryptedLogs: EncryptedNoteL2BlockL2Logs | undefined,
-    encryptedLogs: EncryptedL2BlockL2Logs | undefined,
-    unencryptedLogs: UnencryptedL2BlockL2Logs | undefined,
-    blockNumber: number,
-  ): Promise<boolean> {
-    return this.#logStore.addLogs(noteEncryptedLogs, encryptedLogs, unencryptedLogs, blockNumber);
+  addLogs(blocks: L2Block[]): Promise<boolean> {
+    return this.#logStore.addLogs(blocks);
+  }
+
+  deleteLogs(blocks: L2Block[]): Promise<boolean> {
+    return this.#logStore.deleteLogs(blocks);
+  }
+
+  getTotalL1ToL2MessageCount(): Promise<bigint> {
+    return Promise.resolve(this.#messageStore.getTotalL1ToL2MessageCount());
   }
 
   /**
@@ -228,11 +260,21 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   }
 
   getProvenL2BlockNumber(): Promise<number> {
-    return Promise.resolve(this.#provenStore.getProvenL2BlockNumber());
+    return Promise.resolve(this.#blockStore.getProvenL2BlockNumber());
+  }
+
+  getProvenL2EpochNumber(): Promise<number | undefined> {
+    return Promise.resolve(this.#blockStore.getProvenL2EpochNumber());
   }
 
-  async setProvenL2BlockNumber(blockNumber: SingletonDataRetrieval<number>) {
-    await this.#provenStore.setProvenL2BlockNumber(blockNumber);
+  setProvenL2BlockNumber(blockNumber: number) {
+    this.#blockStore.setProvenL2BlockNumber(blockNumber);
+    return Promise.resolve();
+  }
+
+  setProvenL2EpochNumber(epochNumber: number) {
+    this.#blockStore.setProvenL2EpochNumber(epochNumber);
+    return Promise.resolve();
   }
 
   setBlockSynchedL1BlockNumber(l1BlockNumber: bigint) {
@@ -252,7 +294,6 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return Promise.resolve({
       blocksSynchedTo: this.#blockStore.getSynchedL1BlockNumber(),
       messagesSynchedTo: this.#messageStore.getSynchedL1BlockNumber(),
-      provenLogsSynchedTo: this.#provenStore.getSynchedL1BlockNumber(),
     });
   }
 }

package/src/archiver/kv_archiver_store/log_store.ts

@@ -4,6 +4,7 @@ import {
   ExtendedUnencryptedL2Log,
   type FromLogType,
   type GetUnencryptedLogsResponse,
+  type L2Block,
   type L2BlockL2Logs,
   type LogFilter,
   LogId,
@@ -37,29 +38,28 @@ export class LogStore {
 
   /**
    * 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.
+   * @param blocks - The blocks for which to add the logs.
    * @returns True if the operation is successful.
    */
-  addLogs(
-    noteEncryptedLogs: EncryptedNoteL2BlockL2Logs | undefined,
-    encryptedLogs: EncryptedL2BlockL2Logs | undefined,
-    unencryptedLogs: UnencryptedL2BlockL2Logs | undefined,
-    blockNumber: number,
-  ): Promise<boolean> {
+  addLogs(blocks: L2Block[]): Promise<boolean> {
     return this.db.transaction(() => {
-      if (noteEncryptedLogs) {
-        void this.#noteEncryptedLogs.set(blockNumber, noteEncryptedLogs.toBuffer());
-      }
+      blocks.forEach(block => {
+        void this.#noteEncryptedLogs.set(block.number, block.body.noteEncryptedLogs.toBuffer());
+        void this.#encryptedLogs.set(block.number, block.body.encryptedLogs.toBuffer());
+        void this.#unencryptedLogs.set(block.number, block.body.unencryptedLogs.toBuffer());
+      });
 
-      if (encryptedLogs) {
-        void this.#encryptedLogs.set(blockNumber, encryptedLogs.toBuffer());
-      }
+      return true;
+    });
+  }
 
-      if (unencryptedLogs) {
-        void this.#unencryptedLogs.set(blockNumber, unencryptedLogs.toBuffer());
-      }
+  deleteLogs(blocks: L2Block[]): Promise<boolean> {
+    return this.db.transaction(() => {
+      blocks.forEach(block => {
+        void this.#noteEncryptedLogs.delete(block.number);
+        void this.#encryptedLogs.delete(block.number);
+        void this.#unencryptedLogs.delete(block.number);
+      });
 
       return true;
     });

package/src/archiver/kv_archiver_store/message_store.ts

@@ -17,6 +17,7 @@ export class MessageStore {
   #l1ToL2Messages: AztecMap<string, Buffer>;
   #l1ToL2MessageIndices: AztecMap<string, bigint[]>; // We store array of bigints here because there can be duplicate messages
   #lastSynchedL1Block: AztecSingleton<bigint>;
+  #totalMessageCount: AztecSingleton<bigint>;
 
   #log = createDebugLogger('aztec:archiver:message_store');
 
@@ -26,6 +27,11 @@ export class MessageStore {
     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.#totalMessageCount = db.openSingleton('archiver_l1_to_l2_message_count');
+  }
+
+  getTotalL1ToL2MessageCount(): bigint {
+    return this.#totalMessageCount.get() ?? 0n;
   }
 
   /**
@@ -70,6 +76,9 @@ export class MessageStore {
         void this.#l1ToL2MessageIndices.set(message.leaf.toString(), indices);
       }
 
+      const lastTotalMessageCount = this.getTotalL1ToL2MessageCount();
+      void this.#totalMessageCount.set(lastTotalMessageCount + BigInt(messages.retrievedData.length));
+
       return true;
     });
   }

package/src/archiver/memory_archiver_store/l1_to_l2_message_store.ts

@@ -19,6 +19,10 @@ export class L1ToL2MessageStore {
 
   constructor() {}
 
+  getTotalL1ToL2MessageCount(): bigint {
+    return BigInt(this.store.size);
+  }
+
   addMessage(message: InboxLeaf) {
     if (message.index >= this.#l1ToL2MessagesSubtreeSize) {
       throw new Error(`Message index ${message.index} out of subtree range`);

package/src/archiver/memory_archiver_store/memory_archiver_store.ts

@@ -15,18 +15,19 @@ import {
   TxReceipt,
   type UnencryptedL2BlockL2Logs,
 } from '@aztec/circuit-types';
-import { Fr, INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js';
+import { Fr, type Header, INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js';
 import { type ContractArtifact } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import {
   type ContractClassPublic,
+  type ContractClassPublicWithBlockNumber,
   type ContractInstanceWithAddress,
   type ExecutablePrivateFunctionWithMembershipProof,
   type UnconstrainedFunctionWithMembershipProof,
 } from '@aztec/types/contracts';
 
 import { type ArchiverDataStore, type ArchiverL1SynchPoint } from '../archiver_store.js';
-import { type DataRetrieval, type SingletonDataRetrieval } from '../structs/data_retrieval.js';
+import { type DataRetrieval } from '../structs/data_retrieval.js';
 import { type L1Published } from '../structs/published.js';
 import { L1ToL2MessageStore } from './l1_to_l2_message_store.js';
 
@@ -44,23 +45,11 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    */
   private txEffects: TxEffect[] = [];
 
-  /**
-   * 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 noteEncryptedLogsPerBlock: EncryptedNoteL2BlockL2Logs[] = [];
+  private noteEncryptedLogsPerBlock: Map<number, EncryptedNoteL2BlockL2Logs> = new Map();
 
-  /**
-   * 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: EncryptedL2BlockL2Logs[] = [];
+  private encryptedLogsPerBlock: Map<number, EncryptedL2BlockL2Logs> = new Map();
 
-  /**
-   * 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: UnencryptedL2BlockL2Logs[] = [];
+  private unencryptedLogsPerBlock: Map<number, UnencryptedL2BlockL2Logs> = new Map();
 
   /**
    * Contains all L1 to L2 messages.
@@ -69,7 +58,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
   private contractArtifacts: Map<string, ContractArtifact> = new Map();
 
-  private contractClasses: Map<string, ContractClassPublic> = new Map();
+  private contractClasses: Map<string, ContractClassPublicWithBlockNumber> = new Map();
 
   private privateFunctions: Map<string, ExecutablePrivateFunctionWithMembershipProof[]> = new Map();
 
@@ -79,9 +68,9 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
   private lastL1BlockNewBlocks: bigint | undefined = undefined;
   private lastL1BlockNewMessages: bigint | undefined = undefined;
-  private lastL1BlockNewProvenLogs: bigint | undefined = undefined;
 
   private lastProvenL2BlockNumber: number = 0;
+  private lastProvenL2EpochNumber: number = 0;
 
   constructor(
     /** The max number of logs that can be obtained in 1 "getUnencryptedLogs" call. */
@@ -129,9 +118,24 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(true);
   }
 
-  public addContractClasses(data: ContractClassPublic[], _blockNumber: number): Promise<boolean> {
+  public addContractClasses(data: ContractClassPublic[], blockNumber: number): Promise<boolean> {
     for (const contractClass of data) {
-      this.contractClasses.set(contractClass.id.toString(), contractClass);
+      if (!this.contractClasses.has(contractClass.id.toString())) {
+        this.contractClasses.set(contractClass.id.toString(), {
+          ...contractClass,
+          l2BlockNumber: blockNumber,
+        });
+      }
+    }
+    return Promise.resolve(true);
+  }
+
+  public deleteContractClasses(data: ContractClassPublic[], blockNumber: number): Promise<boolean> {
+    for (const contractClass of data) {
+      const restored = this.contractClasses.get(contractClass.id.toString());
+      if (restored && restored.l2BlockNumber >= blockNumber) {
+        this.contractClasses.delete(contractClass.id.toString());
+      }
     }
     return Promise.resolve(true);
   }
@@ -143,6 +147,13 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(true);
   }
 
+  public deleteContractInstances(data: ContractInstanceWithAddress[], _blockNumber: number): Promise<boolean> {
+    for (const contractInstance of data) {
+      this.contractInstances.delete(contractInstance.address.toString());
+    }
+    return Promise.resolve(true);
+  }
+
   /**
    * Append new blocks to the store's list.
    * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
@@ -161,33 +172,58 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   }
 
   /**
-   * 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.
+   * Unwinds blocks from the database
+   * @param from -  The tip of the chain, passed for verification purposes,
+   *                ensuring that we don't end up deleting something we did not intend
+   * @param blocksToUnwind - The number of blocks we are to unwind
+   * @returns True if the operation is successful
    */
-  addLogs(
-    noteEncryptedLogs: EncryptedNoteL2BlockL2Logs,
-    encryptedLogs: EncryptedL2BlockL2Logs,
-    unencryptedLogs: UnencryptedL2BlockL2Logs,
-    blockNumber: number,
-  ): Promise<boolean> {
-    if (noteEncryptedLogs) {
-      this.noteEncryptedLogsPerBlock[blockNumber - INITIAL_L2_BLOCK_NUM] = noteEncryptedLogs;
+  public async unwindBlocks(from: number, blocksToUnwind: number): Promise<boolean> {
+    const last = await this.getSynchedL2BlockNumber();
+    if (from != last) {
+      throw new Error(`Can only remove the tip`);
     }
 
-    if (encryptedLogs) {
-      this.encryptedLogsPerBlock[blockNumber - INITIAL_L2_BLOCK_NUM] = encryptedLogs;
+    const stopAt = from - blocksToUnwind;
+    while ((await this.getSynchedL2BlockNumber()) > stopAt) {
+      const block = this.l2Blocks.pop();
+      if (block == undefined) {
+        break;
+      }
+      block.data.body.txEffects.forEach(() => this.txEffects.pop());
     }
 
-    if (unencryptedLogs) {
-      this.unencryptedLogsPerBlock[blockNumber - INITIAL_L2_BLOCK_NUM] = unencryptedLogs;
-    }
+    return Promise.resolve(true);
+  }
+
+  /**
+   * Append new logs to the store's list.
+   * @param block - The block for which to add the logs.
+   * @returns True if the operation is successful.
+   */
+  addLogs(blocks: L2Block[]): Promise<boolean> {
+    blocks.forEach(block => {
+      this.noteEncryptedLogsPerBlock.set(block.number, block.body.noteEncryptedLogs);
+      this.encryptedLogsPerBlock.set(block.number, block.body.encryptedLogs);
+      this.unencryptedLogsPerBlock.set(block.number, block.body.unencryptedLogs);
+    });
+    return Promise.resolve(true);
+  }
+
+  deleteLogs(blocks: L2Block[]): Promise<boolean> {
+    blocks.forEach(block => {
+      this.encryptedLogsPerBlock.delete(block.number);
+      this.noteEncryptedLogsPerBlock.delete(block.number);
+      this.unencryptedLogsPerBlock.delete(block.number);
+    });
 
     return Promise.resolve(true);
   }
 
+  getTotalL1ToL2MessageCount(): Promise<bigint> {
+    return Promise.resolve(this.l1ToL2Messages.getTotalL1ToL2MessageCount());
+  }
+
   /**
    * 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.
@@ -226,12 +262,15 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @remarks When "from" is smaller than genesis block number, blocks from the beginning are returned.
    */
   public getBlocks(from: number, limit: number): Promise<L1Published<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 (from < INITIAL_L2_BLOCK_NUM) {
+      return Promise.reject(new Error(`Invalid start: ${from}`));
+    }
+
+    const fromIndex = from - INITIAL_L2_BLOCK_NUM;
     if (fromIndex >= this.l2Blocks.length) {
       return Promise.resolve([]);
     }
@@ -240,6 +279,11 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(this.l2Blocks.slice(fromIndex, toIndex));
   }
 
+  public async getBlockHeaders(from: number, limit: number): Promise<Header[]> {
+    const blocks = await this.getBlocks(from, limit);
+    return blocks.map(block => block.data.header);
+  }
+
   /**
    * Gets a tx effect.
    * @param txHash - The txHash of the tx effect.
@@ -297,9 +341,14 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     logType: TLogType,
   ): Promise<L2BlockL2Logs<FromLogType<TLogType>>[]> {
     if (from < INITIAL_L2_BLOCK_NUM || limit < 1) {
-      throw new Error(`Invalid limit: ${limit}`);
+      return Promise.resolve([]);
     }
-    const logs = (() => {
+
+    if (from > this.l2Blocks.length) {
+      return Promise.resolve([]);
+    }
+
+    const logMap = (() => {
       switch (logType) {
         case LogType.ENCRYPTED:
           return this.encryptedLogsPerBlock;
@@ -309,14 +358,24 @@ export class MemoryArchiverStore implements ArchiverDataStore {
         default:
           return this.unencryptedLogsPerBlock;
       }
-    })() as L2BlockL2Logs<FromLogType<TLogType>>[];
+    })() as Map<number, L2BlockL2Logs<FromLogType<TLogType>>>;
 
-    if (from > logs.length) {
-      return Promise.resolve([]);
-    }
-    const startIndex = from - INITIAL_L2_BLOCK_NUM;
+    const startIndex = from;
     const endIndex = startIndex + limit;
-    return Promise.resolve(logs.slice(startIndex, endIndex));
+    const upper = Math.min(endIndex, this.l2Blocks.length + INITIAL_L2_BLOCK_NUM);
+
+    const l = [];
+    for (let i = startIndex; i < upper; i++) {
+      const log = logMap.get(i);
+      if (log) {
+        l.push(log);
+      } else {
+        // I hate typescript sometimes
+        l.push(undefined as unknown as L2BlockL2Logs<FromLogType<TLogType>>);
+      }
+    }
+
+    return Promise.resolve(l);
   }
 
   /**
@@ -327,37 +386,37 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    */
   getUnencryptedLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
     let txHash: TxHash | undefined;
-    let fromBlockIndex = 0;
-    let toBlockIndex = this.unencryptedLogsPerBlock.length;
+    let fromBlock = 0;
+    let toBlock = this.l2Blocks.length + INITIAL_L2_BLOCK_NUM;
     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;
+        fromBlock = filter.afterLog.blockNumber;
         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;
+        fromBlock = filter.fromBlock;
       }
     } else {
       txHash = filter.txHash;
 
       if (filter.fromBlock !== undefined) {
-        fromBlockIndex = filter.fromBlock - INITIAL_L2_BLOCK_NUM;
+        fromBlock = filter.fromBlock;
       }
     }
 
     if (filter.toBlock !== undefined) {
-      toBlockIndex = filter.toBlock - INITIAL_L2_BLOCK_NUM;
+      toBlock = filter.toBlock;
     }
 
     // Ensure the indices are within block array bounds
-    fromBlockIndex = Math.max(fromBlockIndex, 0);
-    toBlockIndex = Math.min(toBlockIndex, this.unencryptedLogsPerBlock.length);
+    fromBlock = Math.max(fromBlock, INITIAL_L2_BLOCK_NUM);
+    toBlock = Math.min(toBlock, this.l2Blocks.length + INITIAL_L2_BLOCK_NUM);
 
-    if (fromBlockIndex > this.unencryptedLogsPerBlock.length || toBlockIndex < fromBlockIndex || toBlockIndex <= 0) {
+    if (fromBlock > this.l2Blocks.length || toBlock < fromBlock || toBlock <= 0) {
       return Promise.resolve({
         logs: [],
         maxLogsHit: false,
@@ -368,27 +427,30 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
     const logs: ExtendedUnencryptedL2Log[] = [];
 
-    for (; fromBlockIndex < toBlockIndex; fromBlockIndex++) {
-      const block = this.l2Blocks[fromBlockIndex];
-      const blockLogs = this.unencryptedLogsPerBlock[fromBlockIndex];
-      for (; txIndexInBlock < blockLogs.txLogs.length; txIndexInBlock++) {
-        const txLogs = blockLogs.txLogs[txIndexInBlock].unrollLogs();
-        for (; logIndexInTx < txLogs.length; logIndexInTx++) {
-          const log = txLogs[logIndexInTx];
-          if (
-            (!txHash || block.data.body.txEffects[txIndexInBlock].txHash.equals(txHash)) &&
-            (!contractAddress || log.contractAddress.equals(contractAddress))
-          ) {
-            logs.push(new ExtendedUnencryptedL2Log(new LogId(block.data.number, txIndexInBlock, logIndexInTx), log));
-            if (logs.length === this.maxLogs) {
-              return Promise.resolve({
-                logs,
-                maxLogsHit: true,
-              });
+    for (; fromBlock < toBlock; fromBlock++) {
+      const block = this.l2Blocks[fromBlock - INITIAL_L2_BLOCK_NUM];
+      const blockLogs = this.unencryptedLogsPerBlock.get(fromBlock);
+
+      if (blockLogs) {
+        for (; txIndexInBlock < blockLogs.txLogs.length; txIndexInBlock++) {
+          const txLogs = blockLogs.txLogs[txIndexInBlock].unrollLogs();
+          for (; logIndexInTx < txLogs.length; logIndexInTx++) {
+            const log = txLogs[logIndexInTx];
+            if (
+              (!txHash || block.data.body.txEffects[txIndexInBlock].txHash.equals(txHash)) &&
+              (!contractAddress || log.contractAddress.equals(contractAddress))
+            ) {
+              logs.push(new ExtendedUnencryptedL2Log(new LogId(block.data.number, txIndexInBlock, logIndexInTx), log));
+              if (logs.length === this.maxLogs) {
+                return Promise.resolve({
+                  logs,
+                  maxLogsHit: true,
+                });
+              }
             }
           }
+          logIndexInTx = 0;
         }
-        logIndexInTx = 0;
       }
       txIndexInBlock = 0;
     }
@@ -414,9 +476,17 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(this.lastProvenL2BlockNumber);
   }
 
-  public setProvenL2BlockNumber(l2BlockNumber: SingletonDataRetrieval<number>): Promise<void> {
-    this.lastProvenL2BlockNumber = l2BlockNumber.retrievedData;
-    this.lastL1BlockNewProvenLogs = l2BlockNumber.lastProcessedL1BlockNumber;
+  public getProvenL2EpochNumber(): Promise<number | undefined> {
+    return Promise.resolve(this.lastProvenL2EpochNumber);
+  }
+
+  public setProvenL2BlockNumber(l2BlockNumber: number): Promise<void> {
+    this.lastProvenL2BlockNumber = l2BlockNumber;
+    return Promise.resolve();
+  }
+
+  public setProvenL2EpochNumber(l2EpochNumber: number): Promise<void> {
+    this.lastProvenL2EpochNumber = l2EpochNumber;
     return Promise.resolve();
   }
 
@@ -434,7 +504,6 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve({
       blocksSynchedTo: this.lastL1BlockNewBlocks,
       messagesSynchedTo: this.lastL1BlockNewMessages,
-      provenLogsSynchedTo: this.lastL1BlockNewProvenLogs,
     });
   }