@aztec/archiver 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/archiver/kv_archiver_store/nullifier_store.ts

@@ -1,97 +0,0 @@
-import { MAX_NULLIFIERS_PER_TX } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import type { InBlock, L2Block } from '@aztec/stdlib/block';
-
-export class NullifierStore {
-  #nullifiersToBlockNumber: AztecAsyncMap<string, number>;
-  #nullifiersToBlockHash: AztecAsyncMap<string, string>;
-  #nullifiersToIndex: AztecAsyncMap<string, number>;
-  #log = createLogger('archiver:log_store');
-
-  constructor(private db: AztecAsyncKVStore) {
-    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: L2Block[]): Promise<boolean> {
-    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: L2Block[]): Promise<boolean> {
-    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: number,
-    nullifiers: Fr[],
-  ): Promise<(InBlock<bigint> | undefined)[]> {
-    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,
-        } as InBlock<bigint>;
-      }
-    });
-  }
-}

package/src/archiver/memory_archiver_store/l1_to_l2_message_store.ts

@@ -1,61 +0,0 @@
-import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/fields';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
-
-/**
- * A simple in-memory implementation of an L1 to L2 message store.
- */
-export class L1ToL2MessageStore {
-  /**
-   * A map pointing from a key in a "messageIndex" format to the corresponding L1 to L2 message hash.
-   */
-  protected store: Map<string, Fr> = new Map();
-
-  #l1ToL2MessagesSubtreeSize = 2 ** L1_TO_L2_MSG_SUBTREE_HEIGHT;
-
-  constructor() {}
-
-  getTotalL1ToL2MessageCount(): bigint {
-    return BigInt(this.store.size);
-  }
-
-  addMessage(message: InboxLeaf) {
-    this.store.set(`${message.index}`, message.leaf);
-  }
-
-  getMessages(blockNumber: bigint): Fr[] {
-    const messages: Fr[] = [];
-    let undefinedMessageFound = false;
-    const startIndex = Number(InboxLeaf.smallestIndexFromL2Block(blockNumber));
-
-    for (let i = startIndex; i < startIndex + this.#l1ToL2MessagesSubtreeSize; i++) {
-      // This is inefficient but probably fine for now.
-      const message = this.store.get(`${i}`);
-      if (message) {
-        if (undefinedMessageFound) {
-          throw new Error(`L1 to L2 message gap found in block ${blockNumber}`);
-        }
-        messages.push(message);
-      } else {
-        undefinedMessageFound = true;
-        // We continue iterating over messages here to verify that there are no more messages after the undefined one.
-        // --> If this was the case this would imply there is some issue with log fetching.
-      }
-    }
-    return messages;
-  }
-
-  /**
-   * Gets the L1 to L2 message index in the L1 to L2 message tree.
-   * @param l1ToL2Message - The L1 to L2 message.
-   * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
-   */
-  getMessageIndex(l1ToL2Message: Fr): bigint | undefined {
-    for (const [key, message] of this.store.entries()) {
-      if (message.equals(l1ToL2Message)) {
-        return BigInt(key);
-      }
-    }
-    return undefined;
-  }
-}