@aztec-labs/kv-store 6.0.0-nightly.20260829

package/dest/interfaces/multi_map_test_suite.js

@@ -0,0 +1,363 @@
+import { toArray } from '@aztec-labs/foundation/iterable';
+import { isSyncStore } from './utils.js';
+export function describeAztecMultiMap(testName, getStore, forceAsync = false) {
+    describe(testName, ()=>{
+        let store;
+        let multiMap;
+        beforeEach(async ()=>{
+            store = await getStore();
+            multiMap = store.openMultiMap('test');
+        });
+        afterEach(async ()=>{
+            await store.delete();
+        });
+        async function get(key, sut = multiMap) {
+            return isSyncStore(store) && !forceAsync ? sut.get(key) : await sut.getAsync(key);
+        }
+        async function size(sut = multiMap) {
+            return isSyncStore(store) && !forceAsync ? sut.size() : await sut.sizeAsync();
+        }
+        async function entries() {
+            return isSyncStore(store) && !forceAsync ? await toArray(multiMap.entries()) : await toArray(multiMap.entriesAsync());
+        }
+        async function values() {
+            return isSyncStore(store) && !forceAsync ? await toArray(multiMap.values()) : await toArray(multiMap.valuesAsync());
+        }
+        async function keys(range, sut = multiMap) {
+            return isSyncStore(store) && !forceAsync ? await toArray(sut.keys(range)) : await toArray(sut.keysAsync(range));
+        }
+        async function getValues(key) {
+            return isSyncStore(store) && !forceAsync ? await toArray(multiMap.getValues(key)) : await toArray(multiMap.getValuesAsync(key));
+        }
+        async function getValueCount(key, sut = multiMap) {
+            return await sut.getValueCountAsync(key);
+        }
+        it('should be able to set and get values', async ()=>{
+            await multiMap.set('foo', 'bar');
+            await multiMap.set('baz', 'qux');
+            expect(await get('foo')).toBe('bar');
+            expect(await get('baz')).toBe('qux');
+            expect(await get('quux')).toBe(undefined);
+        });
+        it('should be able to set values if they do not exist', async ()=>{
+            expect(await multiMap.setIfNotExists('foo', 'bar')).toBe(true);
+            expect(await multiMap.setIfNotExists('foo', 'baz')).toBe(false);
+            expect(await get('foo')).toBe('bar');
+        });
+        it('should be able to delete values', async ()=>{
+            await multiMap.set('foo', 'bar');
+            await multiMap.set('baz', 'qux');
+            await multiMap.delete('foo');
+            expect(await get('foo')).toBe(undefined);
+            expect(await get('baz')).toBe('qux');
+        });
+        it('should be able to get size of the map', async ()=>{
+            await multiMap.set('foo', 'bar');
+            expect(await size()).toBe(1);
+            await multiMap.set('baz', 'qux');
+            expect(await size()).toBe(2);
+            await multiMap.delete('foo');
+            expect(await size()).toBe(1);
+        });
+        it('returns 0 for empty multimap size', async ()=>{
+            expect(await size()).toBe(0);
+        });
+        it('calculates size correctly with multiple values per key', async ()=>{
+            expect(await size()).toBe(0);
+            // Add multiple values for same key
+            await multiMap.set('key1', 'value1');
+            expect(await size()).toBe(1);
+            await multiMap.set('key1', 'value2');
+            expect(await size()).toBe(2);
+            await multiMap.set('key1', 'value3');
+            expect(await size()).toBe(3);
+            // Add values for different key
+            await multiMap.set('key2', 'value4');
+            expect(await size()).toBe(4);
+            // Delete one value from key1
+            await multiMap.deleteValue('key1', 'value2');
+            expect(await size()).toBe(3);
+            // Delete entire key
+            await multiMap.delete('key1');
+            expect(await size()).toBe(1);
+            // Delete last key
+            await multiMap.delete('key2');
+            expect(await size()).toBe(0);
+        });
+        it('should be able to iterate over entries when there are no keys', async ()=>{
+            expect(await entries()).toEqual([]);
+        });
+        it('should be able to iterate over entries', async ()=>{
+            await multiMap.set('foo', 'bar');
+            await multiMap.set('baz', 'qux');
+            expect(await entries()).toEqual([
+                [
+                    'baz',
+                    'qux'
+                ],
+                [
+                    'foo',
+                    'bar'
+                ]
+            ]);
+        });
+        it('should be able to iterate over values', async ()=>{
+            await multiMap.set('foo', 'bar');
+            await multiMap.set('baz', 'quux');
+            expect(await values()).toEqual([
+                'quux',
+                'bar'
+            ]);
+        });
+        it('should be able to iterate over keys', async ()=>{
+            await multiMap.set('foo', 'bar');
+            await multiMap.set('baz', 'qux');
+            expect(await keys()).toEqual([
+                'baz',
+                'foo'
+            ]);
+        });
+        it('should be able to get multiple values for a single key', async ()=>{
+            await multiMap.set('foo', 'bar');
+            await multiMap.set('foo', 'baz');
+            expect(await getValues('foo')).toEqual([
+                'bar',
+                'baz'
+            ]);
+        });
+        it('should ignore multiple identical values', async ()=>{
+            await multiMap.set('foo', 'bar');
+            await multiMap.set('foo', 'bar');
+            expect(await getValues('foo')).toEqual([
+                'bar'
+            ]);
+        });
+        it('should be able to delete individual values for a single key', async ()=>{
+            await multiMap.set('foo', '1');
+            await multiMap.set('foo', '2');
+            await multiMap.set('foo', '3');
+            await multiMap.deleteValue('foo', '2');
+            expect(await getValues('foo')).toEqual([
+                '1',
+                '3'
+            ]);
+        });
+        it('should be able to get size of the map with duplicate keys', async ()=>{
+            await multiMap.set('foo', '1');
+            await multiMap.set('foo', '2');
+            await multiMap.set('foo', '3');
+            expect(await size()).toBe(3);
+            await multiMap.set('bar', '1');
+            await multiMap.set('bar', '2');
+            await multiMap.set('bar', '3');
+            expect(await size()).toBe(6);
+            await multiMap.deleteValue('foo', '2');
+            expect(await size()).toBe(5);
+        });
+        it('should be able to delete the last and first values for a key', async ()=>{
+            await multiMap.set('foo', '1');
+            await multiMap.set('foo', '2');
+            await multiMap.set('foo', '3');
+            await multiMap.deleteValue('foo', '1');
+            expect(await getValues('foo')).toEqual([
+                '2',
+                '3'
+            ]);
+            await multiMap.deleteValue('foo', '3');
+            expect(await getValues('foo')).toEqual([
+                '2'
+            ]);
+        });
+        it('should be able to fully clear a key', async ()=>{
+            await multiMap.set('foo', '1');
+            await multiMap.set('foo', '2');
+            await multiMap.set('foo', '3');
+            await multiMap.deleteValue('foo', '1');
+            await multiMap.deleteValue('foo', '3');
+            await multiMap.deleteValue('foo', '2');
+            expect(await getValues('foo')).toEqual([]);
+        });
+        it('should be able to insert after deletion', async ()=>{
+            await multiMap.set('foo', '1');
+            await multiMap.set('foo', '2');
+            await multiMap.set('foo', '3');
+            await multiMap.deleteValue('foo', '2');
+            await multiMap.set('foo', 'bar');
+            expect(await getValues('foo')).toEqual([
+                '1',
+                '3',
+                'bar'
+            ]);
+            // Delete the just-added entry
+            await multiMap.deleteValue('foo', 'bar');
+            expect(await getValues('foo')).toEqual([
+                '1',
+                '3'
+            ]);
+            // Reinsert the initially deleted key
+            await multiMap.set('foo', '2');
+            // LMDB and IndexedDB behave differently here, the former ordering by value and the latter by insertion. This is
+            // fine because there is no expectation for values in a multimap to be ordered.
+            const values = (await getValues('foo')).sort((a, b)=>a.localeCompare(b));
+            expect(values).toEqual([
+                '1',
+                '2',
+                '3'
+            ]);
+            // Fully clear the key
+            await multiMap.deleteValue('foo', '1');
+            await multiMap.deleteValue('foo', '3');
+            await multiMap.deleteValue('foo', '2');
+            // Insert some more
+            await multiMap.set('foo', 'baz');
+            await multiMap.set('foo', 'qux');
+            expect(await getValues('foo')).toEqual([
+                'baz',
+                'qux'
+            ]);
+        });
+        it('supports range queries', async ()=>{
+            await multiMap.set('a', 'a');
+            await multiMap.set('b', 'b');
+            await multiMap.set('c', 'c');
+            await multiMap.set('d', 'd');
+            expect(await keys({
+                start: 'b',
+                end: 'c'
+            })).toEqual([
+                'b'
+            ]);
+            expect(await keys({
+                start: 'b'
+            })).toEqual([
+                'b',
+                'c',
+                'd'
+            ]);
+            expect(await keys({
+                end: 'c'
+            })).toEqual([
+                'a',
+                'b'
+            ]);
+            expect(await keys({
+                start: 'b',
+                end: 'c',
+                reverse: true
+            })).toEqual([
+                'c'
+            ]);
+            expect(await keys({
+                start: 'b',
+                limit: 1
+            })).toEqual([
+                'b'
+            ]);
+            expect(await keys({
+                start: 'b',
+                reverse: true
+            })).toEqual([
+                'd',
+                'c'
+            ]);
+            expect(await keys({
+                end: 'b',
+                reverse: true
+            })).toEqual([
+                'b',
+                'a'
+            ]);
+        });
+        it('returns 0 for missing key', async ()=>{
+            expect(await getValueCount('missing')).toBe(0);
+        });
+        it('counts a single value', async ()=>{
+            await multiMap.set('foo', 'bar');
+            expect(await getValueCount('foo')).toBe(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')).toBe(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')).toBe(2);
+            expect((await getValues('foo')).sort()).toEqual([
+                'bar',
+                'baz'
+            ].sort());
+        });
+        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')).toBe(3);
+            await multiMap.deleteValue('foo', '2');
+            expect(await getValueCount('foo')).toBe(2);
+            expect((await getValues('foo')).sort()).toEqual([
+                '1',
+                '3'
+            ].sort());
+        });
+        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')).toBe(2);
+            await multiMap.deleteValue('foo', '2');
+            expect(await getValueCount('foo')).toBe(2);
+        });
+        it('clears all values when deleting a key', async ()=>{
+            await multiMap.set('foo', 'bar');
+            await multiMap.set('foo', 'baz');
+            expect(await getValueCount('foo')).toBe(2);
+            await multiMap.delete('foo');
+            expect(await getValueCount('foo')).toBe(0);
+            expect(await getValues('foo')).toEqual([]);
+        });
+        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')).toBe(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).toBe(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')).toBe(3);
+            await multiMap.deleteValue('foo', '2');
+            expect(await getValueCount('foo')).toBe(2);
+            await multiMap.set('foo', '4');
+            expect(await getValueCount('foo')).toBe(3);
+            expect((await getValues('foo')).sort()).toEqual([
+                '1',
+                '3',
+                '4'
+            ].sort());
+        });
+        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')).toBe(2);
+            expect(await getValueCount('bar')).toBe(1);
+        });
+    });
+}

