@aztec/kv-store 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/lmdb/store.ts

@@ -7,22 +7,17 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 
 import type { AztecArray, AztecAsyncArray } from '../interfaces/array.js';
-import type { Key, StoreSize } from '../interfaces/common.js';
+import type { Key, StoreSize, Value } from '../interfaces/common.js';
 import type { AztecAsyncCounter, AztecCounter } from '../interfaces/counter.js';
-import type {
-  AztecAsyncMap,
-  AztecAsyncMultiMap,
-  AztecMap,
-  AztecMapWithSize,
-  AztecMultiMap,
-  AztecMultiMapWithSize,
-} from '../interfaces/map.js';
+import type { AztecAsyncMap, AztecMap } from '../interfaces/map.js';
+import type { AztecAsyncMultiMap, AztecMultiMap } from '../interfaces/multi_map.js';
 import type { AztecAsyncSet, AztecSet } from '../interfaces/set.js';
 import type { AztecAsyncSingleton, AztecSingleton } from '../interfaces/singleton.js';
 import type { AztecAsyncKVStore, AztecKVStore } from '../interfaces/store.js';
 import { LmdbAztecArray } from './array.js';
 import { LmdbAztecCounter } from './counter.js';
-import { LmdbAztecMap, LmdbAztecMapWithSize } from './map.js';
+import { LmdbAztecMap } from './map.js';
+import { LmdbAztecMultiMap } from './multi_map.js';
 import { LmdbAztecSet } from './set.js';
 import { LmdbAztecSingleton } from './singleton.js';
 
