@aztec/archiver 0.80.0 → 0.82.0

package/src/archiver/kv_archiver_store/block_store.ts

@@ -1,4 +1,5 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { Signature } from '@aztec/foundation/eth-signature';
 import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncSingleton, Range } from '@aztec/kv-store';
@@ -7,9 +8,9 @@ import { Body, type InBlock, L2Block, L2BlockHash } from '@aztec/stdlib/block';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
 import { BlockHeader, TxEffect, TxHash, TxReceipt } from '@aztec/stdlib/tx';
 
-import type { L1Published, L1PublishedData } from '../structs/published.js';
+import type { L1PublishedData, PublishedL2Block } from '../structs/published.js';
 
-export { type TxEffect, type TxHash, TxReceipt } from '@aztec/stdlib/tx';
+export { TxReceipt, type TxEffect, type TxHash } from '@aztec/stdlib/tx';
 
 type BlockIndexValue = [blockNumber: number, index: number];
 
@@ -17,6 +18,7 @@ type BlockStorage = {
   header: Buffer;
   archive: Buffer;
   l1: L1PublishedData;
+  signatures: Buffer[];
 };
 
 /**
@@ -61,25 +63,26 @@ export class BlockStore {
    * @param blocks - The L2 blocks to be added to the store.
    * @returns True if the operation is successful.
    */
