@aztec/kv-store 0.0.1-commit.b655e406 → 0.0.1-commit.b9865e97

package/dest/stores/l2_tips_store.js

@@ -1,7 +1,16 @@
-/** Stores currently synced L2 tips and unfinalized block hashes. */ export class L2TipsKVStore {
+import { L2TipsStoreBase } from '@aztec/stdlib/block';
+import { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+/**
+ * Persistent implementation of L2 tips store backed by a KV store.
+ * Used by nodes that need to persist chain state across restarts.
+ */ export class L2TipsKVStore extends L2TipsStoreBase {
+    store;
     l2TipsStore;
     l2BlockHashesStore;
-    constructor(store, namespace){
+    l2BlockNumberToCheckpointNumberStore;
+    l2CheckpointStore;
+    constructor(store, namespace, initialBlockHash){
+        super(initialBlockHash), this.store = store;
         this.l2TipsStore = store.openMap([
             namespace,
             'l2_tips'
@@ -10,65 +19,65 @@
             namespace,
             'l2_block_hashes'
         ].join('_'));
+        this.l2BlockNumberToCheckpointNumberStore = store.openMap([
+            namespace,
+            'l2_block_number_to_checkpoint_number'
+        ].join('_'));
+        this.l2CheckpointStore = store.openMap([
+            namespace,
+            'l2_checkpoint_store'
+        ].join('_'));
+    }
+    getTip(tag) {
+        return this.l2TipsStore.getAsync(tag);
+    }
+    setTip(tag, blockNumber) {
+        return this.l2TipsStore.set(tag, blockNumber);
     }
-    getL2BlockHash(number) {
-        return this.l2BlockHashesStore.getAsync(number);
+    getStoredBlockHash(blockNumber) {
+        return this.l2BlockHashesStore.getAsync(blockNumber);
     }
-    async getL2Tips() {
-        return {
-            latest: await this.getL2Tip('latest'),
-            finalized: await this.getL2Tip('finalized'),
-            proven: await this.getL2Tip('proven')
-        };
+    setBlockHash(blockNumber, hash) {
+        return this.l2BlockHashesStore.set(blockNumber, hash);
     }
-    async getL2Tip(tag) {
-        const blockNumber = await this.l2TipsStore.getAsync(tag);
-        if (blockNumber === undefined || blockNumber === 0) {
-            return {
-                number: 0,
-                hash: undefined
-            };
+    async deleteBlockHashesBefore(blockNumber) {
+        for await (const key of this.l2BlockHashesStore.keysAsync({
+            end: blockNumber
+        })){
+            await this.l2BlockHashesStore.delete(key);
         }
-        const blockHash = await this.l2BlockHashesStore.getAsync(blockNumber);
-        if (!blockHash) {
-            throw new Error(`Block hash not found for block number ${blockNumber}`);
+    }
+    getCheckpointNumberForBlock(blockNumber) {
+        return this.l2BlockNumberToCheckpointNumberStore.getAsync(blockNumber);
+    }
+    setCheckpointNumberForBlock(blockNumber, checkpointNumber) {
+        return this.l2BlockNumberToCheckpointNumberStore.set(blockNumber, checkpointNumber);
+    }
+    async deleteBlockToCheckpointBefore(blockNumber) {
+        for await (const key of this.l2BlockNumberToCheckpointNumberStore.keysAsync({
+            end: blockNumber
+        })){
+            await this.l2BlockNumberToCheckpointNumberStore.delete(key);
         }
-        return {
-            number: blockNumber,
-            hash: blockHash
-        };
     }
-    async handleBlockStreamEvent(event) {
-        switch(event.type){
-            case 'blocks-added':
-                {
-                    const blocks = event.blocks.map((b)=>b.block);
-                    for (const block of blocks){
-                        await this.l2BlockHashesStore.set(block.number, (await block.hash()).toString());
-                    }
-                    await this.l2TipsStore.set('latest', blocks.at(-1).number);
-                    break;
-                }
-            case 'chain-pruned':
-                await this.saveTag('latest', event.block);
-                break;
-            case 'chain-proven':
-                await this.saveTag('proven', event.block);
-                break;
-            case 'chain-finalized':
-                await this.saveTag('finalized', event.block);
-                for await (const key of this.l2BlockHashesStore.keysAsync({
-                    end: event.block.number
-                })){
-                    await this.l2BlockHashesStore.delete(key);
-                }
-                break;
+    async getCheckpoint(checkpointNumber) {
+        const buffer = await this.l2CheckpointStore.getAsync(checkpointNumber);
+        if (!buffer) {
+            return undefined;
         }
+        return PublishedCheckpoint.fromBuffer(buffer);
     }
-    async saveTag(name, block) {
-        await this.l2TipsStore.set(name, block.number);
-        if (block.hash) {
-            await this.l2BlockHashesStore.set(block.number, block.hash);
+    saveCheckpointData(checkpoint) {
+        return this.l2CheckpointStore.set(checkpoint.checkpoint.number, checkpoint.toBuffer());
+    }
+    async deleteCheckpointsBefore(checkpointNumber) {
+        for await (const key of this.l2CheckpointStore.keysAsync({
+            end: checkpointNumber
+        })){
+            await this.l2CheckpointStore.delete(key);
         }
     }
+    runInTransaction(fn) {
+        return this.store.transactionAsync(fn);
+    }
 }

package/dest/utils.d.ts

@@ -1,12 +1,15 @@
-import type { EthAddress } from '@aztec/foundation/eth-address';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Logger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, AztecKVStore } from './interfaces/store.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.
+ * Clears the store if the schema version or rollup address does not match the one stored in the database.
+ * Also clears if migrating from an older store format that didn't track schema version.
+ * This is to prevent data from being accidentally mixed up between different rollup instances or schema versions.
  * @param store - The store to check
+ * @param targetSchemaVersion - The current schema version
  * @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
+ * @param log - Optional logger
+ * @returns The store (cleared if necessary)
  */
-export declare function initStoreForRollup<T extends AztecKVStore | AztecAsyncKVStore>(store: T, rollupAddress: EthAddress, log?: Logger): Promise<T>;
-//# sourceMappingURL=utils.d.ts.map
+export declare function initStoreForRollupAndSchemaVersion<T extends AztecKVStore | AztecAsyncKVStore>(store: T, schemaVersion: number | undefined, rollupAddress: EthAddress | undefined, log?: Logger): Promise<T>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDM0QsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFJcEQsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsWUFBWSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFHN0U7Ozs7Ozs7OztHQVNHO0FBQ0gsd0JBQXNCLGtDQUFrQyxDQUFDLENBQUMsU0FBUyxZQUFZLEdBQUcsaUJBQWlCLEVBQ2pHLEtBQUssRUFBRSxDQUFDLEVBQ1IsYUFBYSxFQUFFLE1BQU0sR0FBRyxTQUFTLEVBQ2pDLGFBQWEsRUFBRSxVQUFVLEdBQUcsU0FBUyxFQUNyQyxHQUFHLENBQUMsRUFBRSxNQUFNLEdBQ1gsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQXFDWiJ9

package/dest/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAGpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG7E;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CAAC,CAAC,SAAS,YAAY,GAAG,iBAAiB,EACjF,KAAK,EAAE,CAAC,EACR,aAAa,EAAE,UAAU,EACzB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,CAAC,CAAC,CAqBZ"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAIpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG7E;;;;;;;;;GASG;AACH,wBAAsB,kCAAkC,CAAC,CAAC,SAAS,YAAY,GAAG,iBAAiB,EACjG,KAAK,EAAE,CAAC,EACR,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,aAAa,EAAE,UAAU,GAAG,SAAS,EACrC,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,CAAC,CAAC,CAqCZ"}

package/dest/utils.js

@@ -1,24 +1,59 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { DatabaseVersion } from '@aztec/stdlib/database-version/version';
 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.
+ * Clears the store if the schema version or rollup address does not match the one stored in the database.
+ * Also clears if migrating from an older store format that didn't track schema version.
+ * This is to prevent data from being accidentally mixed up between different rollup instances or schema versions.
  * @param store - The store to check
+ * @param targetSchemaVersion - The current schema version
  * @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(store, rollupAddress, log) {
-    if (!rollupAddress) {
-        throw new Error('Rollup address is required');
-    }
-    const rollupAddressValue = store.openSingleton('rollupAddress');
-    const rollupAddressString = rollupAddress.toString();
-    const storedRollupAddressString = isSyncStore(store) ? rollupAddressValue.get() : await rollupAddressValue.getAsync();
-    if (typeof storedRollupAddressString !== 'undefined' && storedRollupAddressString !== rollupAddressString) {
-        log?.warn(`Rollup address mismatch. Clearing entire database...`, {
-            expected: rollupAddressString,
-            found: storedRollupAddressString
-        });
+ * @param log - Optional logger
+ * @returns The store (cleared if necessary)
+ */ export async function initStoreForRollupAndSchemaVersion(store, schemaVersion, rollupAddress, log) {
+    const targetSchemaVersion = schemaVersion ?? 0;
+    const targetRollupAddress = rollupAddress ?? EthAddress.ZERO;
+    const targetDatabaseVersion = new DatabaseVersion(targetSchemaVersion, targetRollupAddress);
+    // DB version: database schema version + rollup address combined)
+    const dbVersion = store.openSingleton('dbVersion');
+    const storedDatabaseVersion = isSyncStore(store) ? dbVersion.get() : await dbVersion.getAsync();
+    // Check if this is an old format store (has rollupAddress singleton but no dbVersion)
+    const oldRollupSingleton = store.openSingleton('rollupAddress');
+    const hasOldFormat = isSyncStore(store) ? !storedDatabaseVersion && !!oldRollupSingleton.get() : !storedDatabaseVersion && !!await oldRollupSingleton.getAsync();
+    if (hasOldFormat || doesStoreNeedToBeCleared(targetDatabaseVersion, storedDatabaseVersion, targetSchemaVersion, targetRollupAddress, log)) {
+        if (hasOldFormat) {
+            log?.warn('Detected old store format without dbVersion, clearing database');
+        }
         await store.clear();
     }
-    await rollupAddressValue.set(rollupAddressString);
+    await dbVersion.set(targetDatabaseVersion.toBuffer().toString('utf-8'));
     return store;
 }
+function doesStoreNeedToBeCleared(targetDatabaseVersion, storedDatabaseVersion, targetSchemaVersion, targetRollupAddress, log) {
+    if (storedDatabaseVersion) {
+        try {
+            const storedVersion = DatabaseVersion.fromBuffer(Buffer.from(storedDatabaseVersion, 'utf-8'));
+            const cmp = storedVersion.cmp(targetDatabaseVersion);
+            if (cmp === undefined) {
+                log?.warn('Rollup address changed, clearing database', {
+                    stored: storedVersion.rollupAddress.toString(),
+                    current: targetRollupAddress.toString()
+                });
+                return true;
+            }
+            if (cmp !== 0) {
+                log?.warn('Schema version changed, clearing database', {
+                    stored: storedVersion.schemaVersion,
+                    current: targetSchemaVersion
+                });
+                return true;
+            }
+        } catch (err) {
+            log?.warn('Failed to parse stored version, clearing database', {
+                err
+            });
+            return true;
+        }
+    }
+    return false;
+}

package/package.json

@@ -1,22 +1,34 @@
 {
   "name": "@aztec/kv-store",
-  "version": "0.0.1-commit.b655e406",
+  "version": "0.0.1-commit.b9865e97",
   "type": "module",
   "exports": {
     ".": "./dest/interfaces/index.js",
+    "./interfaces": "./dest/interfaces/index.js",
     "./lmdb": "./dest/lmdb/index.js",
     "./lmdb-v2": "./dest/lmdb-v2/index.js",
     "./indexeddb": "./dest/indexeddb/index.js",
-    "./stores": "./dest/stores/index.js",
-    "./config": "./dest/config.js"
+    "./sqlite-opfs": "./dest/sqlite-opfs/index.js",
+    "./stores": "./dest/stores/index.js"
+  },
+  "imports": {
+    "#msgpackr": {
+      "browser": "msgpackr/index-no-eval",
+      "default": "msgpackr"
+    },
+    "#ordered-binary": {
+      "browser": "./dest/sqlite-opfs/internal/ordered-binary-browser.js",
+      "default": "ordered-binary"
+    }
   },
   "scripts": {
-    "build": "yarn clean && tsc -b",
-    "build:dev": "tsc -b --watch",
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
-    "test:node": "NODE_NO_WARNINGS=1 mocha --config ./.mocharc.json",
-    "test:browser": "wtr --config ./web-test-runner.config.mjs",
-    "test": "yarn test:node",
+    "test:node": "vitest run --project node",
+    "test:browser": "bash scripts/run-browser-tests.sh",
+    "bench:browser": "VITE_BENCH=1 vitest run --project browser src/bench",
+    "test": "vitest run",
     "test:jest": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
   "inherits": [
@@ -24,10 +36,12 @@
     "./package.local.json"
   ],
   "dependencies": {
-    "@aztec/ethereum": "0.0.1-commit.b655e406",
-    "@aztec/foundation": "0.0.1-commit.b655e406",
-    "@aztec/native": "0.0.1-commit.b655e406",
-    "@aztec/stdlib": "0.0.1-commit.b655e406",
+    "@aztec/constants": "0.0.1-commit.b9865e97",
+    "@aztec/ethereum": "0.0.1-commit.b9865e97",
+    "@aztec/foundation": "0.0.1-commit.b9865e97",
+    "@aztec/native": "0.0.1-commit.b9865e97",
+    "@aztec/sqlite3mc-wasm": "0.0.1-commit.b9865e97",
+    "@aztec/stdlib": "0.0.1-commit.b9865e97",
     "idb": "^8.0.0",
     "lmdb": "^3.2.0",
     "msgpackr": "^1.11.2",
@@ -36,24 +50,17 @@
   },
   "devDependencies": {
     "@jest/globals": "^30.0.0",
-    "@types/chai": "^5.0.1",
-    "@types/chai-as-promised": "^8.0.1",
     "@types/jest": "^30.0.0",
-    "@types/mocha": "^10.0.10",
-    "@types/mocha-each": "^2.0.4",
     "@types/node": "^22.15.17",
-    "@types/sinon": "^17.0.3",
-    "@web/dev-server-esbuild": "^1.0.3",
-    "@web/test-runner": "^0.19.0",
-    "@web/test-runner-playwright": "^0.11.0",
-    "chai": "^5.1.2",
-    "chai-as-promised": "^8.0.1",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "@vitest/browser-playwright": "^4.0.0",
+    "buffer": "^6.0.3",
     "jest": "^30.0.0",
-    "mocha": "^10.8.2",
-    "mocha-each": "^2.0.1",
-    "sinon": "^19.0.2",
+    "playwright": "1.49.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "util": "^0.12.5",
+    "vitest": "^4.0.0"
   },
   "files": [
     "dest",

package/src/bench/shared_map_bench.ts

@@ -0,0 +1,111 @@
+import type { Logger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+
+import type { Key } from '../interfaces/common.js';
+import type { AztecAsyncMap } from '../interfaces/map.js';
+import type { AztecAsyncKVStore } from '../interfaces/store.js';
+
+/** One benchmark measurement. */
+export type BenchResult = {
+  /** Benchmark name (includes the backend prefix for disambiguation). */
+  name: string;
+  value: number;
+  unit: 'ms' | 'us';
+};
+
+export type BenchReporter = (results: BenchResult[]) => void | Promise<void>;
+
+/**
+ * Runs the standard Map benchmark suite against any `AztecAsyncKVStore` backend,
+ * populates `results`, and calls `reporter` in `afterAll`.
+ *
+ * Kept free of Node-only deps (`fs`, `path`) so the same runner works under
+ * vitest-browser for IndexedDB and SQLite-OPFS.
+ */
+export function describeAztecMapBench(
+  backendPrefix: string,
+  getStore: () => Promise<AztecAsyncKVStore>,
+  logger: Logger,
+  reporter: BenchReporter,
+) {
+  describe(`${backendPrefix} Map benchmarks`, () => {
+    let store: AztecAsyncKVStore;
+    let map: AztecAsyncMap<Key, string>;
+
+    const results: BenchResult[] = [];
+
+    const generateKeyValuePairs = (count: number, offset = 0) => {
+      const keys = Array.from({ length: count }, (_, i) => `key-${i + offset}`);
+      const values = Array.from({ length: count }, (_, i) => `value-${i + offset}`);
+      return keys.map((key, i) => ({ key, value: values[i] }));
+    };
+
+    const record = (name: string, value: number, unit: BenchResult['unit']) => {
+      results.push({ name: `${backendPrefix}/Map/${name}`, value, unit });
+    };
+
+    beforeEach(async () => {
+      store = await getStore();
+      map = store.openMap<Key, string>('test');
+    });
+
+    afterEach(async () => {
+      await store.delete();
+    });
+
+    afterAll(async () => {
+      const pretty = results.map(r => `${r.name}: ${r.value.toFixed(2)} ${r.unit}`).join('\n');
+      logger.info(`\n${pretty}\n`);
+      await reporter(results);
+    });
+
+    it('adds individual values', async () => {
+      const pairs = generateKeyValuePairs(1000);
+      const timer = new Timer();
+      for (const pair of pairs) {
+        await map.set(pair.key, pair.value);
+      }
+      record('Individual insertion', timer.ms() / pairs.length, 'ms');
+    });
+
+    it('adds batched values', async () => {
+      const batches = Array.from({ length: 100 }, (_, i) => generateKeyValuePairs(1000, i * 1000));
+      const timer = new Timer();
+      for (const batch of batches) {
+        await map.setMany(batch);
+      }
+      record(`Batch insertion of ${batches[0].length} items`, timer.ms() / batches.length, 'ms');
+    });
+
+    it('reads individual values', async () => {
+      const pairs = generateKeyValuePairs(10000);
+      await map.setMany(pairs);
+      const timer = new Timer();
+      for (const pair of pairs) {
+        await map.getAsync(pair.key);
+      }
+      record('Individual read', (timer.ms() * 1000) / pairs.length, 'us');
+    });
+
+    it('reads via a cursor', async () => {
+      const pairs = generateKeyValuePairs(10000);
+      await map.setMany(pairs);
+      const timer = new Timer();
+      for await (const _ of map.entriesAsync()) {
+        // consume
+      }
+      record(`Iterator per item read of ${pairs.length} items`, (timer.ms() * 1000) / pairs.length, 'us');
+    });
+
+    it('reads the size of the map', async () => {
+      const numIterations = 1000;
+      const pairs = generateKeyValuePairs(10000);
+      await map.setMany(pairs);
+      const timer = new Timer();
+      for (let i = 0; i < numIterations; i++) {
+        await map.sizeAsync();
+      }
+      record(`Read size of ${pairs.length} items`, (timer.ms() * 1000) / numIterations, 'us');
+    });
+  });
+}

package/src/indexeddb/array.ts

@@ -32,7 +32,7 @@ export class IndexedDBAztecArray<T extends Value> implements AztecAsyncArray<T>
     return (
       (await this.db
         .index('key')
-        .count(IDBKeyRange.bound([this.#container, this.#name], [this.#container, this.#name]))) ?? 0
+        .count(IDBKeyRange.bound([this.#container, [this.#name]], [this.#container, [this.#name]]))) ?? 0
     );
   }
 
@@ -43,7 +43,7 @@ export class IndexedDBAztecArray<T extends Value> implements AztecAsyncArray<T>
         value: val,
         hash: hash(val),
         container: this.#container,
-        key: this.#name,
+        key: [this.#name],
         keyCount: length + 1,
         slot: this.#slot(length),
       });
@@ -91,7 +91,7 @@ export class IndexedDBAztecArray<T extends Value> implements AztecAsyncArray<T>
       value: val,
       hash: hash(val),
       container: this.#container,
-      key: this.#name,
+      key: [this.#name],
       keyCount: index + 1,
       slot: this.#slot(index),
     });
@@ -100,7 +100,7 @@ export class IndexedDBAztecArray<T extends Value> implements AztecAsyncArray<T>
 
   async *entriesAsync(): AsyncIterableIterator<[number, T]> {
     const index = this.db.index('key');
-    const rangeQuery = IDBKeyRange.bound([this.#container, this.#name], [this.#container, this.#name]);
+    const rangeQuery = IDBKeyRange.bound([this.#container, [this.#name]], [this.#container, [this.#name]]);
     for await (const cursor of index.iterate(rangeQuery)) {
       yield [cursor.value.keyCount - 1, cursor.value.value] as [number, T];
     }

package/src/indexeddb/index.ts

@@ -1,12 +1,17 @@
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 
-import type { DataStoreConfig } from '../config.js';
-import { initStoreForRollup } from '../utils.js';
+import { initStoreForRollupAndSchemaVersion } from '../utils.js';
 import { AztecIndexedDBStore } from './store.js';
 
 export { AztecIndexedDBStore } from './store.js';
 
-export async function createStore(name: string, config: DataStoreConfig, log: Logger = createLogger('kv-store')) {
+export async function createStore(
+  name: string,
+  config: DataStoreConfig,
+  schemaVersion: number | undefined = undefined,
+  log: Logger = createLogger('kv-store'),
+) {
   let { dataDirectory } = config;
   if (typeof dataDirectory !== 'undefined') {
     dataDirectory = `${dataDirectory}/${name}`;
@@ -18,10 +23,7 @@ export async function createStore(name: string, config: DataStoreConfig, log: Lo
       : `Creating ${name} ephemeral data store with map size ${config.dataStoreMapSizeKb} KB`,
   );
   const store = await AztecIndexedDBStore.open(createLogger('kv-store:indexeddb'), dataDirectory ?? '', false);
-  if (config.l1Contracts?.rollupAddress) {
-    return initStoreForRollup(store, config.l1Contracts.rollupAddress, log);
-  }
-  return store;
+  return initStoreForRollupAndSchemaVersion(store, schemaVersion, config.rollupAddress, log);
 }
 
 export function openTmpStore(ephemeral: boolean = false): Promise<AztecIndexedDBStore> {

package/src/indexeddb/map.ts

@@ -31,7 +31,7 @@ export class IndexedDBAztecMap<K extends Key, V extends Value> implements AztecA
 
   async getAsync(key: K): Promise<V | undefined> {
     const data = await this.db.get(this.slot(key));
-    return data?.value as V;
+    return data ? this.restoreBuffers(data.value as V) : undefined;
   }
 
   async hasAsync(key: K): Promise<boolean> {
@@ -41,7 +41,7 @@ export class IndexedDBAztecMap<K extends Key, V extends Value> implements AztecA
 
   async sizeAsync(): Promise<number> {
     const index = this.db.index('key');
-    const rangeQuery = IDBKeyRange.bound([this.container, ''], [this.container, '\uffff']);
+    const rangeQuery = IDBKeyRange.bound([this.container], [this.container + '\uffff'], true, true);
     return await index.count(rangeQuery);
   }
 
@@ -80,9 +80,12 @@ export class IndexedDBAztecMap<K extends Key, V extends Value> implements AztecA
 
   async *entriesAsync(range: Range<K> = {}): AsyncIterableIterator<[K, V]> {
     const index = this.db.index('key');
+    const startKey = range.start ? this.normalizeKey(range.start) : [];
+    const endKey = range.end ? this.normalizeKey(range.end) : ['\uffff'];
+
     const rangeQuery = IDBKeyRange.bound(
-      [this.container, range.start ? this.normalizeKey(range.start) : ''],
-      [this.container, range.end ? this.normalizeKey(range.end) : '\uffff'],
+      [this.container, startKey],
+      [this.container, endKey],
       !!range.reverse,
       !range.reverse,
     );
@@ -91,7 +94,7 @@ export class IndexedDBAztecMap<K extends Key, V extends Value> implements AztecA
       if (range.limit && count >= range.limit) {
         return;
       }
-      yield [this.#denormalizeKey(cursor.value.key), cursor.value.value] as [K, V];
+      yield [this.#denormalizeKey(cursor.value.key), this.restoreBuffers(cursor.value.value as V)] as [K, V];
       count++;
     }
   }
@@ -108,14 +111,24 @@ export class IndexedDBAztecMap<K extends Key, V extends Value> implements AztecA
     }
   }
 
-  #denormalizeKey(key: string): K {
-    const denormalizedKey = key.split(',').map(part => (part.startsWith('n_') ? Number(part.slice(2)) : part));
-    return (denormalizedKey.length > 1 ? denormalizedKey : denormalizedKey[0]) as K;
+  /**
+   * IndexedDB's structured clone downcasts Buffer (a Node.js subclass of Uint8Array) to plain Uint8Array.
+   * This breaks .toString() behavior: Buffer.toString() returns UTF-8, Uint8Array.toString() returns
+   * comma-separated decimal bytes. We restore Buffer identity on read so callers get consistent behavior.
+   */
+  protected restoreBuffers(val: V): V {
+    if (val instanceof Uint8Array && !Buffer.isBuffer(val)) {
+      return Buffer.from(val) as V;
+    }
+    return val;
+  }
+
+  #denormalizeKey(key: (string | number | Uint8Array)[]): K {
+    return (key.length > 1 ? key : key[0]) as K;
   }
 
-  protected normalizeKey(key: K): string {
-    const arrayKey = Array.isArray(key) ? key : [key];
-    return (arrayKey as K[]).map((element: K) => (typeof element === 'number' ? `n_${element}` : element)).join(',');
+  protected normalizeKey(key: K): (string | number | Uint8Array)[] {
+    return Array.isArray(key) ? key : [key];
   }
 
   protected slot(key: K, index: number = 0): string {

package/src/indexeddb/multi_map.ts

@@ -57,10 +57,22 @@ export class IndexedDBAztecMultiMap<K extends Key, V extends Value>
       false,
     );
     for await (const cursor of index.iterate(rangeQuery)) {
-      yield cursor.value.value as V;
+      yield this.restoreBuffers(cursor.value.value as V);
     }
   }
 
+  getValueCountAsync(key: K): Promise<number> {
+    // Count entries over the keyCount index range for this key
+    const index = this.db.index('keyCount');
+    const rangeQuery = IDBKeyRange.bound(
+      [this.container, this.normalizeKey(key), 0],
+      [this.container, this.normalizeKey(key), Number.MAX_SAFE_INTEGER],
+      false,
+      false,
+    );
+    return index.count(rangeQuery);
+  }
+
   async deleteValue(key: K, val: V): Promise<void> {
     // Since we know the value, we can hash it and directly query the "hash" index
     // to avoid having to iterate over all the values
@@ -76,4 +88,18 @@ export class IndexedDBAztecMultiMap<K extends Key, V extends Value>
       await this.db.delete(fullKey);
     }
   }
+
+  override async delete(key: K): Promise<void> {
+    const index = this.db.index('keyCount');
+    const rangeQuery = IDBKeyRange.bound(
+      [this.container, this.normalizeKey(key), 0],
+      [this.container, this.normalizeKey(key), Number.MAX_SAFE_INTEGER],
+      false,
+      false,
+    );
+
+    for await (const cursor of index.iterate(rangeQuery)) {
+      await cursor.delete();
+    }
+  }
 }

package/src/indexeddb/singleton.ts

@@ -37,7 +37,7 @@ export class IndexedDBAztecSingleton<T extends Value> implements AztecAsyncSingl
     const result = await this.db.put({
       container: this.#container,
       slot: this.#slot,
-      key: this.#slot,
+      key: [this.#slot],
       keyCount: 1,
       value: val,
       hash: hash(val),