@aztec/kv-store 0.0.0-test.0

package/src/stores/l2_tips_store.ts

@@ -0,0 +1,70 @@
+import type {
+  L2BlockId,
+  L2BlockStreamEvent,
+  L2BlockStreamEventHandler,
+  L2BlockStreamLocalDataProvider,
+  L2BlockTag,
+  L2Tips,
+} from '@aztec/stdlib/block';
+
+import type { AztecAsyncMap } from '../interfaces/map.js';
+import type { AztecAsyncKVStore } from '../interfaces/store.js';
+
+/** Stores currently synced L2 tips and unfinalized block hashes. */
+export class L2TipsStore implements L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider {
+  private readonly l2TipsStore: AztecAsyncMap<L2BlockTag, number>;
+  private readonly l2BlockHashesStore: AztecAsyncMap<number, string>;
+
+  constructor(store: AztecAsyncKVStore, namespace: string) {
+    this.l2TipsStore = store.openMap([namespace, 'l2_tips'].join('_'));
+    this.l2BlockHashesStore = store.openMap([namespace, 'l2_block_hashes'].join('_'));
+  }
+
+  public getL2BlockHash(number: number): Promise<string | undefined> {
+    return this.l2BlockHashesStore.getAsync(number);
+  }
+
+  public async getL2Tips(): Promise<L2Tips> {
+    return {
+      latest: await this.getL2Tip('latest'),
+      finalized: await this.getL2Tip('finalized'),
+      proven: await this.getL2Tip('proven'),
+    };
+  }
+
+  private async getL2Tip(tag: L2BlockTag): Promise<L2BlockId> {
+    const blockNumber = await this.l2TipsStore.getAsync(tag);
+    if (blockNumber === undefined || blockNumber === 0) {
+      return { number: 0, hash: undefined };
+    }
+    const blockHash = await this.l2BlockHashesStore.getAsync(blockNumber);
+    if (!blockHash) {
+      throw new Error(`Block hash not found for block number ${blockNumber}`);
+    }
+
+    return { number: blockNumber, hash: blockHash };
+  }
+
+  public async handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
+    switch (event.type) {
+      case 'blocks-added':
+        for (const block of event.blocks) {
+          await this.l2BlockHashesStore.set(block.number, (await block.header.hash()).toString());
+        }
+        await this.l2TipsStore.set('latest', event.blocks.at(-1)!.number);
+        break;
+      case 'chain-pruned':
+        await this.l2TipsStore.set('latest', event.blockNumber);
+        break;
+      case 'chain-proven':
+        await this.l2TipsStore.set('proven', event.blockNumber);
+        break;
+      case 'chain-finalized':
+        await this.l2TipsStore.set('finalized', event.blockNumber);
+        for await (const key of this.l2BlockHashesStore.keysAsync({ end: event.blockNumber })) {
+          await this.l2BlockHashesStore.delete(key);
+        }
+        break;
+    }
+  }
+}

package/src/utils.ts

@@ -0,0 +1,40 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Logger } from '@aztec/foundation/log';
+
+import type { AztecAsyncSingleton, AztecSingleton } from './interfaces/singleton.js';
+import type { AztecAsyncKVStore, AztecKVStore } from './interfaces/store.js';
+import { isSyncStore } from './interfaces/utils.js';
+
+/**
+ * Clears the store if the rollup address does not match the one stored in the database.
+ * This is to prevent data from being accidentally shared between different rollup instances.
+ * @param store - The store to check
+ * @param rollupAddress - The ETH address of the rollup contract
+ * @returns A promise that resolves when the store is cleared, or rejects if the rollup address does not match
+ */
+export async function initStoreForRollup<T extends AztecKVStore | AztecAsyncKVStore>(
+  store: T,
+  rollupAddress: EthAddress,
+  log?: Logger,
+): Promise<T> {
+  if (!rollupAddress) {
+    throw new Error('Rollup address is required');
+  }
+  const rollupAddressValue = store.openSingleton<ReturnType<EthAddress['toString']>>('rollupAddress');
+  const rollupAddressString = rollupAddress.toString();
+  const storedRollupAddressString = isSyncStore(store)
+    ? (rollupAddressValue as AztecSingleton<ReturnType<EthAddress['toString']>>).get()
+    : await (rollupAddressValue as AztecAsyncSingleton<ReturnType<EthAddress['toString']>>).getAsync();
+
+  if (typeof storedRollupAddressString !== 'undefined' && storedRollupAddressString !== rollupAddressString) {
+    log?.warn(`Rollup address mismatch. Clearing entire database...`, {
+      expected: rollupAddressString,
+      found: storedRollupAddressString,
+    });
+
+    await store.clear();
+  }
+
+  await rollupAddressValue.set(rollupAddressString);
+  return store;
+}