@@ -37,7 +32,11 @@ export class AztecLmdbStore implements AztecKVStore, AztecAsyncKVStore {
   #multiMapData: Database<unknown, Key>;
   #log = createLogger('kv-store:lmdb');
 
-  constructor(rootDb: RootDatabase, public readonly isEphemeral: boolean, private path: string) {
+  constructor(
+    rootDb: RootDatabase,
+    public readonly isEphemeral: boolean,
+    private path: string,
+  ) {
     this.#rootDb = rootDb;
 
     // big bucket to store all the data
@@ -80,27 +79,12 @@ export class AztecLmdbStore implements AztecKVStore, AztecAsyncKVStore {
     return new AztecLmdbStore(rootDb, ephemeral, dbPath);
   }
 
-  /**
-   * Forks the current DB into a new DB by backing it up to a temporary location and opening a new lmdb db.
-   * @returns A new AztecLmdbStore.
-   */
-  async fork() {
-    const baseDir = this.path;
-    this.#log.debug(`Forking store with basedir ${baseDir}`);
-    const forkPath = await fs.mkdtemp(join(baseDir, 'aztec-store-fork-'));
-    this.#log.verbose(`Forking store to ${forkPath}`);
-    await this.#rootDb.backup(forkPath, false);
-    const forkDb = open(forkPath, { noSync: this.isEphemeral });
-    this.#log.debug(`Forked store at ${forkPath} opened successfully`);
-    return new AztecLmdbStore(forkDb, this.isEphemeral, forkPath);
-  }
-
   /**
    * Creates a new AztecMap in the store.
    * @param name - Name of the map
    * @returns A new AztecMap
    */
-  openMap<K extends Key, V>(name: string): AztecMap<K, V> & AztecAsyncMap<K, V> {
+  openMap<K extends Key, V extends Value>(name: string): AztecMap<K, V> & AztecAsyncMap<K, V> {
     return new LmdbAztecMap(this.#data, name);
   }
 
@@ -118,37 +102,20 @@ export class AztecLmdbStore implements AztecKVStore, AztecAsyncKVStore {
    * @param name - Name of the map
    * @returns A new AztecMultiMap
    */
-  openMultiMap<K extends Key, V>(name: string): AztecMultiMap<K, V> & AztecAsyncMultiMap<K, V> {
-    return new LmdbAztecMap(this.#multiMapData, name);
+  openMultiMap<K extends Key, V extends Value>(name: string): AztecMultiMap<K, V> & AztecAsyncMultiMap<K, V> {
+    return new LmdbAztecMultiMap(this.#multiMapData, name);
   }
 
   openCounter<K extends Key>(name: string): AztecCounter<K> & AztecAsyncCounter<K> {
     return new LmdbAztecCounter(this.#data, name);
   }
-  /**
-   * Creates a new AztecMultiMapWithSize in the store. A multi-map with size stores multiple values for a single key automatically.
-   * @param name - Name of the map
-   * @returns A new AztecMultiMapWithSize
-   */
-  openMultiMapWithSize<K extends Key, V>(name: string): AztecMultiMapWithSize<K, V> {
-    return new LmdbAztecMapWithSize(this.#multiMapData, name);
-  }
-
-  /**
-   * Creates a new AztecMapWithSize in the store.
-   * @param name - Name of the map
-   * @returns A new AztecMapWithSize
-   */
-  openMapWithSize<K extends Key, V>(name: string): AztecMapWithSize<K, V> {
-    return new LmdbAztecMapWithSize(this.#data, name);
-  }
 
   /**
    * Creates a new AztecArray in the store.
    * @param name - Name of the array
    * @returns A new AztecArray
    */
-  openArray<T>(name: string): AztecArray<T> & AztecAsyncArray<T> {
+  openArray<T extends Value>(name: string): AztecArray<T> & AztecAsyncArray<T> {
     return new LmdbAztecArray(this.#data, name);
   }
 
@@ -224,10 +191,15 @@ export class AztecLmdbStore implements AztecKVStore, AztecAsyncKVStore {
     if ('mapSize' in stats && typeof stats.mapSize === 'number') {
       mapSize = stats.mapSize;
     }
+    let physicalFileSize = 0;
+    if ('physicalFileSize' in stats && typeof stats.physicalFileSize === 'number') {
+      physicalFileSize = stats.physicalFileSize;
+    }
     const dataResult = this.estimateSubDBSize(this.#data);
     const multiResult = this.estimateSubDBSize(this.#multiMapData);
     return Promise.resolve({
       mappingSize: mapSize,
+      physicalFileSize: physicalFileSize,
       actualSize: dataResult.actualSize + multiResult.actualSize,
       numItems: dataResult.numItems + multiResult.numItems,
     });
@@ -260,4 +232,8 @@ export class AztecLmdbStore implements AztecKVStore, AztecAsyncKVStore {
     }
     return { actualSize, numItems };
   }
+
+  backupTo(_dstPath: string, _compact?: boolean): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
 }

package/src/lmdb-v2/array.ts

@@ -1,17 +1,22 @@
 import { Encoder } from 'msgpackr/pack';
 
 import type { AztecAsyncArray } from '../interfaces/array.js';
+import type { Value } from '../interfaces/common.js';
 import type { AztecAsyncSingleton } from '../interfaces/singleton.js';
 import type { ReadTransaction } from './read_transaction.js';
+// eslint-disable-next-line import/no-cycle
 import { AztecLMDBStoreV2, execInReadTx, execInWriteTx } from './store.js';
 import { deserializeKey, serializeKey } from './utils.js';
 
-export class LMDBArray<T> implements AztecAsyncArray<T> {
+export class LMDBArray<T extends Value> implements AztecAsyncArray<T> {
   private length: AztecAsyncSingleton<number>;
   private encoder = new Encoder();
   private prefix: string;
 
-  constructor(private store: AztecLMDBStoreV2, name: string) {
+  constructor(
+    private store: AztecLMDBStoreV2,
+    name: string,
+  ) {
     this.length = store.openSingleton(name + ':length');
     this.prefix = `array:${name}`;
   }

package/src/lmdb-v2/factory.ts

@@ -28,16 +28,20 @@ export async function createStore(
     const rollupAddress = l1Contracts ? l1Contracts.rollupAddress : EthAddress.ZERO;
 
     // Create a version manager
-    const versionManager = new DatabaseVersionManager(schemaVersion, rollupAddress, subDir, dbDirectory =>
-      AztecLMDBStoreV2.new(dbDirectory, config.dataStoreMapSizeKB, MAX_READERS, () => Promise.resolve(), log),
-    );
+    const versionManager = new DatabaseVersionManager({
+      schemaVersion,
+      rollupAddress,
+      dataDirectory: subDir,
+      onOpen: dbDirectory =>
+        AztecLMDBStoreV2.new(dbDirectory, config.dataStoreMapSizeKb, MAX_READERS, () => Promise.resolve(), log),
+    });
 
     log.info(
-      `Creating ${name} data store at directory ${subDir} with map size ${config.dataStoreMapSizeKB} KB (LMDB v2)`,
+      `Creating ${name} data store at directory ${subDir} with map size ${config.dataStoreMapSizeKb} KB (LMDB v2)`,
     );
     [store] = await versionManager.open();
   } else {
-    store = await openTmpStore(name, true, config.dataStoreMapSizeKB, MAX_READERS, log);
+    store = await openTmpStore(name, true, config.dataStoreMapSizeKb, MAX_READERS, log);
   }
 
   return store;
@@ -83,16 +87,19 @@ export async function openStoreAt(
 }
 
 export async function openVersionedStoreAt(
-  dataDir: string,
+  dataDirectory: string,
   schemaVersion: number,
   rollupAddress: EthAddress,
   dbMapSizeKb = 10 * 1_024 * 1_024, // 10GB
   maxReaders = MAX_READERS,
   log: Logger = createLogger('kv-store:lmdb-v2'),
 ): Promise<AztecLMDBStoreV2> {
-  log.debug(`Opening data store at: ${dataDir} with size: ${dbMapSizeKb} KB (LMDB v2)`);
-  const [store] = await new DatabaseVersionManager(schemaVersion, rollupAddress, dataDir, dataDir =>
-    AztecLMDBStoreV2.new(dataDir, dbMapSizeKb, maxReaders, undefined, log),
-  ).open();
+  log.debug(`Opening data store at: ${dataDirectory} with size: ${dbMapSizeKb} KB (LMDB v2)`);
+  const [store] = await new DatabaseVersionManager({
+    schemaVersion,
+    rollupAddress,
+    dataDirectory,
+    onOpen: dataDir => AztecLMDBStoreV2.new(dataDir, dbMapSizeKb, maxReaders, undefined, log),
+  }).open();
   return store;
 }

package/src/lmdb-v2/map.ts

@@ -1,16 +1,20 @@
 import { Encoder } from 'msgpackr';
 
-import type { Key, Range } from '../interfaces/common.js';
-import type { AztecAsyncMap, AztecAsyncMultiMap } from '../interfaces/map.js';
+import type { Key, Range, Value } from '../interfaces/common.js';
+import type { AztecAsyncMap } from '../interfaces/map.js';
 import type { ReadTransaction } from './read_transaction.js';
+// eslint-disable-next-line import/no-cycle
 import { type AztecLMDBStoreV2, execInReadTx, execInWriteTx } from './store.js';
 import { deserializeKey, maxKey, minKey, serializeKey } from './utils.js';
 
-export class LMDBMap<K extends Key, V> implements AztecAsyncMap<K, V> {
+export class LMDBMap<K extends Key, V extends Value> implements AztecAsyncMap<K, V> {
   private prefix: string;
   private encoder = new Encoder();
 
-  constructor(private store: AztecLMDBStoreV2, name: string) {
+  constructor(
+    private store: AztecLMDBStoreV2,
+    name: string,
+  ) {
     this.prefix = `map:${name}`;
   }
   /**
@@ -22,6 +26,18 @@ export class LMDBMap<K extends Key, V> implements AztecAsyncMap<K, V> {
     return execInWriteTx(this.store, tx => tx.set(serializeKey(this.prefix, key), this.encoder.pack(val)));
   }
 
+  /**
+   * Sets the values at the given keys.
+   * @param entries - The entries to set
+   */
+  async setMany(entries: { key: K; value: V }[]): Promise<void> {
+    await execInWriteTx(this.store, async tx => {
+      for (const { key, value } of entries) {
+        await tx.set(serializeKey(this.prefix, key), this.encoder.pack(value));
+      }
+    });
+  }
+
   /**
    * Sets the value at the given key if it does not already exist.
    * @param key - The key to set the value at
@@ -58,15 +74,21 @@ export class LMDBMap<K extends Key, V> implements AztecAsyncMap<K, V> {
     return execInReadTx(this.store, async tx => !!(await tx.get(serializeKey(this.prefix, key))));
   }
 
+  sizeAsync(): Promise<number> {
+    return execInReadTx(this.store, tx => tx.countEntries(minKey(this.prefix), maxKey(this.prefix), false));
+  }
+
   /**
    * Iterates over the map's key-value entries in the key's natural order
    * @param range - The range of keys to iterate over
    */
   async *entriesAsync(range?: Range<K>): AsyncIterableIterator<[K, V]> {
     const reverse = range?.reverse ?? false;
-    const startKey = range?.start ? serializeKey(this.prefix, range.start) : minKey(this.prefix);
 
-    const endKey = range?.end ? serializeKey(this.prefix, range.end) : reverse ? maxKey(this.prefix) : undefined;
+    const startKey = range?.start !== undefined ? serializeKey(this.prefix, range.start) : minKey(this.prefix);
+
+    const endKey =
+      range?.end !== undefined ? serializeKey(this.prefix, range.end) : reverse ? maxKey(this.prefix) : undefined;
 
     let tx: ReadTransaction | undefined = this.store.getCurrentWriteTx();
     const shouldClose = !tx;
@@ -80,7 +102,7 @@ export class LMDBMap<K extends Key, V> implements AztecAsyncMap<K, V> {
         range?.limit,
       )) {
         const deserializedKey = deserializeKey<K>(this.prefix, key);
-        if (!deserializedKey) {
+        if (deserializedKey === false) {
           break;
         }
         yield [deserializedKey, this.encoder.unpack(val)];
@@ -112,122 +134,3 @@ export class LMDBMap<K extends Key, V> implements AztecAsyncMap<K, V> {
     }
   }
 }
-
-export class LMDBMultiMap<K extends Key, V> implements AztecAsyncMultiMap<K, V> {
-  private prefix: string;
-  private encoder = new Encoder();
-  constructor(private store: AztecLMDBStoreV2, name: string) {
-    this.prefix = `multimap:${name}`;
-  }
-
-  /**
-   * Sets the value at the given key.
-   * @param key - The key to set the value at
-   * @param val - The value to set
-   */
-  set(key: K, val: V): Promise<void> {
-    return execInWriteTx(this.store, tx => tx.setIndex(serializeKey(this.prefix, key), this.encoder.pack(val)));
-  }
-
-  /**
-   * Sets the value at the given key if it does not already exist.
-   * @param key - The key to set the value at
-   * @param val - The value to set
-   */
-  setIfNotExists(key: K, val: V): Promise<boolean> {
-    return execInWriteTx(this.store, async tx => {
-      const exists = !!(await this.getAsync(key));
-      if (!exists) {
-        await tx.setIndex(serializeKey(this.prefix, key), this.encoder.pack(val));
-        return true;
-      }
-      return false;
-    });
-  }
-
-  /**
-   * Deletes the value at the given key.
-   * @param key - The key to delete the value at
-   */
-  delete(key: K): Promise<void> {
-    return execInWriteTx(this.store, tx => tx.removeIndex(serializeKey(this.prefix, key)));
-  }
-
-  getAsync(key: K): Promise<V | undefined> {
-    return execInReadTx(this.store, async tx => {
-      const val = await tx.getIndex(serializeKey(this.prefix, key));
-      return val.length > 0 ? this.encoder.unpack(val[0]) : undefined;
-    });
-  }
-
-  hasAsync(key: K): Promise<boolean> {
-    return execInReadTx(this.store, async tx => (await tx.getIndex(serializeKey(this.prefix, key))).length > 0);
-  }
-
-  /**
-   * Iterates over the map's key-value entries in the key's natural order
-   * @param range - The range of keys to iterate over
-   */
-  async *entriesAsync(range?: Range<K>): AsyncIterableIterator<[K, V]> {
-    const reverse = range?.reverse ?? false;
-    const startKey = range?.start ? serializeKey(this.prefix, range.start) : minKey(this.prefix);
-    const endKey = range?.end ? serializeKey(this.prefix, range.end) : reverse ? maxKey(this.prefix) : undefined;
-
-    let tx: ReadTransaction | undefined = this.store.getCurrentWriteTx();
-    const shouldClose = !tx;
-    tx ??= this.store.getReadTx();
-
-    try {
-      for await (const [key, vals] of tx.iterateIndex(
-        reverse ? endKey! : startKey,
-        reverse ? startKey : endKey,
-        reverse,
-        range?.limit,
-      )) {
-        const deserializedKey = deserializeKey<K>(this.prefix, key);
-        if (!deserializedKey) {
-          break;
-        }
-
-        for (const val of vals) {
-          yield [deserializedKey, this.encoder.unpack(val)];
-        }
-      }
-    } finally {
-      if (shouldClose) {
-        tx.close();
-      }
-    }
-  }
-
-  /**
-   * Iterates over the map's values in the key's natural order
-   * @param range - The range of keys to iterate over
-   */
-  async *valuesAsync(range?: Range<K>): AsyncIterableIterator<V> {
-    for await (const [_, value] of this.entriesAsync(range)) {
-      yield value;
-    }
-  }
-
-  /**
-   * Iterates over the map's keys in the key's natural order
-   * @param range - The range of keys to iterate over
-   */
-  async *keysAsync(range?: Range<K>): AsyncIterableIterator<K> {
-    for await (const [key, _] of this.entriesAsync(range)) {
-      yield key;
-    }
-  }
-
-  deleteValue(key: K, val: V | undefined): Promise<void> {
-    return execInWriteTx(this.store, tx => tx.removeIndex(serializeKey(this.prefix, key), this.encoder.pack(val)));
-  }
-
-  async *getValuesAsync(key: K): AsyncIterableIterator<V> {
-    const values = await execInReadTx(this.store, tx => tx.getIndex(serializeKey(this.prefix, key)));
-    for (const value of values) {
-      yield this.encoder.unpack(value);
-    }
-  }
-}

package/src/lmdb-v2/message.ts

@@ -12,6 +12,7 @@ export enum LMDBMessageType {
 
   START_CURSOR,
   ADVANCE_CURSOR,
+  ADVANCE_CURSOR_COUNT,
   CLOSE_CURSOR,
 
   BATCH,
@@ -19,6 +20,7 @@ export enum LMDBMessageType {
   STATS,
 
   CLOSE,
+  COPY_STORE,
 }
 
 type Key = Uint8Array;
@@ -59,10 +61,20 @@ interface AdvanceCursorRequest {
   count: number | null;
 }
 
+interface AdvanceCursorCountRequest {
+  cursor: number;
+  endKey: Key;
+}
+
 interface CloseCursorRequest {
   cursor: number;
 }
 
+interface CopyStoreRequest {
+  dstPath: string;
+  compact: boolean;
+}
+
 export interface Batch {
   addEntries: Array<KeyValues>;
   removeEntries: Array<KeyOptionalValues>;
@@ -80,6 +92,7 @@ export type LMDBRequestBody = {
 
   [LMDBMessageType.START_CURSOR]: StartCursorRequest;
   [LMDBMessageType.ADVANCE_CURSOR]: AdvanceCursorRequest;
+  [LMDBMessageType.ADVANCE_CURSOR_COUNT]: AdvanceCursorCountRequest;
   [LMDBMessageType.CLOSE_CURSOR]: CloseCursorRequest;
 
   [LMDBMessageType.BATCH]: BatchRequest;
@@ -87,6 +100,7 @@ export type LMDBRequestBody = {
   [LMDBMessageType.STATS]: void;
 
   [LMDBMessageType.CLOSE]: void;
+  [LMDBMessageType.COPY_STORE]: CopyStoreRequest;
 };
 
 interface GetResponse {
@@ -107,6 +121,11 @@ interface AdvanceCursorResponse {
   done: boolean;
 }
 
+interface AdvanceCursorCountResponse {
+  count: number;
+  done: boolean;
+}
+
 interface BatchResponse {
   durationNs: number;
 }
@@ -122,6 +141,7 @@ interface StatsResponse {
     totalUsedSize: bigint | number;
   }>;
   dbMapSizeBytes: bigint | number;
+  dbPhysicalFileSizeBytes: bigint | number;
 }
 
 export type LMDBResponseBody = {
@@ -132,6 +152,7 @@ export type LMDBResponseBody = {
 
   [LMDBMessageType.START_CURSOR]: StartCursorResponse;
   [LMDBMessageType.ADVANCE_CURSOR]: AdvanceCursorResponse;
+  [LMDBMessageType.ADVANCE_CURSOR_COUNT]: AdvanceCursorCountResponse;
   [LMDBMessageType.CLOSE_CURSOR]: BoolResponse;
 
   [LMDBMessageType.BATCH]: BatchResponse;
@@ -139,6 +160,8 @@ export type LMDBResponseBody = {
   [LMDBMessageType.STATS]: StatsResponse;
 
   [LMDBMessageType.CLOSE]: BoolResponse;
+
+  [LMDBMessageType.COPY_STORE]: BoolResponse;
 };
 
 export interface LMDBMessageChannel {

package/src/lmdb-v2/multi_map.ts

@@ -0,0 +1,141 @@
+import { Encoder } from 'msgpackr/pack';
+
+import type { Key, Range, Value } from '../interfaces/common.js';
+import type { AztecAsyncMultiMap } from '../interfaces/multi_map.js';
+import type { ReadTransaction } from './read_transaction.js';
+import { type AztecLMDBStoreV2, execInReadTx, execInWriteTx } from './store.js';
+import { deserializeKey, maxKey, minKey, serializeKey } from './utils.js';
+
+export class LMDBMultiMap<K extends Key, V extends Value> implements AztecAsyncMultiMap<K, V> {
+  private prefix: string;
+  private encoder = new Encoder();
+  constructor(
+    private store: AztecLMDBStoreV2,
+    name: string,
+  ) {
+    this.prefix = `multimap:${name}`;
+  }
+
+  /**
+   * Sets the value at the given key.
+   * @param key - The key to set the value at
+   * @param val - The value to set
+   */
+  set(key: K, val: V): Promise<void> {
+    return execInWriteTx(this.store, tx => tx.setIndex(serializeKey(this.prefix, key), this.encoder.pack(val)));
+  }
+
+  async setMany(entries: { key: K; value: V }[]): Promise<void> {
+    await execInWriteTx(this.store, async tx => {
+      for (const { key, value } of entries) {
+        await tx.setIndex(serializeKey(this.prefix, key), this.encoder.pack(value));
+      }
+    });
+  }
+
+  /**
+   * Sets the value at the given key if it does not already exist.
+   * @param key - The key to set the value at
+   * @param val - The value to set
+   */
+  setIfNotExists(key: K, val: V): Promise<boolean> {
+    return execInWriteTx(this.store, async tx => {
+      const exists = !!(await this.getAsync(key));
+      if (!exists) {
+        await tx.setIndex(serializeKey(this.prefix, key), this.encoder.pack(val));
+        return true;
+      }
+      return false;
+    });
+  }
+
+  /**
+   * Deletes the value at the given key.
+   * @param key - The key to delete the value at
+   */
+  delete(key: K): Promise<void> {
+    return execInWriteTx(this.store, tx => tx.removeIndex(serializeKey(this.prefix, key)));
+  }
+
+  getAsync(key: K): Promise<V | undefined> {
+    return execInReadTx(this.store, async tx => {
+      const val = await tx.getIndex(serializeKey(this.prefix, key));
+      return val.length > 0 ? this.encoder.unpack(val[0]) : undefined;
+    });
+  }
+
+  hasAsync(key: K): Promise<boolean> {
+    return execInReadTx(this.store, async tx => (await tx.getIndex(serializeKey(this.prefix, key))).length > 0);
+  }
+
+  sizeAsync(): Promise<number> {
+    return execInReadTx(this.store, tx => tx.countEntriesIndex(minKey(this.prefix), maxKey(this.prefix), false));
+  }
+
+  /**
+   * Iterates over the map's key-value entries in the key's natural order
+   * @param range - The range of keys to iterate over
+   */
+  async *entriesAsync(range?: Range<K>): AsyncIterableIterator<[K, V]> {
+    const reverse = range?.reverse ?? false;
+    const startKey = range?.start ? serializeKey(this.prefix, range.start) : minKey(this.prefix);
+    const endKey = range?.end ? serializeKey(this.prefix, range.end) : reverse ? maxKey(this.prefix) : undefined;
+
+    let tx: ReadTransaction | undefined = this.store.getCurrentWriteTx();
+    const shouldClose = !tx;
+    tx ??= this.store.getReadTx();
+
+    try {
+      for await (const [key, vals] of tx.iterateIndex(
+        reverse ? endKey! : startKey,
+        reverse ? startKey : endKey,
+        reverse,
+        range?.limit,
+      )) {
+        const deserializedKey = deserializeKey<K>(this.prefix, key);
+        if (!deserializedKey) {
+          break;
+        }
+
+        for (const val of vals) {
+          yield [deserializedKey, this.encoder.unpack(val)];
+        }
+      }
+    } finally {
+      if (shouldClose) {
+        tx.close();
+      }
+    }
+  }
+
+  /**
+   * Iterates over the map's values in the key's natural order
+   * @param range - The range of keys to iterate over
+   */
+  async *valuesAsync(range?: Range<K>): AsyncIterableIterator<V> {
+    for await (const [_, value] of this.entriesAsync(range)) {
+      yield value;
+    }
+  }
+
+  /**
+   * Iterates over the map's keys in the key's natural order
+   * @param range - The range of keys to iterate over
+   */
+  async *keysAsync(range?: Range<K>): AsyncIterableIterator<K> {
+    for await (const [key, _] of this.entriesAsync(range)) {
+      yield key;
+    }
+  }
+
+  deleteValue(key: K, val: V | undefined): Promise<void> {
+    return execInWriteTx(this.store, tx => tx.removeIndex(serializeKey(this.prefix, key), this.encoder.pack(val)));
+  }
+
+  async *getValuesAsync(key: K): AsyncIterableIterator<V> {
+    const values = await execInReadTx(this.store, tx => tx.getIndex(serializeKey(this.prefix, key)));
+    for (const value of values) {
+      yield this.encoder.unpack(value);
+    }
+  }
+}

package/src/lmdb-v2/read_transaction.ts

@@ -48,6 +48,14 @@ export class ReadTransaction {
     yield* this.#iterate(Database.INDEX, startKey, endKey, reverse, limit, vals => vals);
   }
 
+  public countEntries(startKey: Uint8Array, endKey: Uint8Array, reverse: boolean): Promise<number> {
+    return this.#countEntries(Database.DATA, startKey, endKey, reverse);
+  }
+
+  public countEntriesIndex(startKey: Uint8Array, endKey: Uint8Array, reverse: boolean): Promise<number> {
+    return this.#countEntries(Database.INDEX, startKey, endKey, reverse);
+  }
+
   async *#iterate<T>(
     db: string,
     startKey: Uint8Array,
@@ -113,4 +121,36 @@ export class ReadTransaction {
       }
     }
   }
+
+  async #countEntries(db: string, startKey: Uint8Array, endKey: Uint8Array, reverse: boolean): Promise<number> {
+    this.assertIsOpen();
+
+    const response = await this.channel.sendMessage(LMDBMessageType.START_CURSOR, {
+      key: startKey,
+      reverse,
+      count: 0,
+      onePage: false,
+      db,
+    });
+
+    const cursor = response.cursor;
+
+    try {
+      if (!cursor) {
+        return 0;
+      }
+
+      const advanceResponse = await this.channel.sendMessage(LMDBMessageType.ADVANCE_CURSOR_COUNT, {
+        cursor,
+        endKey: endKey,
+      });
+
+      return advanceResponse.count;
+    } finally {
+      // we might not have anything to close
+      if (typeof cursor === 'number') {
+        await this.channel.sendMessage(LMDBMessageType.CLOSE_CURSOR, { cursor });
+      }
+    }
+  }
 }