-  async addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
+  async addBlocks(blocks: PublishedL2Block[]): Promise<boolean> {
     if (blocks.length === 0) {
       return true;
     }
 
     return await this.db.transactionAsync(async () => {
       for (const block of blocks) {
-        await this.#blocks.set(block.data.number, {
-          header: block.data.header.toBuffer(),
-          archive: block.data.archive.toBuffer(),
+        await this.#blocks.set(block.block.number, {
+          header: block.block.header.toBuffer(),
+          archive: block.block.archive.toBuffer(),
           l1: block.l1,
+          signatures: block.signatures.map(sig => sig.toBuffer()),
         });
 
-        for (let i = 0; i < block.data.body.txEffects.length; i++) {
-          const txEffect = block.data.body.txEffects[i];
-          await this.#txIndex.set(txEffect.txHash.toString(), [block.data.number, i]);
+        for (let i = 0; i < block.block.body.txEffects.length; i++) {
+          const txEffect = block.block.body.txEffects[i];
+          await this.#txIndex.set(txEffect.txHash.toString(), [block.block.number, i]);
         }
 
-        await this.#blockBodies.set((await block.data.hash()).toString(), block.data.body.toBuffer());
+        await this.#blockBodies.set((await block.block.hash()).toString(), block.block.body.toBuffer());
       }
 
       await this.#lastSynchedL1Block.set(blocks[blocks.length - 1].l1.blockNumber);
@@ -109,9 +112,9 @@ export class BlockStore {
           this.#log.warn(`Cannot remove block ${blockNumber} from the store since we don't have it`);
           continue;
         }
-        await this.#blocks.delete(block.data.number);
-        await Promise.all(block.data.body.txEffects.map(tx => this.#txIndex.delete(tx.txHash.toString())));
-        const blockHash = (await block.data.hash()).toString();
+        await this.#blocks.delete(block.block.number);
+        await Promise.all(block.block.body.txEffects.map(tx => this.#txIndex.delete(tx.txHash.toString())));
+        const blockHash = (await block.block.hash()).toString();
         await this.#blockBodies.delete(blockHash);
         this.#log.debug(`Unwound block ${blockNumber} ${blockHash}`);
       }
@@ -126,10 +129,9 @@ export class BlockStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  async *getBlocks(start: number, limit: number): AsyncIterableIterator<L1Published<L2Block>> {
+  async *getBlocks(start: number, limit: number): AsyncIterableIterator<PublishedL2Block> {
     for await (const blockStorage of this.#blocks.valuesAsync(this.#computeBlockRange(start, limit))) {
-      const block = await this.getBlockFromBlockStorage(blockStorage);
-      yield block;
+      yield await this.getBlockFromBlockStorage(blockStorage);
     }
   }
 
@@ -138,12 +140,11 @@ export class BlockStore {
    * @param blockNumber - The number of the block to return.
    * @returns The requested L2 block.
    */
-  async getBlock(blockNumber: number): Promise<L1Published<L2Block> | undefined> {
+  async getBlock(blockNumber: number): Promise<PublishedL2Block | undefined> {
     const blockStorage = await this.#blocks.getAsync(blockNumber);
     if (!blockStorage || !blockStorage.header) {
       return Promise.resolve(undefined);
     }
-
     return this.getBlockFromBlockStorage(blockStorage);
   }
 
@@ -170,9 +171,9 @@ export class BlockStore {
       );
     }
     const body = Body.fromBuffer(blockBodyBuffer);
-
-    const l2Block = new L2Block(archive, header, body);
-    return { data: l2Block, l1: blockStorage.l1 };
+    const block = new L2Block(archive, header, body);
+    const signatures = blockStorage.signatures.map(Signature.fromBuffer);
+    return { block, l1: blockStorage.l1, signatures };
   }
 
   /**
@@ -192,9 +193,9 @@ export class BlockStore {
     }
 
     return {
-      data: block.data.body.txEffects[txIndex],
-      l2BlockNumber: block.data.number,
-      l2BlockHash: (await block.data.hash()).toString(),
+      data: block.block.body.txEffects[txIndex],
+      l2BlockNumber: block.block.number,
+      l2BlockHash: (await block.block.hash()).toString(),
     };
   }
 
@@ -210,15 +211,15 @@ export class BlockStore {
     }
 
     const block = (await this.getBlock(blockNumber))!;
-    const tx = block.data.body.txEffects[txIndex];
+    const tx = block.block.body.txEffects[txIndex];
 
     return new TxReceipt(
       txHash,
       TxReceipt.statusFromRevertCode(tx.revertCode),
       '',
       tx.transactionFee.toBigInt(),
-      L2BlockHash.fromField(await block.data.hash()),
-      block.data.number,
+      L2BlockHash.fromField(await block.block.hash()),
+      block.block.number,
     );
   }
 

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -4,7 +4,7 @@ import { createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, StoreSize } from '@aztec/kv-store';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { InBlock, L2Block } from '@aztec/stdlib/block';
+import type { L2Block } from '@aztec/stdlib/block';
 import type {
   ContractClassPublic,
   ContractInstanceUpdateWithAddress,
@@ -19,13 +19,12 @@ import type { BlockHeader, TxHash, TxReceipt } from '@aztec/stdlib/tx';
 
 import type { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
 import type { DataRetrieval } from '../structs/data_retrieval.js';
-import type { L1Published } from '../structs/published.js';
+import type { PublishedL2Block } from '../structs/published.js';
 import { BlockStore } from './block_store.js';
 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 { NullifierStore } from './nullifier_store.js';
 
 /**
  * LMDB implementation of the ArchiverDataStore interface.
@@ -35,7 +34,6 @@ export class KVArchiverDataStore implements ArchiverDataStore {
 
   #blockStore: BlockStore;
   #logStore: LogStore;
-  #nullifierStore: NullifierStore;
   #messageStore: MessageStore;
   #contractClassStore: ContractClassStore;
   #contractInstanceStore: ContractInstanceStore;
@@ -49,7 +47,6 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     this.#messageStore = new MessageStore(db);
     this.#contractClassStore = new ContractClassStore(db);
     this.#contractInstanceStore = new ContractInstanceStore(db);
-    this.#nullifierStore = new NullifierStore(db);
   }
 
   // TODO:  These function names are in memory only as they are for development/debugging. They require the full contract
@@ -78,9 +75,8 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return this.#contractClassStore.getContractClassIds();
   }
 
-  async getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    const contract = this.#contractInstanceStore.getContractInstance(address, await this.getSynchedL2BlockNumber());
-    return contract;
+  getContractInstance(address: AztecAddress, blockNumber: number): Promise<ContractInstanceWithAddress | undefined> {
+    return this.#contractInstanceStore.getContractInstance(address, blockNumber);
   }
 
   async addContractClasses(
@@ -148,7 +144,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
    * @returns True if the operation is successful.
    */
-  addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
+  addBlocks(blocks: PublishedL2Block[]): Promise<boolean> {
     return this.#blockStore.addBlocks(blocks);
   }
 
@@ -170,7 +166,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  getBlocks(start: number, limit: number): Promise<L1Published<L2Block>[]> {
+  getBlocks(start: number, limit: number): Promise<PublishedL2Block[]> {
     return toArray(this.#blockStore.getBlocks(start, limit));
   }
 
@@ -216,23 +212,6 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return this.#logStore.deleteLogs(blocks);
   }
 
-  /**
-   * Append new nullifiers to the store's list.
-   * @param blocks - The blocks for which to add the nullifiers.
-   * @returns True if the operation is successful.
-   */
-  addNullifiers(blocks: L2Block[]): Promise<boolean> {
-    return this.#nullifierStore.addNullifiers(blocks);
-  }
-
-  deleteNullifiers(blocks: L2Block[]): Promise<boolean> {
-    return this.#nullifierStore.deleteNullifiers(blocks);
-  }
-
-  findNullifiersIndexesWithBlock(blockNumber: number, nullifiers: Fr[]): Promise<(InBlock<bigint> | undefined)[]> {
-    return this.#nullifierStore.findNullifiersIndexesWithBlock(blockNumber, nullifiers);
-  }
-
   getTotalL1ToL2MessageCount(): Promise<bigint> {
     return this.#messageStore.getTotalL1ToL2MessageCount();
   }

package/src/archiver/kv_archiver_store/log_store.ts

@@ -1,4 +1,4 @@
-import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS } from '@aztec/constants';
+import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
 import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
@@ -40,7 +40,7 @@ export class LogStore {
     this.#logsMaxPageSize = logsMaxPageSize;
   }
 
-  #extractTaggedLogsFromPrivate(block: L2Block) {
+  #extractTaggedLogs(block: L2Block) {
     const taggedLogs = new Map<string, Buffer[]>();
     const dataStartIndexForBlock =
       block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
@@ -48,68 +48,22 @@ export class LogStore {
     block.body.txEffects.forEach((txEffect, txIndex) => {
       const txHash = txEffect.txHash;
       const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
+
       txEffect.privateLogs.forEach(log => {
         const tag = log.fields[0];
+        this.#log.debug(`Found private log with tag ${tag.toString()} in block ${block.number}`);
+
         const currentLogs = taggedLogs.get(tag.toString()) ?? [];
-        currentLogs.push(
-          new TxScopedL2Log(
-            txHash,
-            dataStartIndexForTx,
-            block.number,
-            /* isFromPublic */ false,
-            log.toBuffer(),
-          ).toBuffer(),
-        );
+        currentLogs.push(new TxScopedL2Log(txHash, dataStartIndexForTx, block.number, log).toBuffer());
         taggedLogs.set(tag.toString(), currentLogs);
       });
-    });
-    return taggedLogs;
-  }
 
-  #extractTaggedLogsFromPublic(block: L2Block) {
-    const taggedLogs = new Map<string, Buffer[]>();
-    const dataStartIndexForBlock =
-      block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
-      block.body.txEffects.length * MAX_NOTE_HASHES_PER_TX;
-    block.body.txEffects.forEach((txEffect, txIndex) => {
-      const txHash = txEffect.txHash;
-      const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
       txEffect.publicLogs.forEach(log => {
-        // Check that each log stores 2 lengths in its first field. If not, it's not a tagged log:
-        const firstFieldBuf = log.log[0].toBuffer();
-        // See macros/note/mod/ and see how finalization_log[0] is constructed, to understand this monstrosity. (It wasn't me).
-        // Search the codebase for "disgusting encoding" to see other hardcoded instances of this encoding, that you might need to change if you ever find yourself here.
-        if (!firstFieldBuf.subarray(0, 27).equals(Buffer.alloc(27)) || firstFieldBuf[29] !== 0) {
-          // See parseLogFromPublic - the first field of a tagged log is 5 bytes structured:
-          // [ publicLen[0], publicLen[1], 0, privateLen[0], privateLen[1]]
-          this.#log.warn(`Skipping public log with invalid first field: ${log.log[0]}`);
-          return;
-        }
-        // Check that the length values line up with the log contents
-        const publicValuesLength = firstFieldBuf.subarray(-5).readUint16BE();
-        const privateValuesLength = firstFieldBuf.subarray(-5).readUint16BE(3);
-        // Add 1 for the first field holding lengths
-        const totalLogLength = 1 + publicValuesLength + privateValuesLength;
-        // Note that zeroes can be valid log values, so we can only assert that we do not go over the given length
-        if (totalLogLength > PUBLIC_LOG_DATA_SIZE_IN_FIELDS || log.log.slice(totalLogLength).find(f => !f.isZero())) {
-          this.#log.warn(`Skipping invalid tagged public log with first field: ${log.log[0]}`);
-          return;
-        }
-
-        // The first elt stores lengths as above => tag is in fields[1]
-        const tag = log.log[1];
+        const tag = log.log[0];
+        this.#log.debug(`Found public log with tag ${tag.toString()} in block ${block.number}`);
 
-        this.#log.debug(`Found tagged public log with tag ${tag.toString()} in block ${block.number}`);
         const currentLogs = taggedLogs.get(tag.toString()) ?? [];
-        currentLogs.push(
-          new TxScopedL2Log(
-            txHash,
-            dataStartIndexForTx,
-            block.number,
-            /* isFromPublic */ true,
-            log.toBuffer(),
-          ).toBuffer(),
-        );
+        currentLogs.push(new TxScopedL2Log(txHash, dataStartIndexForTx, block.number, log).toBuffer());
         taggedLogs.set(tag.toString(), currentLogs);
       });
     });
@@ -123,7 +77,7 @@ export class LogStore {
    */
   addLogs(blocks: L2Block[]): Promise<boolean> {
     const taggedLogsToAdd = blocks
-      .flatMap(block => [this.#extractTaggedLogsFromPrivate(block), this.#extractTaggedLogsFromPublic(block)])
+      .map(block => this.#extractTaggedLogs(block))
       .reduce((acc, val) => {
         for (const [tag, logs] of val.entries()) {
           const currentLogs = acc.get(tag) ?? [];
@@ -204,6 +158,7 @@ export class LogStore {
             this.#privateLogsByBlock.delete(block.number),
             this.#publicLogsByBlock.delete(block.number),
             this.#logTagsByBlock.delete(block.number),
+            this.#contractClassLogsByBlock.delete(block.number),
           ]),
         ),
       );
@@ -238,9 +193,7 @@ export class LogStore {
    */
   async getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]> {
     const logs = await Promise.all(tags.map(tag => this.#logsByTag.getAsync(tag.toString())));
-    return logs.map(
-      noteLogBuffers => noteLogBuffers?.map(noteLogBuffer => TxScopedL2Log.fromBuffer(noteLogBuffer)) ?? [],
-    );
+    return logs.map(logBuffers => logBuffers?.map(logBuffer => TxScopedL2Log.fromBuffer(logBuffer)) ?? []);
   }
 
   /**

package/src/archiver/structs/published.ts

@@ -1,11 +1 @@
-/** 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, L1PublishedData } from '@aztec/stdlib/block';

package/src/factory.ts

@@ -2,18 +2,12 @@ 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 { 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 ContractClassPublic, computePublicBytecodeCommitment } 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';
@@ -32,11 +26,12 @@ import { createArchiverClient } from './rpc/index.js';
  * @returns The local archiver.
  */
 export async function createArchiver(
-  config: ArchiverConfig & DataStoreConfig,
+  _config: ArchiverConfig & DataStoreConfig,
   blobSinkClient: BlobSinkClientInterface,
   opts: { blockUntilSync: boolean } = { blockUntilSync: true },
   telemetry: TelemetryClient = getTelemetryClient(),
 ): Promise<ArchiverApi & Service & L2BlockSourceEventEmitter> {
+  const config = { ..._config, dataStoreMapSizeKB: _config.archiverStoreMapSizeKb ?? _config.dataStoreMapSizeKB };
   const store = await createStore(
     'archiver',
     KVArchiverDataStore.SCHEMA_VERSION,
@@ -45,7 +40,6 @@ export async function createArchiver(
   );
   const archiverStore = new KVArchiverDataStore(store, config.maxLogs);
   await registerProtocolContracts(archiverStore);
-  await registerCommonContracts(archiverStore);
   return Archiver.createAndSync(config, archiverStore, { telemetry, blobSinkClient }, opts.blockUntilSync);
 }
 
@@ -86,22 +80,3 @@ async function registerProtocolContracts(store: KVArchiverDataStore) {
     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/test/mock_l2_block_source.ts

@@ -1,4 +1,5 @@
 import { DefaultL1ContractsConfig } from '@aztec/ethereum';
+import { Buffer32 } from '@aztec/foundation/buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { L2Block, L2BlockHash, type L2BlockSource, type L2Tips } from '@aztec/stdlib/block';
@@ -90,6 +91,19 @@ export class MockL2BlockSource implements L2BlockSource {
     );
   }
 
+  public async getPublishedBlocks(from: number, limit: number, proven?: boolean) {
+    const blocks = await this.getBlocks(from, limit, proven);
+    return blocks.map(block => ({
+      block,
+      l1: {
+        blockNumber: BigInt(block.number),
+        blockHash: Buffer32.random().toString(),
+        timestamp: BigInt(block.number),
+      },
+      signatures: [],
+    }));
+  }
+
   getBlockHeader(number: number | 'latest'): Promise<BlockHeader | undefined> {
     return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.header);
   }
@@ -104,6 +118,10 @@ export class MockL2BlockSource implements L2BlockSource {
     return Promise.resolve(blocks);
   }
 
+  getBlockHeadersForEpoch(epochNumber: bigint): Promise<BlockHeader[]> {
+    return this.getBlocksForEpoch(epochNumber).then(blocks => blocks.map(b => b.header));
+  }
+
   /**
    * Gets a tx effect.
    * @param txHash - The hash of a transaction which resulted in the returned tx effect.

package/dest/archiver/kv_archiver_store/nullifier_store.d.ts

@@ -1,12 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import type { InBlock, L2Block } from '@aztec/stdlib/block';
-export declare class NullifierStore {
-    #private;
-    private db;
-    constructor(db: AztecAsyncKVStore);
-    addNullifiers(blocks: L2Block[]): Promise<boolean>;
-    deleteNullifiers(blocks: L2Block[]): Promise<boolean>;
-    findNullifiersIndexesWithBlock(blockNumber: number, nullifiers: Fr[]): Promise<(InBlock<bigint> | undefined)[]>;
-}
-//# sourceMappingURL=nullifier_store.d.ts.map

package/dest/archiver/kv_archiver_store/nullifier_store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nullifier_store.d.ts","sourceRoot":"","sources":["../../../src/archiver/kv_archiver_store/nullifier_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE5D,qBAAa,cAAc;;IAMb,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,iBAAiB;IAMnC,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IA0BlD,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAerD,8BAA8B,CAClC,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,EAAE,EAAE,GACf,OAAO,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC;CAkC5C"}

package/dest/archiver/kv_archiver_store/nullifier_store.js

@@ -1,73 +0,0 @@
-import { MAX_NULLIFIERS_PER_TX } from '@aztec/constants';
-import { createLogger } from '@aztec/foundation/log';
-export class NullifierStore {
-    db;
-    #nullifiersToBlockNumber;
-    #nullifiersToBlockHash;
-    #nullifiersToIndex;
-    #log;
-    constructor(db){
-        this.db = db;
-        this.#log = createLogger('archiver:log_store');
-        this.#nullifiersToBlockNumber = db.openMap('archiver_nullifiers_to_block_number');
-        this.#nullifiersToBlockHash = db.openMap('archiver_nullifiers_to_block_hash');
-        this.#nullifiersToIndex = db.openMap('archiver_nullifiers_to_index');
-    }
-    async addNullifiers(blocks) {
-        const blockHashes = await Promise.all(blocks.map((block)=>block.hash()));
-        await this.db.transactionAsync(async ()=>{
-            await Promise.all(blocks.map((block, i)=>{
-                const dataStartIndexForBlock = block.header.state.partial.nullifierTree.nextAvailableLeafIndex - block.body.txEffects.length * MAX_NULLIFIERS_PER_TX;
-                return Promise.all(block.body.txEffects.map((txEffects, txIndex)=>{
-                    const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NULLIFIERS_PER_TX;
-                    return Promise.all(txEffects.nullifiers.map(async (nullifier, nullifierIndex)=>{
-                        await this.#nullifiersToBlockNumber.set(nullifier.toString(), block.number);
-                        await this.#nullifiersToBlockHash.set(nullifier.toString(), blockHashes[i].toString());
-                        await this.#nullifiersToIndex.set(nullifier.toString(), dataStartIndexForTx + nullifierIndex);
-                    }));
-                }));
-            }));
-        });
-        return true;
-    }
-    async deleteNullifiers(blocks) {
-        await this.db.transactionAsync(async ()=>{
-            for (const block of blocks){
-                for (const nullifier of block.body.txEffects.flatMap((tx)=>tx.nullifiers)){
-                    await Promise.all([
-                        this.#nullifiersToBlockNumber.delete(nullifier.toString()),
-                        this.#nullifiersToBlockHash.delete(nullifier.toString()),
-                        this.#nullifiersToIndex.delete(nullifier.toString())
-                    ]);
-                }
-            }
-        });
-        return true;
-    }
-    async findNullifiersIndexesWithBlock(blockNumber, nullifiers) {
-        const asStrings = nullifiers.map((x)=>x.toString());
-        const maybeNullifiers = await Promise.all(asStrings.map(async (nullifier)=>{
-            const [data, l2BlockNumber, l2BlockHash] = await Promise.all([
-                this.#nullifiersToIndex.getAsync(nullifier),
-                this.#nullifiersToBlockNumber.getAsync(nullifier),
-                this.#nullifiersToBlockHash.getAsync(nullifier)
-            ]);
-            return {
-                data,
-                l2BlockNumber,
-                l2BlockHash
-            };
-        }));
-        return maybeNullifiers.map(({ data, l2BlockNumber, l2BlockHash })=>{
-            if (data === undefined || l2BlockNumber === undefined || l2BlockHash === undefined || l2BlockNumber > blockNumber) {
-                return undefined;
-            } else {
-                return {
-                    data: BigInt(data),
-                    l2BlockNumber,
-                    l2BlockHash
-                };
-            }
-        });
-    }
-}