@aztec/kv-store 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/dest/stores/l2_tips_store.d.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import type { L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider, L2Tips } from '@aztec/stdlib/block';
 import type { AztecAsyncKVStore } from '../interfaces/store.js';
 /** Stores currently synced L2 tips and unfinalized block hashes. */
@@ -5,10 +6,10 @@ export declare class L2TipsKVStore implements L2BlockStreamEventHandler, L2Block
     private readonly l2TipsStore;
     private readonly l2BlockHashesStore;
     constructor(store: AztecAsyncKVStore, namespace: string);
-    getL2BlockHash(number: number): Promise<string | undefined>;
+    getL2BlockHash(number: BlockNumber): Promise<string | undefined>;
     getL2Tips(): Promise<L2Tips>;
     private getL2Tip;
     handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void>;
     private saveTag;
 }
-//# sourceMappingURL=l2_tips_store.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDJfdGlwc19zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N0b3Jlcy9sMl90aXBzX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUM5RCxPQUFPLEtBQUssRUFFVixrQkFBa0IsRUFDbEIseUJBQXlCLEVBQ3pCLDhCQUE4QixFQUU5QixNQUFNLEVBQ1AsTUFBTSxxQkFBcUIsQ0FBQztBQUc3QixPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRWhFLG9FQUFvRTtBQUNwRSxxQkFBYSxhQUFjLFlBQVcseUJBQXlCLEVBQUUsOEJBQThCO0lBQzdGLE9BQU8sQ0FBQyxRQUFRLENBQUMsV0FBVyxDQUF5QztJQUNyRSxPQUFPLENBQUMsUUFBUSxDQUFDLGtCQUFrQixDQUFxQztJQUV4RSxZQUFZLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUd0RDtJQUVNLGNBQWMsQ0FBQyxNQUFNLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBRXRFO0lBRVksU0FBUyxJQUFJLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FNeEM7WUFFYSxRQUFRO0lBYVQsc0JBQXNCLENBQUMsS0FBSyxFQUFFLGtCQUFrQixHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0F1QjVFO1lBRWEsT0FBTztDQU10QiJ9

