@aztec/kv-store 0.72.1 → 0.73.0

package/dest/lmdb-v2/store.js

@@ -0,0 +1,156 @@
+import { createLogger } from '@aztec/foundation/log';
+import { Semaphore, SerialQueue } from '@aztec/foundation/queue';
+import { MsgpackChannel, NativeLMDBStore } from '@aztec/native';
+import { AsyncLocalStorage } from 'async_hooks';
+import { rm } from 'fs/promises';
+import { LMDBMap, LMDBMultiMap } from './map.js';
+import { Database, LMDBMessageType, } from './message.js';
+import { ReadTransaction } from './read_transaction.js';
+import { LMDBSingleValue } from './singleton.js';
+import { WriteTransaction } from './write_transaction.js';
+export class AztecLMDBStoreV2 {
+    constructor(dataDir, mapSize, maxReaders, log, cleanup) {
+        this.dataDir = dataDir;
+        this.log = log;
+        this.cleanup = cleanup;
+        this.writerCtx = new AsyncLocalStorage();
+        this.writerQueue = new SerialQueue();
+        this.log.info(`Starting data store with maxReaders ${maxReaders}`);
+        this.channel = new MsgpackChannel(new NativeLMDBStore(dataDir, mapSize, maxReaders));
+        // leave one reader to always be available for regular, atomic, reads
+        this.availableCursors = new Semaphore(maxReaders - 1);
+    }
+    async start() {
+        this.writerQueue.start();
+        await this.sendMessage(LMDBMessageType.OPEN_DATABASE, {
+            db: Database.DATA,
+            uniqueKeys: true,
+        });
+        await this.sendMessage(LMDBMessageType.OPEN_DATABASE, {
+            db: Database.INDEX,
+            uniqueKeys: false,
+        });
+    }
+    static async new(dataDir, dbMapSizeKb = 10 * 1024 * 1024, maxReaders = 16, cleanup, log = createLogger('kv-store:lmdb-v2')) {
+        const db = new AztecLMDBStoreV2(dataDir, dbMapSizeKb, maxReaders, log, cleanup);
+        await db.start();
+        return db;
+    }
+    getReadTx() {
+        return new ReadTransaction(this);
+    }
+    getCurrentWriteTx() {
+        const currentWrite = this.writerCtx.getStore();
+        return currentWrite;
+    }
+    openMap(name) {
+        return new LMDBMap(this, name);
+    }
+    openMultiMap(name) {
+        return new LMDBMultiMap(this, name);
+    }
+    openSingleton(name) {
+        return new LMDBSingleValue(this, name);
+    }
+    openArray(_name) {
+        throw new Error('Not implemented');
+    }
+    openSet(_name) {
+        throw new Error('Not implemented');
+    }
+    openCounter(_name) {
+        throw new Error('Not implemented');
+    }
+    async transactionAsync(callback) {
+        // transactionAsync might be called recursively
+        // send any writes to the parent tx, but don't close it
+        // if the callback throws then the parent tx will rollback automatically
+        const currentTx = this.getCurrentWriteTx();
+        if (currentTx) {
+            return await callback(currentTx);
+        }
+        return this.writerQueue.put(async () => {
+            const tx = new WriteTransaction(this);
+            try {
+                const res = await this.writerCtx.run(tx, callback, tx);
+                await tx.commit();
+                return res;
+            }
+            catch (err) {
+                this.log.error(`Failed to commit transaction`, err);
+                throw err;
+            }
+            finally {
+                tx.close();
+            }
+        });
+    }
+    clear() {
+        return Promise.resolve();
+    }
+    fork() {
+        throw new Error('Not implemented');
+    }
+    async delete() {
+        await this.close();
+        await rm(this.dataDir, { recursive: true, force: true });
+        this.log.verbose(`Deleted database files at ${this.dataDir}`);
+        await this.cleanup?.();
+    }
+    async close() {
+        await this.writerQueue.cancel();
+        await this.sendMessage(LMDBMessageType.CLOSE, undefined);
+    }
+    async sendMessage(msgType, body) {
+        if (msgType === LMDBMessageType.START_CURSOR) {
+            await this.availableCursors.acquire();
+        }
+        let response = undefined;
+        try {
+            ({ response } = await this.channel.sendMessage(msgType, body));
+            return response;
+        }
+        finally {
+            if ((msgType === LMDBMessageType.START_CURSOR && response === undefined) ||
+                msgType === LMDBMessageType.CLOSE_CURSOR ||
+                // it's possible for a START_CURSOR command to not return a cursor (e.g. db is empty)
+                (msgType === LMDBMessageType.START_CURSOR &&
+                    typeof response.cursor !== 'number')) {
+                this.availableCursors.release();
+            }
+        }
+    }
+    async estimateSize() {
+        const resp = await this.sendMessage(LMDBMessageType.STATS, undefined);
+        return {
+            mappingSize: Number(resp.dbMapSizeBytes),
+            actualSize: resp.stats.reduce((s, db) => Number(db.totalUsedSize) + s, 0),
+            numItems: resp.stats.reduce((s, db) => Number(db.numDataItems) + s, 0),
+        };
+    }
+}
+export function execInWriteTx(store, fn) {
+    const currentWrite = store.getCurrentWriteTx();
+    if (currentWrite) {
+        return fn(currentWrite);
+    }
+    else {
+        return store.transactionAsync(fn);
+    }
+}
+export async function execInReadTx(store, fn) {
+    const currentWrite = store.getCurrentWriteTx();
+    if (currentWrite) {
+        return await fn(currentWrite);
+    }
+    else {
+        const tx = store.getReadTx();
+        try {
+            return await fn(tx);
+        }
+        finally {
+            tx.close();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/lmdb-v2/utils.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { type Key } from '../interfaces/common.js';
+type Cmp<T> = (a: T, b: T) => -1 | 0 | 1;
+export declare function dedupeSortedArray<T>(arr: T[], cmp: Cmp<T>): void;
+export declare function insertIntoSortedArray<T>(arr: T[], item: T, cmp: (a: T, b: T) => number): void;
+export declare function findIndexInSortedArray<T, N>(values: T[], needle: N, cmp: (a: T, b: N) => number): number;
+export declare function findInSortedArray<T, N>(values: T[], needle: N, cmp: (a: T, b: N) => number): T | undefined;
+export declare function removeAnyOf<T, N>(arr: T[], vals: N[], cmp: (a: T, b: N) => -1 | 0 | 1): void;
+export declare function removeFromSortedArray<T, N>(arr: T[], val: N, cmp: (a: T, b: N) => -1 | 0 | 1): void;
+export declare function merge<T>(arr: T[], toInsert: T[], cmp: (a: T, b: T) => -1 | 0 | 1): void;
+export declare function keyCmp(a: [Uint8Array, Uint8Array[] | null], b: [Uint8Array, Uint8Array[] | null]): -1 | 0 | 1;
+export declare function singleKeyCmp(a: [Uint8Array, Uint8Array[] | null], b: Uint8Array): -1 | 0 | 1;
+export declare function minKey(prefix: string): Buffer;
+export declare function maxKey(prefix: string): Buffer;
+export declare function serializeKey(prefix: string, key: Key): Buffer;
+export declare function deserializeKey<K extends Key>(prefix: string, key: Uint8Array): K | false;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dest/lmdb-v2/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lmdb-v2/utils.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,yBAAyB,CAAC;AAEnD,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEzC,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAkBhE;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,GAAG,IAAI,CAgB7F;AAED,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,CAiBxG;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,GAAG,CAAC,GAAG,SAAS,CAG1G;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,CAsB5F;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,QAK5F;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,CAqBvF;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAE7G;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAE5F;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,UAEpC;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,UAEpC;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,MAAM,CAE7D;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,GAAG,CAAC,GAAG,KAAK,CAOxF"}

package/dest/lmdb-v2/utils.js

@@ -0,0 +1,126 @@
+import { MAXIMUM_KEY, fromBufferKey, toBufferKey } from 'ordered-binary';
+export function dedupeSortedArray(arr, cmp) {
+    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(arr, item, cmp) {
+    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(values, needle, cmp) {
+    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(values, needle, cmp) {
+    const idx = findIndexInSortedArray(values, needle, cmp);
+    return idx > -1 ? values[idx] : undefined;
+}
+export function removeAnyOf(arr, vals, cmp) {
+    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(arr, val, cmp) {
+    const idx = findIndexInSortedArray(arr, val, cmp);
+    if (idx > -1) {
+        arr.splice(idx, 1);
+    }
+}
+export function merge(arr, toInsert, cmp) {
+    const result = new Array(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, b) {
+    return Buffer.compare(a[0], b[0]);
+}
+export function singleKeyCmp(a, b) {
+    return Buffer.compare(a[0], b);
+}
+export function minKey(prefix) {
+    return toBufferKey([prefix]);
+}
+export function maxKey(prefix) {
+    return toBufferKey([prefix, MAXIMUM_KEY]);
+}
+export function serializeKey(prefix, key) {
+    return toBufferKey([prefix, key]);
+}
+export function deserializeKey(prefix, key) {
+    const buf = Buffer.from(key);
+    const parsed = fromBufferKey(buf);
+    if (!Array.isArray(parsed) || parsed[0] !== prefix) {
+        return false;
+    }
+    return parsed[1];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/lmdb-v2/write_transaction.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { type Batch } from './message.js';
+import { ReadTransaction } from './read_transaction.js';
+export declare class WriteTransaction extends ReadTransaction {
+    #private;
+    readonly dataBatch: Batch;
+    readonly indexBatch: Batch;
+    set(key: Uint8Array, value: Uint8Array): Promise<void>;
+    remove(key: Uint8Array): Promise<void>;
+    get(key: Buffer): Promise<Uint8Array | undefined>;
+    setIndex(key: Buffer, ...values: Buffer[]): Promise<void>;
+    removeIndex(key: Buffer, ...values: Buffer[]): Promise<void>;
+    getIndex(key: Buffer): Promise<Uint8Array[]>;
+    iterate(startKey: Uint8Array, endKey?: Uint8Array | undefined, reverse?: boolean, limit?: number): AsyncIterable<[Uint8Array, Uint8Array]>;
+    iterateIndex(startKey: Uint8Array, endKey?: Uint8Array | undefined, reverse?: boolean, limit?: number): AsyncIterable<[Uint8Array, Uint8Array[]]>;
+    commit(): Promise<void>;
+}
+//# sourceMappingURL=write_transaction.d.ts.map

package/dest/lmdb-v2/write_transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write_transaction.d.ts","sourceRoot":"","sources":["../../src/lmdb-v2/write_transaction.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,KAAK,KAAK,EAA6B,MAAM,cAAc,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAaxD,qBAAa,gBAAiB,SAAQ,eAAe;;IAEnD,SAAgB,SAAS,EAAE,KAAK,CAG9B;IACF,SAAgB,UAAU,EAAE,KAAK,CAG/B;IAEF,GAAG,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBtD,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAchB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC;IAevE,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BzD,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAuCtC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAuB3C,OAAO,CAC5B,QAAQ,EAAE,UAAU,EACpB,MAAM,CAAC,EAAE,UAAU,GAAG,SAAS,EAC/B,OAAO,CAAC,EAAE,OAAO,EACjB,KAAK,CAAC,EAAE,MAAM,GACb,aAAa,CAAC,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IAanB,YAAY,CACjC,QAAQ,EAAE,UAAU,EACpB,MAAM,CAAC,EAAE,UAAU,GAAG,SAAS,EAC/B,OAAO,CAAC,EAAE,OAAO,EACjB,KAAK,CAAC,EAAE,MAAM,GACb,aAAa,CAAC,CAAC,UAAU,EAAE,UAAU,EAAE,CAAC,CAAC;IAqH/B,MAAM;CAUpB"}

package/dest/lmdb-v2/write_transaction.js

@@ -0,0 +1,234 @@
+var _WriteTransaction_instances, _WriteTransaction_iterate;
+import { __classPrivateFieldGet } from "tslib";
+import { Database, LMDBMessageType } from './message.js';
+import { ReadTransaction } from './read_transaction.js';
+import { dedupeSortedArray, findInSortedArray, findIndexInSortedArray, insertIntoSortedArray, keyCmp, merge, removeAnyOf, removeFromSortedArray, singleKeyCmp, } from './utils.js';
+export class WriteTransaction extends ReadTransaction {
+    constructor() {
+        super(...arguments);
+        _WriteTransaction_instances.add(this);
+        // exposed for tests
+        this.dataBatch = {
+            addEntries: [],
+            removeEntries: [],
+        };
+        this.indexBatch = {
+            addEntries: [],
+            removeEntries: [],
+        };
+    }
+    set(key, value) {
+        this.assertIsOpen();
+        const addEntry = findInSortedArray(this.dataBatch.addEntries, key, singleKeyCmp);
+        if (!addEntry) {
+            insertIntoSortedArray(this.dataBatch.addEntries, [key, [value]], keyCmp);
+        }
+        else {
+            addEntry[1] = [value];
+        }
+        const removeEntryIndex = findIndexInSortedArray(this.dataBatch.removeEntries, key, singleKeyCmp);
+        if (removeEntryIndex > -1) {
+            this.dataBatch.removeEntries.splice(removeEntryIndex, 1);
+        }
+        return Promise.resolve();
+    }
+    remove(key) {
+        const removeEntryIndex = findIndexInSortedArray(this.dataBatch.removeEntries, key, singleKeyCmp);
+        if (removeEntryIndex === -1) {
+            this.dataBatch.removeEntries.push([key, null]);
+        }
+        const addEntryIndex = findIndexInSortedArray(this.dataBatch.addEntries, key, singleKeyCmp);
+        if (addEntryIndex > -1) {
+            this.dataBatch.addEntries.splice(addEntryIndex, 1);
+        }
+        return Promise.resolve();
+    }
+    async get(key) {
+        this.assertIsOpen();
+        const addEntry = findInSortedArray(this.dataBatch.addEntries, key, singleKeyCmp);
+        if (addEntry) {
+            return addEntry[1][0];
+        }
+        const removeEntryIdx = findIndexInSortedArray(this.dataBatch.removeEntries, key, singleKeyCmp);
+        if (removeEntryIdx > -1) {
+            return undefined;
+        }
+        return await super.get(key);
+    }
+    setIndex(key, ...values) {
+        this.assertIsOpen();
+        const addEntries = findInSortedArray(this.indexBatch.addEntries, key, singleKeyCmp);
+        const removeEntries = findInSortedArray(this.indexBatch.removeEntries, key, singleKeyCmp);
+        if (removeEntries) {
+            if (removeEntries[1]) {
+                // check if we were deleting these values and update
+                removeAnyOf(removeEntries[1], values, Buffer.compare);
+            }
+            if (!removeEntries[1] || removeEntries[1].length === 0) {
+                // either we were deleting the entire key previously
+                // or after cleaning up duplicates, we don't have anything else to delete
+                removeFromSortedArray(this.indexBatch.removeEntries, removeEntries, keyCmp);
+            }
+        }
+        if (addEntries) {
+            merge(addEntries[1], values, Buffer.compare);
+            dedupeSortedArray(addEntries[1], Buffer.compare);
+        }
+        else {
+            insertIntoSortedArray(this.indexBatch.addEntries, [key, values], keyCmp);
+        }
+        return Promise.resolve();
+    }
+    removeIndex(key, ...values) {
+        this.assertIsOpen();
+        const addEntries = findInSortedArray(this.indexBatch.addEntries, key, singleKeyCmp);
+        const removeEntries = findInSortedArray(this.indexBatch.removeEntries, key, singleKeyCmp);
+        if (values.length === 0) {
+            // special case, we're deleting the entire key
+            if (addEntries) {
+                removeFromSortedArray(this.indexBatch.addEntries, addEntries, keyCmp);
+            }
+            if (removeEntries) {
+                removeEntries[1] = null;
+            }
+            else {
+                insertIntoSortedArray(this.indexBatch.removeEntries, [key, null], keyCmp);
+            }
+            return Promise.resolve();
+        }
+        if (addEntries) {
+            removeAnyOf(addEntries[1], values, Buffer.compare);
+            if (addEntries[1].length === 0) {
+                removeFromSortedArray(this.indexBatch.addEntries, addEntries, keyCmp);
+            }
+        }
+        if (removeEntries) {
+            removeEntries[1] ?? (removeEntries[1] = []);
+            merge(removeEntries[1], values, Buffer.compare);
+            dedupeSortedArray(removeEntries[1], Buffer.compare);
+        }
+        else {
+            insertIntoSortedArray(this.indexBatch.removeEntries, [key, values], keyCmp);
+        }
+        return Promise.resolve();
+    }
+    async getIndex(key) {
+        this.assertIsOpen();
+        const removeEntries = findInSortedArray(this.indexBatch.removeEntries, key, singleKeyCmp);
+        if (removeEntries && removeEntries[1] === null) {
+            return [];
+        }
+        const addEntries = findInSortedArray(this.indexBatch.addEntries, key, singleKeyCmp);
+        const results = await super.getIndex(key);
+        if (addEntries) {
+            merge(results, addEntries[1], Buffer.compare);
+            dedupeSortedArray(results, Buffer.compare);
+        }
+        if (removeEntries && Array.isArray(removeEntries[1])) {
+            removeAnyOf(results, removeEntries[1], Buffer.compare);
+        }
+        return results;
+    }
+    async *iterate(startKey, endKey, reverse, limit) {
+        yield* __classPrivateFieldGet(this, _WriteTransaction_instances, "m", _WriteTransaction_iterate).call(this, super.iterate(startKey, endKey, reverse), this.dataBatch, startKey, endKey, reverse, limit, (committed, toAdd) => (toAdd.length > 0 ? toAdd[0] : committed), vals => vals[0]);
+    }
+    async *iterateIndex(startKey, endKey, reverse, limit) {
+        yield* __classPrivateFieldGet(this, _WriteTransaction_instances, "m", _WriteTransaction_iterate).call(this, super.iterateIndex(startKey, endKey, reverse), this.indexBatch, startKey, endKey, reverse, limit, (committed, toAdd, toRemove) => {
+            if (toAdd.length > 0) {
+                merge(committed, toAdd, Buffer.compare);
+                dedupeSortedArray(committed, Buffer.compare);
+            }
+            if (toRemove.length > 0) {
+                removeAnyOf(committed, toRemove, Buffer.compare);
+            }
+            return committed;
+        }, vals => vals);
+    }
+    async commit() {
+        this.assertIsOpen();
+        this.close();
+        await this.channel.sendMessage(LMDBMessageType.BATCH, {
+            batches: new Map([
+                [Database.DATA, this.dataBatch],
+                [Database.INDEX, this.indexBatch],
+            ]),
+        });
+    }
+}
+_WriteTransaction_instances = new WeakSet(), _WriteTransaction_iterate = async function* _WriteTransaction_iterate(iterator, batch, startKey, endKey, reverse = false, limit, merge, map) {
+    this.assertIsOpen();
+    // make a copy of this in case we're running in reverse
+    const uncommittedEntries = [...batch.addEntries];
+    // used to check we're in the right order when comparing between a key and uncommittedEntries
+    let cmpDirection = -1;
+    if (reverse) {
+        cmpDirection = 1;
+        uncommittedEntries.reverse();
+    }
+    let uncommittedEntriesIdx = 0;
+    while (uncommittedEntriesIdx < uncommittedEntries.length) {
+        const entry = uncommittedEntries[uncommittedEntriesIdx];
+        // go to the first key in our cache that would be captured by the iterator
+        if (Buffer.compare(entry[0], startKey) !== cmpDirection) {
+            break;
+        }
+        uncommittedEntriesIdx++;
+    }
+    let count = 0;
+    // helper to early return if we've reached our limit
+    const checkLimit = typeof limit === 'number' ? () => count < limit : () => true;
+    for await (const [key, values] of iterator) {
+        // yield every key that we have cached that's captured by the iterator
+        while (uncommittedEntriesIdx < uncommittedEntries.length && checkLimit()) {
+            const entry = uncommittedEntries[uncommittedEntriesIdx];
+            if (endKey && Buffer.compare(entry[0], endKey) !== cmpDirection) {
+                break;
+            }
+            if (Buffer.compare(entry[0], key) === cmpDirection) {
+                count++;
+                yield [entry[0], map(entry[1])];
+            }
+            else {
+                break;
+            }
+            uncommittedEntriesIdx++;
+        }
+        if (!checkLimit()) {
+            // we reached the imposed `limit`
+            break;
+        }
+        const toRemove = findInSortedArray(batch.removeEntries, key, singleKeyCmp);
+        // at this point we've either exhausted all uncommitted entries,
+        // we reached a key strictly greater/smaller than `key`
+        // or we found the key itself
+        // check if it's the key and use the uncommitted value
+        let toAdd = [];
+        if (uncommittedEntriesIdx < uncommittedEntries.length &&
+            Buffer.compare(uncommittedEntries[uncommittedEntriesIdx][0], key) === 0) {
+            toAdd = uncommittedEntries[uncommittedEntriesIdx][1];
+            uncommittedEntriesIdx++;
+        }
+        if (toRemove && !toRemove[1]) {
+            // we were told to delete this key entirely
+            continue;
+        }
+        else {
+            const mergedValues = merge(values, toAdd, toRemove?.[1] ?? []);
+            if (mergedValues) {
+                count++;
+                yield [key, mergedValues];
+            }
+        }
+    }
+    // emit all the uncommitted data that would be captured by this iterator
+    while (uncommittedEntriesIdx < uncommittedEntries.length && checkLimit()) {
+        const entry = uncommittedEntries[uncommittedEntriesIdx];
+        if (endKey && Buffer.compare(entry[0], endKey) !== cmpDirection) {
+            break;
+        }
+        count++;
+        yield [entry[0], map(entry[1])];
+        uncommittedEntriesIdx++;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"write_transaction.js","sourceRoot":"","sources":["../../src/lmdb-v2/write_transaction.ts"],"names":[],"mappings":"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"}

package/dest/stores/l2_tips_store.js

@@ -29,7 +29,7 @@ export class L2TipsStore {
         switch (event.type) {
             case 'blocks-added':
                 for (const block of event.blocks) {
-                    await this.l2BlockHashesStore.set(block.number, block.header.hash().toString());
+                    await this.l2BlockHashesStore.set(block.number, (await block.header.hash()).toString());
                 }
                 await this.l2TipsStore.set('latest', event.blocks.at(-1).number);
                 break;
@@ -48,4 +48,4 @@ export class L2TipsStore {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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