package/dest/interfaces/set.d.ts

@@ -0,0 +1,44 @@
+import type { Key, Range } from './common.js';
+/**
+ * A set backed by a persistent store.
+ */
+interface AztecBaseSet<K extends Key> {
+    /**
+     * Adds the given value.
+     * @param key - The key to add.
+     */
+    add(key: K): Promise<void>;
+    /**
+     * Deletes the given key.
+     * @param key - The key to delete.
+     */
+    delete(key: K): Promise<void>;
+}
+export interface AztecSet<K extends Key> extends AztecBaseSet<K> {
+    /**
+     * Checks if a key exists in the set.
+     * @param key - The key to check
+     * @returns True if the key exists, false otherwise
+     */
+    has(key: K): boolean;
+    /**
+     * Iterates over the sets's keys entries in the key's natural order
+     * @param range - The range of keys to iterate over
+     */
+    entries(range?: Range<K>): IterableIterator<K>;
+}
+export interface AztecAsyncSet<K extends Key> extends AztecBaseSet<K> {
+    /**
+     * Checks if a key exists in the set.
+     * @param key - The key to check
+     * @returns True if the key exists, false otherwise
+     */
+    hasAsync(key: K): Promise<boolean>;
+    /**
+     * Iterates over the sets's keys entries in the key's natural order
+     * @param range - The range of keys to iterate over
+     */
+    entriesAsync(range?: Range<K>): AsyncIterableIterator<K>;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW50ZXJmYWNlcy9zZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsR0FBRyxFQUFFLEtBQUssRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUU5Qzs7R0FFRztBQUNILFVBQVUsWUFBWSxDQUFDLENBQUMsU0FBUyxHQUFHO0lBQ2xDOzs7T0FHRztJQUNILEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUUzQjs7O09BR0c7SUFDSCxNQUFNLENBQUMsR0FBRyxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7Q0FDL0I7QUFFRCxNQUFNLFdBQVcsUUFBUSxDQUFDLENBQUMsU0FBUyxHQUFHLENBQUUsU0FBUSxZQUFZLENBQUMsQ0FBQyxDQUFDO0lBQzlEOzs7O09BSUc7SUFDSCxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUM7SUFFckI7OztPQUdHO0lBQ0gsT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUMsR0FBRyxnQkFBZ0IsQ0FBQyxDQUFDLENBQUMsQ0FBQztDQUNoRDtBQUVELE1BQU0sV0FBVyxhQUFhLENBQUMsQ0FBQyxTQUFTLEdBQUcsQ0FBRSxTQUFRLFlBQVksQ0FBQyxDQUFDLENBQUM7SUFDbkU7Ozs7T0FJRztJQUNILFFBQVEsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUVuQzs7O09BR0c7SUFDSCxZQUFZLENBQUMsS0FBSyxDQUFDLEVBQUUsS0FBSyxDQUFDLENBQUMsQ0FBQyxHQUFHLHFCQUFxQixDQUFDLENBQUMsQ0FBQyxDQUFDO0NBQzFEIn0=

package/dest/interfaces/set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../src/interfaces/set.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,UAAU,YAAY,CAAC,CAAC,SAAS,GAAG;IAClC;;;OAGG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3B;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,GAAG,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;IAC9D;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IAErB;;;OAGG;IACH,OAAO,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,GAAG,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC;IACnE;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAEnC;;;OAGG;IACH,YAAY,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAAC;CAC1D"}

package/dest/interfaces/set.js

@@ -0,0 +1 @@
+export { };

package/dest/interfaces/set_test_suite.d.ts

@@ -0,0 +1,3 @@
+import type { AztecAsyncKVStore, AztecKVStore } from './store.js';
+export declare function describeAztecSet(testName: string, getStore: () => AztecKVStore | Promise<AztecAsyncKVStore>, forceAsync?: boolean): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0X3Rlc3Rfc3VpdGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbnRlcmZhY2VzL3NldF90ZXN0X3N1aXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLFlBQVksRUFBRSxNQUFNLFlBQVksQ0FBQztBQUdsRSx3QkFBZ0IsZ0JBQWdCLENBQzlCLFFBQVEsRUFBRSxNQUFNLEVBQ2hCLFFBQVEsRUFBRSxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsaUJBQWlCLENBQUMsRUFDekQsVUFBVSxHQUFFLE9BQWUsUUFvRTVCIn0=

package/dest/interfaces/set_test_suite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set_test_suite.d.ts","sourceRoot":"","sources":["../../src/interfaces/set_test_suite.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAGlE,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,YAAY,GAAG,OAAO,CAAC,iBAAiB,CAAC,EACzD,UAAU,GAAE,OAAe,QAoE5B"}

package/dest/interfaces/set_test_suite.js

@@ -0,0 +1,95 @@
+import { toArray } from '@aztec-labs/foundation/iterable';
+import { isSyncStore } from './utils.js';
+export function describeAztecSet(testName, getStore, forceAsync = false) {
+    describe(testName, ()=>{
+        let store;
+        let set;
+        beforeEach(async ()=>{
+            store = await getStore();
+            set = store.openSet('test');
+        });
+        afterEach(async ()=>{
+            await store.delete();
+        });
+        async function has(key) {
+            return isSyncStore(store) && !forceAsync ? set.has(key) : await set.hasAsync(key);
+        }
+        async function entries(range) {
+            return isSyncStore(store) && !forceAsync ? await toArray(set.entries(range)) : await toArray(set.entriesAsync(range));
+        }
+        it('should be able to set and get values', async ()=>{
+            await set.add('foo');
+            await set.add('baz');
+            expect(await has('foo')).toBe(true);
+            expect(await has('baz')).toBe(true);
+            expect(await has('bar')).toBe(false);
+        });
+        it('should be able to delete values', async ()=>{
+            await set.add('foo');
+            await set.add('baz');
+            await set.delete('foo');
+            expect(await has('foo')).toBe(false);
+            expect(await has('baz')).toBe(true);
+        });
+        it('should be able to iterate over entries', async ()=>{
+            await set.add('baz');
+            await set.add('foo');
+            expect(await entries()).toEqual([
+                'baz',
+                'foo'
+            ]);
+        });
+        it('supports range queries', async ()=>{
+            await set.add('a');
+            await set.add('b');
+            await set.add('c');
+            await set.add('d');
+            expect(await entries({
+                start: 'b',
+                end: 'c'
+            })).toEqual([
+                'b'
+            ]);
+            expect(await entries({
+                start: 'b'
+            })).toEqual([
+                'b',
+                'c',
+                'd'
+            ]);
+            expect(await entries({
+                end: 'c'
+            })).toEqual([
+                'a',
+                'b'
+            ]);
+            expect(await entries({
+                start: 'b',
+                end: 'c',
+                reverse: true
+            })).toEqual([
+                'c'
+            ]);
+            expect(await entries({
+                start: 'b',
+                limit: 1
+            })).toEqual([
+                'b'
+            ]);
+            expect(await entries({
+                start: 'b',
+                reverse: true
+            })).toEqual([
+                'd',
+                'c'
+            ]);
+            expect(await entries({
+                end: 'b',
+                reverse: true
+            })).toEqual([
+                'b',
+                'a'
+            ]);
+        });
+    });
+}

package/dest/interfaces/singleton.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Represents a singleton value in the database.
+ * Note: The singleton loses type info so it's recommended to serialize to buffer when storing it.
+ */
+interface AztecBaseSingleton<T> {
+    /**
+     * Sets the value.
+     * @param val - The new value
+     */
+    set(val: T): Promise<boolean>;
+    /**
+     * Deletes the value.
+     */
+    delete(): Promise<boolean>;
+}
+export interface AztecSingleton<T> extends AztecBaseSingleton<T> {
+    /**
+     * Gets the value.
+     */
+    get(): T | undefined;
+}
+export interface AztecAsyncSingleton<T> extends AztecBaseSingleton<T> {
+    /**
+     * Gets the value.
+     */
+    getAsync(): Promise<T | undefined>;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2luZ2xldG9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW50ZXJmYWNlcy9zaW5nbGV0b24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBQ0gsVUFBVSxrQkFBa0IsQ0FBQyxDQUFDO0lBQzVCOzs7T0FHRztJQUNILEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUU5Qjs7T0FFRztJQUNILE1BQU0sSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUM7Q0FDNUI7QUFDRCxNQUFNLFdBQVcsY0FBYyxDQUFDLENBQUMsQ0FBRSxTQUFRLGtCQUFrQixDQUFDLENBQUMsQ0FBQztJQUM5RDs7T0FFRztJQUNILEdBQUcsSUFBSSxDQUFDLEdBQUcsU0FBUyxDQUFDO0NBQ3RCO0FBRUQsTUFBTSxXQUFXLG1CQUFtQixDQUFDLENBQUMsQ0FBRSxTQUFRLGtCQUFrQixDQUFDLENBQUMsQ0FBQztJQUNuRTs7T0FFRztJQUNILFFBQVEsSUFBSSxPQUFPLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxDQUFDO0NBQ3BDIn0=

package/dest/interfaces/singleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleton.d.ts","sourceRoot":"","sources":["../../src/interfaces/singleton.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,UAAU,kBAAkB,CAAC,CAAC;IAC5B;;;OAGG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAE9B;;OAEG;IACH,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC5B;AACD,MAAM,WAAW,cAAc,CAAC,CAAC,CAAE,SAAQ,kBAAkB,CAAC,CAAC,CAAC;IAC9D;;OAEG;IACH,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;CACtB;AAED,MAAM,WAAW,mBAAmB,CAAC,CAAC,CAAE,SAAQ,kBAAkB,CAAC,CAAC,CAAC;IACnE;;OAEG;IACH,QAAQ,IAAI,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CACpC"}

package/dest/interfaces/singleton.js

@@ -0,0 +1,4 @@
+/**
+ * Represents a singleton value in the database.
+ * Note: The singleton loses type info so it's recommended to serialize to buffer when storing it.
+ */ export { };

package/dest/interfaces/singleton_test_suite.d.ts

@@ -0,0 +1,3 @@
+import type { AztecAsyncKVStore, AztecKVStore } from './store.js';
+export declare function describeAztecSingleton(testName: string, getStore: () => AztecKVStore | Promise<AztecAsyncKVStore>, forceAsync?: boolean): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2luZ2xldG9uX3Rlc3Rfc3VpdGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbnRlcmZhY2VzL3NpbmdsZXRvbl90ZXN0X3N1aXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLFlBQVksRUFBRSxNQUFNLFlBQVksQ0FBQztBQUdsRSx3QkFBZ0Isc0JBQXNCLENBQ3BDLFFBQVEsRUFBRSxNQUFNLEVBQ2hCLFFBQVEsRUFBRSxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsaUJBQWlCLENBQUMsRUFDekQsVUFBVSxHQUFFLE9BQWUsUUFvQzVCIn0=

package/dest/interfaces/singleton_test_suite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleton_test_suite.d.ts","sourceRoot":"","sources":["../../src/interfaces/singleton_test_suite.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAGlE,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,YAAY,GAAG,OAAO,CAAC,iBAAiB,CAAC,EACzD,UAAU,GAAE,OAAe,QAoC5B"}

package/dest/interfaces/singleton_test_suite.js

@@ -0,0 +1,29 @@
+import { isSyncStore } from './utils.js';
+export function describeAztecSingleton(testName, getStore, forceAsync = false) {
+    describe(testName, ()=>{
+        let store;
+        let singleton;
+        beforeEach(async ()=>{
+            store = await getStore();
+            singleton = store.openSingleton('test');
+        });
+        afterEach(async ()=>{
+            await store.delete();
+        });
+        async function get() {
+            return isSyncStore(store) && !forceAsync ? singleton.get() : await singleton.getAsync();
+        }
+        it('returns undefined if the value is not set', async ()=>{
+            expect(await get()).toBe(undefined);
+        });
+        it('should be able to set and get values', async ()=>{
+            expect(await singleton.set('foo')).toBe(true);
+            expect(await get()).toBe('foo');
+        });
+        it('overwrites the value if it is set again', async ()=>{
+            expect(await singleton.set('foo')).toBe(true);
+            expect(await singleton.set('bar')).toBe(true);
+            expect(await get()).toBe('bar');
+        });
+    });
+}