@aztec/kv-store 0.65.2 → 0.67.0

package/src/lmdb/array.ts

@@ -1,6 +1,6 @@
 import { type Database, type Key } from 'lmdb';
 
-import { type AztecArray } from '../interfaces/array.js';
+import { type AztecArray, type AztecAsyncArray } from '../interfaces/array.js';
 import { LmdbAztecSingleton } from './singleton.js';
 
 /** The shape of a key that stores a value in an array */
@@ -9,7 +9,7 @@ type ArrayIndexSlot = ['array', string, 'slot', number];
 /**
  * An persistent array backed by LMDB.
  */
-export class LmdbAztecArray<T> implements AztecArray<T> {
+export class LmdbAztecArray<T> implements AztecArray<T>, AztecAsyncArray<T> {
   #db: Database<T, ArrayIndexSlot>;
   #name: string;
   #length: LmdbAztecSingleton<number>;
@@ -24,6 +24,10 @@ export class LmdbAztecArray<T> implements AztecArray<T> {
     return this.#length.get() ?? 0;
   }
 
+  lengthAsync(): Promise<number> {
+    return Promise.resolve(this.length);
+  }
+
   push(...vals: T[]): Promise<number> {
     return this.#db.childTransaction(() => {
       let length = this.length;
@@ -69,6 +73,10 @@ export class LmdbAztecArray<T> implements AztecArray<T> {
     return this.#db.get(this.#slot(index));
   }
 
+  atAsync(index: number): Promise<T | undefined> {
+    return Promise.resolve(this.at(index));
+  }
+
   setAt(index: number, val: T): Promise<boolean> {
     if (index < 0) {
       index = this.length + index;
@@ -93,16 +101,32 @@ export class LmdbAztecArray<T> implements AztecArray<T> {
     }
   }
 
+  async *entriesAsync(): AsyncIterableIterator<[number, T]> {
+    for (const [key, value] of this.entries()) {
+      yield [key, value];
+    }
+  }
+
   *values(): IterableIterator<T> {
     for (const [_, value] of this.entries()) {
       yield value;
     }
   }
 
+  async *valuesAsync(): AsyncIterableIterator<T> {
+    for (const [_, value] of this.entries()) {
+      yield value;
+    }
+  }
+
   [Symbol.iterator](): IterableIterator<T> {
     return this.values();
   }
 
+  [Symbol.asyncIterator](): AsyncIterableIterator<T> {
+    return this.valuesAsync();
+  }
+
   #slot(index: number): ArrayIndexSlot {
     return ['array', this.#name, 'slot', index];
   }

package/src/lmdb/counter.ts

@@ -1,13 +1,13 @@
 import { type Key as BaseKey, type Database } from 'lmdb';
 
 import { type Key, type Range } from '../interfaces/common.js';
-import { type AztecCounter } from '../interfaces/counter.js';
+import { type AztecAsyncCounter, type AztecCounter } from '../interfaces/counter.js';
 import { LmdbAztecMap } from './map.js';
 
 /**
  * A counter implementation backed by LMDB
  */
-export class LmdbAztecCounter<K extends Key> implements AztecCounter<K> {
+export class LmdbAztecCounter<K extends Key> implements AztecCounter<K>, AztecAsyncCounter<K> {
   #db: Database;
   #name: string;
   #map: LmdbAztecMap<K, number>;
@@ -45,11 +45,23 @@ export class LmdbAztecCounter<K extends Key> implements AztecCounter<K> {
     return this.#map.get(key) ?? 0;
   }
 
+  getAsync(key: K): Promise<number> {
+    return Promise.resolve(this.get(key));
+  }
+
   entries(range: Range<K> = {}): IterableIterator<[K, number]> {
     return this.#map.entries(range);
   }
 
+  async *entriesAsync(range: Range<K> = {}): AsyncIterableIterator<[K, number]> {
+    yield* this.entries(range);
+  }
+
   keys(range: Range<K> = {}): IterableIterator<K> {
     return this.#map.keys(range);
   }
+
+  async *keysAsync(range: Range<K> = {}): AsyncIterableIterator<K> {
+    yield* this.keys(range);
+  }
 }

package/src/lmdb/index.ts

@@ -1 +1,37 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+
+import { join } from 'path';
+
+import { type DataStoreConfig } from '../config.js';
+import { initStoreForRollup } from '../utils.js';
+import { AztecLmdbStore } from './store.js';
+
 export { AztecLmdbStore } from './store.js';
+
+export function createStore(name: string, config: DataStoreConfig, log: Logger = createLogger('kv-store')) {
+  let { dataDirectory } = config;
+  if (typeof dataDirectory !== 'undefined') {
+    dataDirectory = join(dataDirectory, name);
+  }
+
+  log.info(
+    dataDirectory
+      ? `Creating ${name} data store at directory ${dataDirectory} with map size ${config.dataStoreMapSizeKB} KB`
+      : `Creating ${name} ephemeral data store with map size ${config.dataStoreMapSizeKB} KB`,
+  );
+
+  const store = AztecLmdbStore.open(dataDirectory, config.dataStoreMapSizeKB, false);
+  if (config.l1Contracts?.rollupAddress) {
+    return initStoreForRollup(store, config.l1Contracts.rollupAddress, log);
+  }
+  return store;
+}
+/**
+ * Opens a temporary store for testing purposes.
+ * @param ephemeral - true if the store should only exist in memory and not automatically be flushed to disk. Optional
+ * @returns A new store
+ */
+export function openTmpStore(ephemeral: boolean = false): AztecLmdbStore {
+  const mapSize = 1024 * 1024 * 10; // 10 GB map size
+  return AztecLmdbStore.open(undefined, mapSize, ephemeral);
+}

package/src/lmdb/map.ts

@@ -1,7 +1,7 @@
 import { type Database, type RangeOptions } from 'lmdb';
 
 import { type Key, type Range } from '../interfaces/common.js';
-import { type AztecMultiMap } from '../interfaces/map.js';
+import { type AztecAsyncMultiMap, type AztecMultiMap } from '../interfaces/map.js';
 
 /** The slot where a key-value entry would be stored */
 type MapValueSlot<K extends Key | Buffer> = ['map', string, 'slot', K];
@@ -9,7 +9,7 @@ type MapValueSlot<K extends Key | Buffer> = ['map', string, 'slot', K];
 /**
  * A map backed by LMDB.
  */
-export class LmdbAztecMap<K extends Key, V> implements AztecMultiMap<K, V> {
+export class LmdbAztecMap<K extends Key, V> implements AztecMultiMap<K, V>, AztecAsyncMultiMap<K, V> {
   protected db: Database<[K, V], MapValueSlot<K>>;
   protected name: string;
 
@@ -35,6 +35,10 @@ export class LmdbAztecMap<K extends Key, V> implements AztecMultiMap<K, V> {
     return this.db.get(this.#slot(key))?.[1];
   }
 
+  getAsync(key: K): Promise<V | undefined> {
+    return Promise.resolve(this.get(key));
+  }
+
   *getValues(key: K): IterableIterator<V> {
     const values = this.db.getValues(this.#slot(key));
     for (const value of values) {
@@ -42,10 +46,20 @@ export class LmdbAztecMap<K extends Key, V> implements AztecMultiMap<K, V> {
     }
   }
 
+  async *getValuesAsync(key: K): AsyncIterableIterator<V> {
+    for (const value of this.getValues(key)) {
+      yield value;
+    }
+  }
+
   has(key: K): boolean {
     return this.db.doesExist(this.#slot(key));
   }
 
+  hasAsync(key: K): Promise<boolean> {
+    return Promise.resolve(this.has(key));
+  }
+
   async set(key: K, val: V): Promise<void> {
     await this.db.put(this.#slot(key), [key, val]);
   }
@@ -109,18 +123,36 @@ export class LmdbAztecMap<K extends Key, V> implements AztecMultiMap<K, V> {
     }
   }
 
+  async *entriesAsync(range?: Range<K> | undefined): AsyncIterableIterator<[K, V]> {
+    for (const entry of this.entries(range)) {
+      yield entry;
+    }
+  }
+
   *values(range: Range<K> = {}): IterableIterator<V> {
     for (const [_, value] of this.entries(range)) {
       yield value;
     }
   }
 
+  async *valuesAsync(range: Range<K> = {}): AsyncIterableIterator<V> {
+    for await (const [_, value] of this.entriesAsync(range)) {
+      yield value;
+    }
+  }
+
   *keys(range: Range<K> = {}): IterableIterator<K> {
     for (const [key, _] of this.entries(range)) {
       yield key;
     }
   }
 
+  async *keysAsync(range: Range<K> = {}): AsyncIterableIterator<K> {
+    for await (const [key, _] of this.entriesAsync(range)) {
+      yield key;
+    }
+  }
+
   #slot(key: K): MapValueSlot<K> {
     return ['map', this.name, 'slot', key];
   }

package/src/lmdb/set.ts

@@ -1,13 +1,13 @@
 import { type Database } from 'lmdb';
 
 import { type Key, type Range } from '../interfaces/common.js';
-import { type AztecSet } from '../interfaces/set.js';
+import { type AztecAsyncSet, type AztecSet } from '../interfaces/set.js';
 import { LmdbAztecMap } from './map.js';
 
 /**
  * A set backed by LMDB.
  */
-export class LmdbAztecSet<K extends Key> implements AztecSet<K> {
+export class LmdbAztecSet<K extends Key> implements AztecSet<K>, AztecAsyncSet<K> {
   private map: LmdbAztecMap<K, boolean>;
   constructor(rootDb: Database, mapName: string) {
     this.map = new LmdbAztecMap(rootDb, mapName);
@@ -21,6 +21,10 @@ export class LmdbAztecSet<K extends Key> implements AztecSet<K> {
     return this.map.has(key);
   }
 
+  hasAsync(key: K): Promise<boolean> {
+    return Promise.resolve(this.has(key));
+  }
+
   add(key: K): Promise<void> {
     return this.map.set(key, true);
   }
@@ -32,4 +36,10 @@ export class LmdbAztecSet<K extends Key> implements AztecSet<K> {
   entries(range: Range<K> = {}): IterableIterator<K> {
     return this.map.keys(range);
   }
+
+  async *entriesAsync(range: Range<K> = {}): AsyncIterableIterator<K> {
+    for await (const key of this.map.keysAsync(range)) {
+      yield key;
+    }
+  }
 }

package/src/lmdb/singleton.ts

@@ -1,6 +1,6 @@
 import { type Database, type Key } from 'lmdb';
 
-import { type AztecSingleton } from '../interfaces/singleton.js';
+import { type AztecAsyncSingleton, type AztecSingleton } from '../interfaces/singleton.js';
 
 /** The slot where this singleton will store its value */
 type ValueSlot = ['singleton', string, 'value'];
@@ -8,7 +8,7 @@ type ValueSlot = ['singleton', string, 'value'];
 /**
  * Stores a single value in LMDB.
  */
-export class LmdbAztecSingleton<T> implements AztecSingleton<T> {
+export class LmdbAztecSingleton<T> implements AztecSingleton<T>, AztecAsyncSingleton<T> {
   #db: Database<T, ValueSlot>;
   #slot: ValueSlot;
 
@@ -21,6 +21,10 @@ export class LmdbAztecSingleton<T> implements AztecSingleton<T> {
     return this.#db.get(this.#slot);
   }
 
+  getAsync(): Promise<T | undefined> {
+    return Promise.resolve(this.get());
+  }
+
   set(val: T): Promise<boolean> {
     return this.#db.put(this.#slot, val);
   }

package/src/lmdb/store.ts

@@ -1,17 +1,17 @@
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 
-import { mkdirSync } from 'fs';
-import { mkdtemp, rm } from 'fs/promises';
-import { type Database, type Key, type RootDatabase, open } from 'lmdb';
+import { promises as fs, mkdirSync } from 'fs';
+import { type Database, type RootDatabase, open } from 'lmdb';
 import { tmpdir } from 'os';
 import { dirname, join } from 'path';
 
-import { type AztecArray } from '../interfaces/array.js';
-import { type AztecCounter } from '../interfaces/counter.js';
-import { type AztecMap, type AztecMultiMap } from '../interfaces/map.js';
-import { type AztecSet } from '../interfaces/set.js';
-import { type AztecSingleton } from '../interfaces/singleton.js';
-import { type AztecKVStore } from '../interfaces/store.js';
+import { type AztecArray, type AztecAsyncArray } from '../interfaces/array.js';
+import { type Key } from '../interfaces/common.js';
+import { type AztecAsyncCounter, type AztecCounter } from '../interfaces/counter.js';
+import { type AztecAsyncMap, type AztecAsyncMultiMap, type AztecMap, type AztecMultiMap } from '../interfaces/map.js';
+import { type AztecAsyncSet, type AztecSet } from '../interfaces/set.js';
+import { type AztecAsyncSingleton, type AztecSingleton } from '../interfaces/singleton.js';
+import { type AztecAsyncKVStore, type AztecKVStore } from '../interfaces/store.js';
 import { LmdbAztecArray } from './array.js';
 import { LmdbAztecCounter } from './counter.js';
 import { LmdbAztecMap } from './map.js';
@@ -21,11 +21,13 @@ import { LmdbAztecSingleton } from './singleton.js';
 /**
  * A key-value store backed by LMDB.
  */
-export class AztecLmdbStore implements AztecKVStore {
+export class AztecLmdbStore implements AztecKVStore, AztecAsyncKVStore {
+  syncGetters = true as const;
+
   #rootDb: RootDatabase;
   #data: Database<unknown, Key>;
   #multiMapData: Database<unknown, Key>;
-  #log = createDebugLogger('aztec:kv-store:lmdb');
+  #log = createLogger('kv-store:lmdb');
 
   constructor(rootDb: RootDatabase, public readonly isEphemeral: boolean, private path?: string) {
     this.#rootDb = rootDb;
@@ -60,7 +62,7 @@ export class AztecLmdbStore implements AztecKVStore {
     path?: string,
     mapSizeKb = 1 * 1024 * 1024, // defaults to 1 GB map size
     ephemeral: boolean = false,
-    log = createDebugLogger('aztec:kv-store:lmdb'),
+    log = createLogger('kv-store:lmdb'),
   ): AztecLmdbStore {
     if (path) {
       mkdirSync(path, { recursive: true });
@@ -79,7 +81,7 @@ export class AztecLmdbStore implements AztecKVStore {
     const baseDir = this.path ? dirname(this.path) : tmpdir();
     this.#log.debug(`Forking store with basedir ${baseDir}`);
     const forkPath =
-      (await mkdtemp(join(baseDir, 'aztec-store-fork-'))) + (this.isEphemeral || !this.path ? '/data.mdb' : '');
+      (await fs.mkdtemp(join(baseDir, 'aztec-store-fork-'))) + (this.isEphemeral || !this.path ? '/data.mdb' : '');
     this.#log.verbose(`Forking store to ${forkPath}`);
     await this.#rootDb.backup(forkPath, false);
     const forkDb = open(forkPath, { noSync: this.isEphemeral });
@@ -92,7 +94,7 @@ export class AztecLmdbStore implements AztecKVStore {
    * @param name - Name of the map
    * @returns A new AztecMap
    */
-  openMap<K extends string | number, V>(name: string): AztecMap<K, V> {
+  openMap<K extends Key, V>(name: string): AztecMap<K, V> & AztecAsyncMap<K, V> {
     return new LmdbAztecMap(this.#data, name);
   }
 
@@ -101,7 +103,7 @@ export class AztecLmdbStore implements AztecKVStore {
    * @param name - Name of the set
    * @returns A new AztecSet
    */
-  openSet<K extends string | number>(name: string): AztecSet<K> {
+  openSet<K extends Key>(name: string): AztecSet<K> & AztecAsyncSet<K> {
     return new LmdbAztecSet(this.#data, name);
   }
 
@@ -110,11 +112,11 @@ export class AztecLmdbStore implements AztecKVStore {
    * @param name - Name of the map
    * @returns A new AztecMultiMap
    */
-  openMultiMap<K extends string | number, V>(name: string): AztecMultiMap<K, V> {
+  openMultiMap<K extends Key, V>(name: string): AztecMultiMap<K, V> & AztecAsyncMultiMap<K, V> {
     return new LmdbAztecMap(this.#multiMapData, name);
   }
 
-  openCounter<K extends string | number | Array<string | number>>(name: string): AztecCounter<K> {
+  openCounter<K extends Key>(name: string): AztecCounter<K> & AztecAsyncCounter<K> {
     return new LmdbAztecCounter(this.#data, name);
   }
 
@@ -123,7 +125,7 @@ export class AztecLmdbStore implements AztecKVStore {
    * @param name - Name of the array
    * @returns A new AztecArray
    */
-  openArray<T>(name: string): AztecArray<T> {
+  openArray<T>(name: string): AztecArray<T> & AztecAsyncArray<T> {
     return new LmdbAztecArray(this.#data, name);
   }
 
@@ -132,7 +134,7 @@ export class AztecLmdbStore implements AztecKVStore {
    * @param name - Name of the singleton
    * @returns A new AztecSingleton
    */
-  openSingleton<T>(name: string): AztecSingleton<T> {
+  openSingleton<T>(name: string): AztecSingleton<T> & AztecAsyncSingleton<T> {
     return new LmdbAztecSingleton(this.#data, name);
   }
 
@@ -145,6 +147,15 @@ export class AztecLmdbStore implements AztecKVStore {
     return this.#rootDb.transaction(callback);
   }
 
+  /**
+   * Runs a callback in a transaction.
+   * @param callback - Function to execute in a transaction
+   * @returns A promise that resolves to the return value of the callback
+   */
+  async transactionAsync<T>(callback: () => Promise<T>): Promise<T> {
+    return await this.#rootDb.transaction(callback);
+  }
+
   /**
    * Clears all entries in the store & sub DBs.
    */
@@ -177,7 +188,7 @@ export class AztecLmdbStore implements AztecKVStore {
     await this.drop();
     await this.close();
     if (this.path) {
-      await rm(this.path, { recursive: true, force: true });
+      await fs.rm(this.path, { recursive: true, force: true });
       this.#log.verbose(`Deleted database files at ${this.path}`);
     }
   }
@@ -201,11 +212,7 @@ export class AztecLmdbStore implements AztecKVStore {
 
   private estimateSubDBSize(db: Database<unknown, Key>): { actualSize: number; numItems: number } {
     const stats = db.getStats();
-    let branchPages = 0;
-    let leafPages = 0;
-    let overflowPages = 0;
-    let pageSize = 0;
-    let totalSize = 0;
+    let actualSize = 0;
     let numItems = 0;
     // This is the total number of key/value pairs present in the DB
     if ('entryCount' in stats && typeof stats.entryCount === 'number') {
@@ -222,12 +229,12 @@ export class AztecLmdbStore implements AztecKVStore {
       'pageSize' in stats &&
       typeof stats.pageSize === 'number'
     ) {
-      branchPages = stats.treeBranchPageCount;
-      leafPages = stats.treeLeafPageCount;
-      overflowPages = stats.overflowPages;
-      pageSize = stats.pageSize;
-      totalSize = (branchPages + leafPages + overflowPages) * pageSize;
+      const branchPages = stats.treeBranchPageCount;
+      const leafPages = stats.treeLeafPageCount;
+      const overflowPages = stats.overflowPages;
+      const pageSize = stats.pageSize;
+      actualSize = (branchPages + leafPages + overflowPages) * pageSize;
     }
-    return { actualSize: totalSize, numItems };
+    return { actualSize, numItems };
   }
 }

package/src/stores/l2_tips_store.ts

@@ -7,37 +7,37 @@ import {
   type L2Tips,
 } from '@aztec/circuit-types';
 
-import { type AztecMap } from '../interfaces/map.js';
-import { type AztecKVStore } from '../interfaces/store.js';
+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: AztecMap<L2BlockTag, number>;
-  private readonly l2BlockHashesStore: AztecMap<number, string>;
+  private readonly l2TipsStore: AztecAsyncMap<L2BlockTag, number>;
+  private readonly l2BlockHashesStore: AztecAsyncMap<number, string>;
 
-  constructor(store: AztecKVStore, namespace: 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 Promise.resolve(this.l2BlockHashesStore.get(number));
+    return this.l2BlockHashesStore.getAsync(number);
   }
 
-  public getL2Tips(): Promise<L2Tips> {
-    return Promise.resolve({
-      latest: this.getL2Tip('latest'),
-      finalized: this.getL2Tip('finalized'),
-      proven: this.getL2Tip('proven'),
-    });
+  public async getL2Tips(): Promise<L2Tips> {
+    return {
+      latest: await this.getL2Tip('latest'),
+      finalized: await this.getL2Tip('finalized'),
+      proven: await this.getL2Tip('proven'),
+    };
   }
 
-  private getL2Tip(tag: L2BlockTag): L2BlockId {
-    const blockNumber = this.l2TipsStore.get(tag);
+  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 = this.l2BlockHashesStore.get(blockNumber);
+    const blockHash = await this.l2BlockHashesStore.getAsync(blockNumber);
     if (!blockHash) {
       throw new Error(`Block hash not found for block number ${blockNumber}`);
     }
@@ -60,7 +60,7 @@ export class L2TipsStore implements L2BlockStreamEventHandler, L2BlockStreamLoca
         break;
       case 'chain-finalized':
         await this.l2TipsStore.set('finalized', event.blockNumber);
-        for (const key of this.l2BlockHashesStore.keys({ end: event.blockNumber })) {
+        for await (const key of this.l2BlockHashesStore.keysAsync({ end: event.blockNumber })) {
           await this.l2BlockHashesStore.delete(key);
         }
         break;

package/src/utils.ts

@@ -1,29 +1,9 @@
 import { type EthAddress } from '@aztec/foundation/eth-address';
-import { type Logger, createDebugLogger } from '@aztec/foundation/log';
+import { type Logger } from '@aztec/foundation/log';
 
-import { join } from 'path';
-
-import { type DataStoreConfig } from './config.js';
-import { type AztecKVStore } from './interfaces/store.js';
-import { AztecLmdbStore } from './lmdb/store.js';
-
-export function createStore(name: string, config: DataStoreConfig, log: Logger = createDebugLogger('aztec:kv-store')) {
-  let { dataDirectory } = config;
-  if (typeof dataDirectory !== 'undefined') {
-    dataDirectory = join(dataDirectory, name);
-  }
-
-  log.info(
-    dataDirectory
-      ? `Creating ${name} data store at directory ${dataDirectory} with map size ${config.dataStoreMapSizeKB} KB`
-      : `Creating ${name} ephemeral data store with map size ${config.dataStoreMapSizeKB} KB`,
-  );
-  return initStoreForRollup(
-    AztecLmdbStore.open(dataDirectory, config.dataStoreMapSizeKB, false),
-    config.l1Contracts.rollupAddress,
-    log,
-  );
-}
+import { type AztecAsyncSingleton, type AztecSingleton } from './interfaces/singleton.js';
+import { type AztecAsyncKVStore, type 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.
@@ -32,7 +12,7 @@ export function createStore(name: string, config: DataStoreConfig, log: Logger =
  * @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
  */
-async function initStoreForRollup<T extends AztecKVStore>(
+export async function initStoreForRollup<T extends AztecKVStore | AztecAsyncKVStore>(
   store: T,
   rollupAddress: EthAddress,
   log?: Logger,
@@ -42,7 +22,9 @@ async function initStoreForRollup<T extends AztecKVStore>(
   }
   const rollupAddressValue = store.openSingleton<ReturnType<EthAddress['toString']>>('rollupAddress');
   const rollupAddressString = rollupAddress.toString();
-  const storedRollupAddressString = rollupAddressValue.get();
+  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...`, {
@@ -56,13 +38,3 @@ async function initStoreForRollup<T extends AztecKVStore>(
   await rollupAddressValue.set(rollupAddressString);
   return store;
 }
-
-/**
- * Opens a temporary store for testing purposes.
- * @param ephemeral - true if the store should only exist in memory and not automatically be flushed to disk. Optional
- * @returns A new store
- */
-export function openTmpStore(ephemeral: boolean = false): AztecLmdbStore {
-  const mapSize = 1024 * 1024 * 10; // 10 GB map size
-  return AztecLmdbStore.open(undefined, mapSize, ephemeral);
-}