package/dest/stores/l2_tips_store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"l2_tips_store.d.ts","sourceRoot":"","sources":["../../src/stores/l2_tips_store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,kBAAkB,EAClB,yBAAyB,EACzB,8BAA8B,EAE9B,MAAM,EACP,MAAM,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,oEAAoE;AACpE,qBAAa,aAAc,YAAW,yBAAyB,EAAE,8BAA8B;IAC7F,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoC;IAChE,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAgC;gBAEvD,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM;IAKhD,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAIrD,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;YAQ3B,QAAQ;IAaT,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;YAyB/D,OAAO;CAMtB"}
+{"version":3,"file":"l2_tips_store.d.ts","sourceRoot":"","sources":["../../src/stores/l2_tips_store.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,KAAK,EAEV,kBAAkB,EAClB,yBAAyB,EACzB,8BAA8B,EAE9B,MAAM,EACP,MAAM,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,oEAAoE;AACpE,qBAAa,aAAc,YAAW,yBAAyB,EAAE,8BAA8B;IAC7F,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyC;IACrE,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAqC;IAExE,YAAY,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,EAGtD;IAEM,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAEtE;IAEY,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAMxC;YAEa,QAAQ;IAaT,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB5E;YAEa,OAAO;CAMtB"}

package/dest/stores/l2_tips_store.js

@@ -1,3 +1,5 @@
+import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 /** Stores currently synced L2 tips and unfinalized block hashes. */ export class L2TipsKVStore {
     l2TipsStore;
     l2BlockHashesStore;
@@ -25,8 +27,8 @@
         const blockNumber = await this.l2TipsStore.getAsync(tag);
         if (blockNumber === undefined || blockNumber === 0) {
             return {
-                number: 0,
-                hash: undefined
+                number: BlockNumber.ZERO,
+                hash: GENESIS_BLOCK_HEADER_HASH.toString()
             };
         }
         const blockHash = await this.l2BlockHashesStore.getAsync(blockNumber);
@@ -44,7 +46,7 @@
                 {
                     const blocks = event.blocks.map((b)=>b.block);
                     for (const block of blocks){
-                        await this.l2BlockHashesStore.set(block.number, (await block.header.hash()).toString());
+                        await this.l2BlockHashesStore.set(block.number, (await block.hash()).toString());
                     }
                     await this.l2TipsStore.set('latest', blocks.at(-1).number);
                     break;

package/dest/utils.d.ts

@@ -9,4 +9,4 @@ import type { AztecAsyncKVStore, AztecKVStore } from './interfaces/store.js';
  * @returns A promise that resolves when the store is cleared, or rejects if the rollup address does not match
  */
 export declare function initStoreForRollup<T extends AztecKVStore | AztecAsyncKVStore>(store: T, rollupAddress: EthAddress, log?: Logger): Promise<T>;
-//# sourceMappingURL=utils.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUdwRCxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxZQUFZLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUc3RTs7Ozs7O0dBTUc7QUFDSCx3QkFBc0Isa0JBQWtCLENBQUMsQ0FBQyxTQUFTLFlBQVksR0FBRyxpQkFBaUIsRUFDakYsS0FBSyxFQUFFLENBQUMsRUFDUixhQUFhLEVBQUUsVUFBVSxFQUN6QixHQUFHLENBQUMsRUFBRSxNQUFNLEdBQ1gsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQXFCWiJ9

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@aztec/kv-store",
-  "version": "4.0.0-nightly.20250907",
+  "version": "4.0.0-nightly.20260108",
   "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",
@@ -11,8 +12,8 @@
     "./config": "./dest/config.js"
   },
   "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",
@@ -24,10 +25,11 @@
     "./package.local.json"
   ],
   "dependencies": {
-    "@aztec/ethereum": "4.0.0-nightly.20250907",
-    "@aztec/foundation": "4.0.0-nightly.20250907",
-    "@aztec/native": "4.0.0-nightly.20250907",
-    "@aztec/stdlib": "4.0.0-nightly.20250907",
+    "@aztec/constants": "4.0.0-nightly.20260108",
+    "@aztec/ethereum": "4.0.0-nightly.20260108",
+    "@aztec/foundation": "4.0.0-nightly.20260108",
+    "@aztec/native": "4.0.0-nightly.20260108",
+    "@aztec/stdlib": "4.0.0-nightly.20260108",
     "idb": "^8.0.0",
     "lmdb": "^3.2.0",
     "msgpackr": "^1.11.2",
@@ -43,6 +45,7 @@
     "@types/mocha-each": "^2.0.4",
     "@types/node": "^22.15.17",
     "@types/sinon": "^17.0.3",
+    "@typescript/native-preview": "7.0.0-dev.20251126.1",
     "@web/dev-server-esbuild": "^1.0.3",
     "@web/test-runner": "^0.19.0",
     "@web/test-runner-playwright": "^0.11.0",

package/src/config.ts

@@ -4,7 +4,7 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 
 export type DataStoreConfig = {
   dataDirectory: string | undefined;
-  dataStoreMapSizeKB: number;
+  dataStoreMapSizeKb: number;
   l1Contracts?: { rollupAddress: EthAddress };
 };
 
@@ -13,9 +13,9 @@ export const dataConfigMappings: ConfigMappingsType<DataStoreConfig> = {
     env: 'DATA_DIRECTORY',
     description: 'Optional dir to store data. If omitted will store in memory.',
   },
-  dataStoreMapSizeKB: {
+  dataStoreMapSizeKb: {
     env: 'DATA_STORE_MAP_SIZE_KB',
-    description: 'DB mapping size to be applied to all key/value stores',
+    description: 'The maximum possible size of a data store DB in KB. Can be overridden by component-specific options.',
     ...numberConfigHelper(128 * 1_024 * 1_024), // Defaulted to 128 GB
   },
   l1Contracts: {

package/src/indexeddb/index.ts

@@ -14,8 +14,8 @@ export async function createStore(name: string, config: DataStoreConfig, log: Lo
 
   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`,
+      ? `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 = await AztecIndexedDBStore.open(createLogger('kv-store:indexeddb'), dataDirectory ?? '', false);
   if (config.l1Contracts?.rollupAddress) {

package/src/indexeddb/multi_map.ts

@@ -61,6 +61,18 @@ export class IndexedDBAztecMultiMap<K extends Key, V extends Value>
     }
   }
 
+  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

package/src/interfaces/multi_map.ts

@@ -29,6 +29,13 @@ export interface AztecAsyncMultiMap<K extends Key, V extends Value> extends Azte
    */
   getValuesAsync(key: K): AsyncIterableIterator<V>;
 
+  /**
+   * Gets the number of values at the given key.
+   * @param key - The key to get the number of values from
+   * @returns The number of values at the given key
+   */
+  getValueCountAsync(key: K): Promise<number>;
+
   /**
    * Deletes a specific value at the given key.
    * @param key - The key to delete the value at

package/src/interfaces/multi_map_test_suite.ts

@@ -61,6 +61,13 @@ export function describeAztecMultiMap(
         : await toArray((multiMap as AztecAsyncMultiMap<any, any>).getValuesAsync(key));
     }
 
+    async function getValueCount(
+      key: Key,
+      sut: AztecAsyncMultiMap<any, any> | AztecMultiMap<any, any> = multiMap,
+    ): Promise<number> {
+      return await (sut as AztecAsyncMultiMap<any, any>).getValueCountAsync(key);
+    }
+
     it('should be able to set and get values', async () => {
       await multiMap.set('foo', 'bar');
       await multiMap.set('baz', 'qux');
@@ -238,5 +245,98 @@ export function describeAztecMultiMap(
       expect(await keys({ start: 'b', reverse: true })).to.deep.equal(['d', 'c']);
       expect(await keys({ end: 'b', reverse: true })).to.deep.equal(['b', 'a']);
     });
+
+    it('returns 0 for missing key', async () => {
+      expect(await getValueCount('missing')).to.equal(0);
+    });
+
+    it('counts a single value', async () => {
+      await multiMap.set('foo', 'bar');
+      expect(await getValueCount('foo')).to.equal(1);
+    });
+
+    it('counts multiple distinct values for same key', async () => {
+      await multiMap.set('foo', 'bar');
+      await multiMap.set('foo', 'baz');
+      await multiMap.set('foo', 'qux');
+      expect(await getValueCount('foo')).to.equal(3);
+    });
+
+    it('does not increase count for duplicate inserts', async () => {
+      await multiMap.set('foo', 'bar');
+      await multiMap.set('foo', 'bar');
+      await multiMap.set('foo', 'baz');
+      await multiMap.set('foo', 'baz');
+      expect(await getValueCount('foo')).to.equal(2);
+      expect(await getValues('foo')).to.have.members(['bar', 'baz']);
+    });
+
+    it('decrements when deleting a single value', async () => {
+      await multiMap.set('foo', '1');
+      await multiMap.set('foo', '2');
+      await multiMap.set('foo', '3');
+      expect(await getValueCount('foo')).to.equal(3);
+      await multiMap.deleteValue('foo', '2');
+      expect(await getValueCount('foo')).to.equal(2);
+      expect(await getValues('foo')).to.have.members(['1', '3']);
+    });
+
+    it('does not change count when deleting a non-existent value', async () => {
+      await multiMap.set('foo', '1');
+      await multiMap.set('foo', '3');
+      expect(await getValueCount('foo')).to.equal(2);
+      await multiMap.deleteValue('foo', '2');
+      expect(await getValueCount('foo')).to.equal(2);
+    });
+
+    it('clears all values when deleting a key', async () => {
+      await multiMap.set('foo', 'bar');
+      await multiMap.set('foo', 'baz');
+      expect(await getValueCount('foo')).to.equal(2);
+      await multiMap.delete('foo');
+      expect(await getValueCount('foo')).to.equal(0);
+      expect(await getValues('foo')).to.deep.equal([]);
+    });
+
+    it('count equals enumerated values length', async () => {
+      await multiMap.set('foo', '1');
+      await multiMap.set('foo', '2');
+      const vals = await getValues('foo');
+      expect(await getValueCount('foo')).to.equal(vals.length);
+    });
+
+    it('sum of per-key counts equals total size', async () => {
+      await multiMap.set('foo', '1');
+      await multiMap.set('foo', '2');
+      await multiMap.set('bar', '3');
+      await multiMap.set('bar', '4');
+      await multiMap.set('baz', '5');
+
+      const allKeys = await keys();
+      const uniqueKeys = Array.from(new Set(allKeys));
+      const counts = await Promise.all(uniqueKeys.map(k => getValueCount(k)));
+      const sum = counts.reduce((s, n) => s + n, 0);
+      expect(sum).to.equal(await size());
+    });
+
+    it('supports sparse slots: delete middle, reinsert new, count remains correct', async () => {
+      await multiMap.set('foo', '1');
+      await multiMap.set('foo', '2');
+      await multiMap.set('foo', '3');
+      expect(await getValueCount('foo')).to.equal(3);
+      await multiMap.deleteValue('foo', '2');
+      expect(await getValueCount('foo')).to.equal(2);
+      await multiMap.set('foo', '4');
+      expect(await getValueCount('foo')).to.equal(3);
+      expect(await getValues('foo')).to.have.members(['1', '3', '4']);
+    });
+
+    it('multiple keys are independent', async () => {
+      await multiMap.set('foo', '1');
+      await multiMap.set('foo', '2');
+      await multiMap.set('bar', '3');
+      expect(await getValueCount('foo')).to.equal(2);
+      expect(await getValueCount('bar')).to.equal(1);
+    });
   });
 }

package/src/lmdb/index.ts

@@ -16,11 +16,11 @@ export function createStore(name: string, config: DataStoreConfig, log: Logger =
 
   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`,
+      ? `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);
+  const store = AztecLmdbStore.open(dataDirectory, config.dataStoreMapSizeKb, false);
   if (config.l1Contracts?.rollupAddress) {
     return initStoreForRollup(store, config.l1Contracts.rollupAddress, log);
   }

package/src/lmdb/multi_map.ts

@@ -29,6 +29,22 @@ export class LmdbAztecMultiMap<K extends Key, V extends Value>
     }
   }
 
+  getValueCountAsync(key: K): Promise<number> {
+    const transaction = this.db.useReadTransaction();
+    try {
+      const values = this.db.getValues(this.slot(key), {
+        transaction,
+      });
+      let count = 0;
+      for (const _ of values) {
+        count++;
+      }
+      return Promise.resolve(count);
+    } finally {
+      transaction.done();
+    }
+  }
+
   async deleteValue(key: K, val: V): Promise<void> {
     await this.db.remove(this.slot(key), [key, val]);
   }

package/src/lmdb/store.ts

@@ -1,4 +1,4 @@
-import { randomBytes } from '@aztec/foundation/crypto';
+import { randomBytes } from '@aztec/foundation/crypto/random';
 import { createLogger } from '@aztec/foundation/log';
 
 import { promises as fs, mkdirSync } from 'fs';

package/src/lmdb-v2/factory.ts

@@ -33,15 +33,15 @@ export async function createStore(
       rollupAddress,
       dataDirectory: subDir,
       onOpen: dbDirectory =>
-        AztecLMDBStoreV2.new(dbDirectory, config.dataStoreMapSizeKB, MAX_READERS, () => Promise.resolve(), log),
+        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;

package/src/lmdb-v2/multi_map.ts

@@ -1,8 +1,10 @@
 import { Encoder } from 'msgpackr/pack';
+import { MAXIMUM_KEY, toBufferKey } from 'ordered-binary';
 
 import type { Key, Range, Value } from '../interfaces/common.js';
 import type { AztecAsyncMultiMap } from '../interfaces/multi_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';
 
@@ -138,4 +140,11 @@ export class LMDBMultiMap<K extends Key, V extends Value> implements AztecAsyncM
       yield this.encoder.unpack(value);
     }
   }
+
+  getValueCountAsync(key: K): Promise<number> {
+    const startKey = serializeKey(this.prefix, key);
+    const endKey = toBufferKey([this.prefix, key, MAXIMUM_KEY]);
+
+    return execInReadTx(this.store, tx => tx.countEntriesIndex(startKey, endKey, false));
+  }
 }

package/src/lmdb-v2/utils.ts

@@ -2,124 +2,6 @@ import { MAXIMUM_KEY, fromBufferKey, toBufferKey } from 'ordered-binary';
 
 import type { Key } from '../interfaces/common.js';
 
-type Cmp<T> = (a: T, b: T) => -1 | 0 | 1;
-
-export function dedupeSortedArray<T>(arr: T[], cmp: Cmp<T>): void {
-  for (let i = 0; i < arr.length; i++) {
-    let j = i + 1;
-    for (; j < arr.length; j++) {
-      const res = cmp(arr[i], arr[j]);
-      if (res === 0) {
-        continue;
-      } else if (res < 0) {
-        break;
-      } else {
-        throw new Error('Array not sorted');
-      }
-    }
-
-    if (j - i > 1) {
-      arr.splice(i + 1, j - i - 1);
-    }
-  }
-}
-
-export function insertIntoSortedArray<T>(arr: T[], item: T, cmp: (a: T, b: T) => number): void {
-  let left = 0;
-  let right = arr.length;
-
-  while (left < right) {
-    const mid = (left + right) >> 1;
-    const comparison = cmp(arr[mid], item);
-
-    if (comparison < 0) {
-      left = mid + 1;
-    } else {
-      right = mid;
-    }
-  }
-
-  arr.splice(left, 0, item);
-}
-
-export function findIndexInSortedArray<T, N>(values: T[], needle: N, cmp: (a: T, b: N) => number): number {
-  let start = 0;
-  let end = values.length - 1;
-
-  while (start <= end) {
-    const mid = start + (((end - start) / 2) | 0);
-    const res = cmp(values[mid], needle);
-    if (res === 0) {
-      return mid;
-    } else if (res > 0) {
-      end = mid - 1;
-    } else {
-      start = mid + 1;
-    }
-  }
-
-  return -1;
-}
-
-export function findInSortedArray<T, N>(values: T[], needle: N, cmp: (a: T, b: N) => number): T | undefined {
-  const idx = findIndexInSortedArray(values, needle, cmp);
-  return idx > -1 ? values[idx] : undefined;
-}
-
-export function removeAnyOf<T, N>(arr: T[], vals: N[], cmp: (a: T, b: N) => -1 | 0 | 1): void {
-  let writeIdx = 0;
-  let readIdx = 0;
-  let valIdx = 0;
-
-  while (readIdx < arr.length && valIdx < vals.length) {
-    const comparison = cmp(arr[readIdx], vals[valIdx]);
-
-    if (comparison < 0) {
-      arr[writeIdx++] = arr[readIdx++];
-    } else if (comparison > 0) {
-      valIdx++;
-    } else {
-      readIdx++;
-    }
-  }
-
-  while (readIdx < arr.length) {
-    arr[writeIdx++] = arr[readIdx++];
-  }
-
-  arr.length = writeIdx;
-}
-
-export function removeFromSortedArray<T, N>(arr: T[], val: N, cmp: (a: T, b: N) => -1 | 0 | 1) {
-  const idx = findIndexInSortedArray(arr, val, cmp);
-  if (idx > -1) {
-    arr.splice(idx, 1);
-  }
-}
-
-export function merge<T>(arr: T[], toInsert: T[], cmp: (a: T, b: T) => -1 | 0 | 1): void {
-  const result = new Array<T>(arr.length + toInsert.length);
-  let i = 0,
-    j = 0,
-    k = 0;
-
-  while (i < arr.length && j < toInsert.length) {
-    result[k++] = cmp(arr[i], toInsert[j]) <= 0 ? arr[i++] : toInsert[j++];
-  }
-
-  while (i < arr.length) {
-    result[k++] = arr[i++];
-  }
-  while (j < toInsert.length) {
-    result[k++] = toInsert[j++];
-  }
-
-  for (i = 0; i < result.length; i++) {
-    arr[i] = result[i];
-  }
-  arr.length = result.length;
-}
-
 export function keyCmp(a: [Uint8Array, Uint8Array[] | null], b: [Uint8Array, Uint8Array[] | null]): -1 | 0 | 1 {
   return Buffer.compare(a[0], b[0]);
 }

package/src/lmdb-v2/write_transaction.ts

@@ -1,16 +1,16 @@
-import { type Batch, Database, LMDBMessageType } from './message.js';
-import { ReadTransaction } from './read_transaction.js';
 import {
   dedupeSortedArray,
   findInSortedArray,
   findIndexInSortedArray,
   insertIntoSortedArray,
-  keyCmp,
   merge,
   removeAnyOf,
   removeFromSortedArray,
-  singleKeyCmp,
-} from './utils.js';
+} from '@aztec/foundation/array';
+
+import { type Batch, Database, LMDBMessageType } from './message.js';
+import { ReadTransaction } from './read_transaction.js';
+import { keyCmp, singleKeyCmp } from './utils.js';
 
 export class WriteTransaction extends ReadTransaction {
   // exposed for tests
@@ -44,7 +44,7 @@ export class WriteTransaction extends ReadTransaction {
   remove(key: Uint8Array): Promise<void> {
     const removeEntryIndex = findIndexInSortedArray(this.dataBatch.removeEntries, key, singleKeyCmp);
     if (removeEntryIndex === -1) {
-      this.dataBatch.removeEntries.push([key, null]);
+      insertIntoSortedArray(this.dataBatch.removeEntries, [key, null], keyCmp);
     }
 
     const addEntryIndex = findIndexInSortedArray(this.dataBatch.addEntries, key, singleKeyCmp);
@@ -218,8 +218,9 @@ export class WriteTransaction extends ReadTransaction {
   ): AsyncIterable<[Uint8Array, T]> {
     this.assertIsOpen();
 
-    // make a copy of this in case we're running in reverse
+    // Snapshot both add and remove entries at the start of iteration to ensure consistency
     const uncommittedEntries = [...batch.addEntries];
+    const removeEntries = [...batch.removeEntries];
     // used to check we're in the right order when comparing between a key and uncommittedEntries
     let cmpDirection = -1;
     if (reverse) {
@@ -262,7 +263,7 @@ export class WriteTransaction extends ReadTransaction {
         break;
       }
 
-      const toRemove = findInSortedArray(batch.removeEntries, key, singleKeyCmp);
+      const toRemove = findInSortedArray(removeEntries, key, singleKeyCmp);
 
       // at this point we've either exhausted all uncommitted entries,
       // we reached a key strictly greater/smaller than `key`

package/src/stores/l2_tips_store.ts

@@ -1,3 +1,5 @@
+import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import type {
   L2BlockId,
   L2BlockStreamEvent,
@@ -12,15 +14,15 @@ import type { AztecAsyncKVStore } from '../interfaces/store.js';
 
 /** Stores currently synced L2 tips and unfinalized block hashes. */
 export class L2TipsKVStore implements L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider {
-  private readonly l2TipsStore: AztecAsyncMap<L2BlockTag, number>;
-  private readonly l2BlockHashesStore: AztecAsyncMap<number, string>;
+  private readonly l2TipsStore: AztecAsyncMap<L2BlockTag, BlockNumber>;
+  private readonly l2BlockHashesStore: AztecAsyncMap<BlockNumber, 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> {
+  public getL2BlockHash(number: BlockNumber): Promise<string | undefined> {
     return this.l2BlockHashesStore.getAsync(number);
   }
 
@@ -35,7 +37,7 @@ export class L2TipsKVStore implements L2BlockStreamEventHandler, L2BlockStreamLo
   private async getL2Tip(tag: L2BlockTag): Promise<L2BlockId> {
     const blockNumber = await this.l2TipsStore.getAsync(tag);
     if (blockNumber === undefined || blockNumber === 0) {
-      return { number: 0, hash: undefined };
+      return { number: BlockNumber.ZERO, hash: GENESIS_BLOCK_HEADER_HASH.toString() };
     }
     const blockHash = await this.l2BlockHashesStore.getAsync(blockNumber);
     if (!blockHash) {
@@ -50,7 +52,7 @@ export class L2TipsKVStore implements L2BlockStreamEventHandler, L2BlockStreamLo
       case 'blocks-added': {
         const blocks = event.blocks.map(b => b.block);
         for (const block of blocks) {
-          await this.l2BlockHashesStore.set(block.number, (await block.header.hash()).toString());
+          await this.l2BlockHashesStore.set(block.number, (await block.hash()).toString());
         }
         await this.l2TipsStore.set('latest', blocks.at(-1)!.number);
         break;