@aztec/kv-store 0.0.1-commit.9372f48 → 0.0.1-commit.949a33fd8

package/dest/sqlite-opfs/worker.js

@@ -0,0 +1,194 @@
+/// <reference lib="webworker" />
+import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
+const SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS data (
+    slot TEXT NOT NULL PRIMARY KEY,
+    container TEXT NOT NULL,
+    key BLOB NOT NULL,
+    key_count INTEGER NOT NULL,
+    hash TEXT NOT NULL,
+    value BLOB
+  ) WITHOUT ROWID;
+
+  CREATE INDEX IF NOT EXISTS idx_container_key ON data(container, key);
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_container_key_count ON data(container, key, key_count);
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_container_key_hash ON data(container, key, hash);
+`;
+const DEFAULT_SAH_POOL_DIRECTORY = '.aztec-kv';
+const SAH_POOL_VFS_NAME = 'aztec-kv-opfs';
+let sqlite3;
+let pool;
+let db;
+let dbPath;
+async function ensurePool(directory) {
+    sqlite3 ??= await sqlite3InitModule();
+    if (!pool) {
+        pool = await sqlite3.installOpfsSAHPoolVfs({
+            name: SAH_POOL_VFS_NAME,
+            directory,
+            initialCapacity: 8
+        });
+    }
+    return pool;
+}
+async function handleInit(dbName, ephemeral, directory) {
+    sqlite3 ??= await sqlite3InitModule();
+    if (ephemeral) {
+        db = new sqlite3.oo1.DB(':memory:', 'c');
+    } else {
+        const p = await ensurePool(directory ?? DEFAULT_SAH_POOL_DIRECTORY);
+        dbPath = normalizeDbPath(dbName);
+        db = new p.OpfsSAHPoolDb(dbPath);
+    }
+    runSql(SCHEMA_SQL);
+}
+function handleClose() {
+    db?.close();
+    db = undefined;
+    dbPath = undefined;
+}
+async function handleExport() {
+    if (!db || !dbPath) {
+        throw new Error('SQLite worker: no database open to export');
+    }
+    if (!pool) {
+        throw new Error('SQLite worker: no SAH Pool available (ephemeral DBs cannot be exported)');
+    }
+    return await pool.exportFile(dbPath);
+}
+function handleDeleteDb(dbName) {
+    const path = normalizeDbPath(dbName);
+    if (db && dbPath === path) {
+        db.close();
+        db = undefined;
+        dbPath = undefined;
+    }
+    // Ephemeral :memory: DBs never back a file — skip installing a pool just to unlink
+    // nothing. installOpfsSAHPoolVfs acquires an exclusive lock on the OPFS SAH
+    // directory, and under heavy test churn that can contend with workers from
+    // previous tests whose OPFS handles Chromium hasn't yet released, hanging the RPC
+    // and then the whole test run.
+    if (!pool) {
+        return;
+    }
+    try {
+        pool.unlink(path);
+    } catch  {
+    // File may not exist; ignore.
+    }
+}
+function requireDb() {
+    if (!db) {
+        throw new Error('SQLite worker: no database open');
+    }
+    return db;
+}
+function runSql(sql, bind) {
+    const conn = requireDb();
+    conn.exec({
+        sql,
+        bind
+    });
+    return {
+        changes: conn.changes()
+    };
+}
+function selectAll(sql, bind) {
+    const conn = requireDb();
+    const rows = [];
+    conn.exec({
+        sql,
+        bind,
+        rowMode: 'array',
+        resultRows: rows
+    });
+    return rows;
+}
+function normalizeDbPath(dbName) {
+    return dbName.startsWith('/') ? dbName : `/${dbName}`;
+}
+function respond(msg) {
+    self.postMessage(msg);
+}
+self.onmessage = async (ev)=>{
+    const req = ev.data;
+    try {
+        switch(req.type){
+            case 'init':
+                await handleInit(req.dbName, req.ephemeral, req.poolDirectory);
+                return respond({
+                    type: 'ok',
+                    id: req.id
+                });
+            case 'close':
+                handleClose();
+                return respond({
+                    type: 'ok',
+                    id: req.id
+                });
+            case 'deleteDb':
+                handleDeleteDb(req.dbName);
+                return respond({
+                    type: 'ok',
+                    id: req.id
+                });
+            case 'run':
+                {
+                    const { changes } = runSql(req.sql, req.bind);
+                    return respond({
+                        type: 'ok',
+                        id: req.id,
+                        changes
+                    });
+                }
+            case 'all':
+                {
+                    const rows = selectAll(req.sql, req.bind);
+                    return respond({
+                        type: 'ok',
+                        id: req.id,
+                        rows
+                    });
+                }
+            case 'export':
+                {
+                    const bytes = await handleExport();
+                    return respond({
+                        type: 'ok',
+                        id: req.id,
+                        bytes
+                    });
+                }
+            case 'begin':
+                runSql('BEGIN');
+                return respond({
+                    type: 'ok',
+                    id: req.id
+                });
+            case 'commit':
+                runSql('COMMIT');
+                return respond({
+                    type: 'ok',
+                    id: req.id
+                });
+            case 'rollback':
+                runSql('ROLLBACK');
+                return respond({
+                    type: 'ok',
+                    id: req.id
+                });
+            default:
+                {
+                    const _exhaustive = req;
+                    throw new Error(`Unknown request: ${JSON.stringify(_exhaustive)}`);
+                }
+        }
+    } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        respond({
+            type: 'err',
+            id: req.id,
+            message
+        });
+    }
+};

package/dest/utils.d.ts

@@ -12,4 +12,4 @@ import type { AztecAsyncKVStore, AztecKVStore } from './interfaces/store.js';
  * @returns The store (cleared if necessary)
  */
 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDM0QsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFJcEQsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsWUFBWSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFHN0U7Ozs7Ozs7OztHQVNHO0FBQ0gsd0JBQXNCLGtDQUFrQyxDQUFDLENBQUMsU0FBUyxZQUFZLEdBQUcsaUJBQWlCLEVBQ2pHLEtBQUssRUFBRSxDQUFDLEVBQ1IsYUFBYSxFQUFFLE1BQU0sR0FBRyxTQUFTLEVBQ2pDLGFBQWEsRUFBRSxVQUFVLEdBQUcsU0FBUyxFQUNyQyxHQUFHLENBQUMsRUFBRSxNQUFNLEdBQ1gsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQTJCWiJ9
+//# 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,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,CA2BZ"}
+{"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

@@ -17,7 +17,13 @@ import { isSyncStore } from './interfaces/utils.js';
     // DB version: database schema version + rollup address combined)
     const dbVersion = store.openSingleton('dbVersion');
     const storedDatabaseVersion = isSyncStore(store) ? dbVersion.get() : await dbVersion.getAsync();
-    if (doesStoreNeedToBeCleared(targetDatabaseVersion, storedDatabaseVersion, targetSchemaVersion, targetRollupAddress, log)) {
+    // 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 dbVersion.set(targetDatabaseVersion.toBuffer().toString('utf-8'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/kv-store",
-  "version": "0.0.1-commit.9372f48",
+  "version": "0.0.1-commit.949a33fd8",
   "type": "module",
   "exports": {
     ".": "./dest/interfaces/index.js",
@@ -8,15 +8,16 @@
     "./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"
   },
   "scripts": {
     "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:browser": "vitest run --config ./vitest.config.ts",
+    "bench:browser": "VITE_BENCH=1 vitest run --config ./vitest.config.ts src/bench",
     "test": "yarn test:node",
     "test:jest": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
@@ -25,11 +26,12 @@
     "./package.local.json"
   ],
   "dependencies": {
-    "@aztec/constants": "0.0.1-commit.9372f48",
-    "@aztec/ethereum": "0.0.1-commit.9372f48",
-    "@aztec/foundation": "0.0.1-commit.9372f48",
-    "@aztec/native": "0.0.1-commit.9372f48",
-    "@aztec/stdlib": "0.0.1-commit.9372f48",
+    "@aztec/constants": "0.0.1-commit.949a33fd8",
+    "@aztec/ethereum": "0.0.1-commit.949a33fd8",
+    "@aztec/foundation": "0.0.1-commit.949a33fd8",
+    "@aztec/native": "0.0.1-commit.949a33fd8",
+    "@aztec/stdlib": "0.0.1-commit.949a33fd8",
+    "@sqlite.org/sqlite-wasm": "3.50.4-build1",
     "idb": "^8.0.0",
     "lmdb": "^3.2.0",
     "msgpackr": "^1.11.2",
@@ -46,17 +48,19 @@
     "@types/node": "^22.15.17",
     "@types/sinon": "^17.0.3",
     "@typescript/native-preview": "7.0.0-dev.20260113.1",
-    "@web/dev-server-esbuild": "^1.0.3",
-    "@web/test-runner": "^0.19.0",
-    "@web/test-runner-playwright": "^0.11.0",
+    "@vitest/browser-playwright": "^4.0.0",
+    "buffer": "^6.0.3",
     "chai": "^5.1.2",
     "chai-as-promised": "^8.0.1",
     "jest": "^30.0.0",
     "mocha": "^10.8.2",
     "mocha-each": "^2.0.1",
+    "playwright": "1.49.0",
     "sinon": "^19.0.2",
     "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,6 +1,6 @@
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 
-import type { DataStoreConfig } from '../config.js';
 import { initStoreForRollupAndSchemaVersion } from '../utils.js';
 import { AztecIndexedDBStore } from './store.js';
 

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,7 +57,7 @@ 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);
     }
   }
 
@@ -88,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),

package/src/indexeddb/store.ts

@@ -20,7 +20,7 @@ import { IndexedDBAztecSingleton } from './singleton.js';
 export type StoredData<V extends Value> = {
   value: V;
   container: string;
-  key: string;
+  key: (string | number | Uint8Array)[];
   keyCount: number;
   slot: string;
   hash: string;
@@ -30,7 +30,12 @@ export interface AztecIDBSchema extends DBSchema {
   data: {
     value: StoredData<any>;
     key: string;
-    indexes: { container: string; key: string; keyCount: number; hash: string };
+    indexes: {
+      container: string;
+      key: any; // Runtime: (string | number | Uint8Array)[] - idb types don't support arrays
+      keyCount: number;
+      hash: string;
+    };
   };
 }
 
@@ -187,18 +192,20 @@ export class AztecIndexedDBStore implements AztecAsyncKVStore {
   }
 
   /** Deletes this store and removes the database */
-  delete() {
+  async delete() {
     this.#containers.clear();
+    await this.#txQueue.end();
     this.#rootDB.close();
-    return deleteDB(this.#name);
+    await deleteDB(this.#name);
   }
 
   estimateSize(): Promise<StoreSize> {
     return Promise.resolve({ mappingSize: 0, physicalFileSize: 0, actualSize: 0, numItems: 0 });
   }
 
-  close(): Promise<void> {
-    return Promise.resolve();
+  async close(): Promise<void> {
+    await this.#txQueue.end();
+    this.#rootDB.close();
   }
 
   backupTo(_dstPath: string, _compact?: boolean): Promise<void> {

package/src/interfaces/map_test_suite.ts

@@ -107,6 +107,33 @@ export function describeAztecMap(
       expect(await size()).to.equal(1);
     });
 
+    it('returns 0 for empty map size', async () => {
+      expect(await size()).to.equal(0);
+    });
+
+    it('calculates size correctly across multiple operations', async () => {
+      expect(await size()).to.equal(0);
+
+      // Add items
+      await map.set('a', 'value1');
+      await map.set('b', 'value2');
+      await map.set('c', 'value3');
+      expect(await size()).to.equal(3);
+
+      // Update existing (size should not change)
+      await map.set('b', 'updated');
+      expect(await size()).to.equal(3);
+
+      // Delete some
+      await map.delete('a');
+      expect(await size()).to.equal(2);
+
+      // Delete all
+      await map.delete('b');
+      await map.delete('c');
+      expect(await size()).to.equal(0);
+    });
+
     it('should be able to iterate over entries when there are no keys', async () => {
       expect(await entries()).to.deep.equal([]);
     });
@@ -145,10 +172,11 @@ export function describeAztecMap(
     for (const [name, data] of [
       ['chars', ['a', 'b', 'c', 'd']],
       ['numbers', [1, 2, 3, 4]],
-      // disabled because indexeddb sorts lexigographically
-      // ['negative numbers', [-4, -3, -2, -1]],
+      ['negative numbers', [-4, -3, -2, -1]],
       ['strings', ['aaa', 'bbb', 'ccc', 'ddd']],
       ['zero-based numbers', [0, 1, 2, 3]],
+      ['large numbers', [100, 999, 1000, 1001]],
+      ['mixed negative and positive', [-1000, -1, 1, 1000]],
     ]) {
       it(`supports range queries over ${name} keys`, async () => {
         const [a, b, c, d] = data;