@aztec/pxe 0.0.1-commit.7b97ef96e → 0.0.1-commit.7cbc774

package/dest/storage/backwards_compatibility_tests/kv_store_snapshot.js

@@ -0,0 +1,93 @@
+/**
+ * Returns every entry of the given map (or multimap), with both keys and values rendered as strings, sorted by key
+ * with value as a tiebreaker.
+ */ export async function snapshotMap(map) {
+    const entries = [];
+    for await (const [k, v] of map.entriesAsync()){
+        entries.push({
+            key: keyToString(k),
+            value: valueToString(v)
+        });
+    }
+    return entries.sort(compareMapEntries);
+}
+/**
+ * Returns the contents of `array` paired with their numeric indices, in insertion order.
+ *
+ * Unlike {@link snapshotMap}, no sort: arrays are inherently ordered by index and that order *is* part of the schema.
+ * The `index` field is preserved on each entry so any unintended reorder shows up in the diff.
+ */ export async function snapshotArray(array) {
+    const entries = [];
+    let index = 0;
+    for await (const v of array.valuesAsync()){
+        entries.push({
+            index: index++,
+            value: valueToString(v)
+        });
+    }
+    return entries;
+}
+/** Returns the singleton's value rendered as a string, or `null` if unset. */ export async function snapshotSingleton(singleton) {
+    const value = await singleton.getAsync();
+    return value === undefined ? null : valueToString(value);
+}
+function compareMapEntries(a, b) {
+    return a.key === b.key ? a.value.localeCompare(b.value) : a.key.localeCompare(b.key);
+}
+/**
+ * Renders a key as a stable string. Buffers and `Uint8Array`s become `0x`-prefixed hex (matching the canonical byte
+ * form used by `Fr.toString()`, `AztecAddress.toString()`, etc. elsewhere in the codebase); primitives carry a type
+ * prefix (`utf8:`, `num:`) so that different runtime types can't alias to the same string in a snapshot. Without the
+ * prefix, a future change that swapped a `number` key for a `string` of the same digits would be invisible in the
+ * diff.
+ */ function keyToString(k) {
+    if (typeof k === 'string') {
+        return `utf8:${k}`;
+    }
+    if (typeof k === 'number') {
+        return `num:${k}`;
+    }
+    if (Buffer.isBuffer(k)) {
+        return `0x${k.toString('hex')}`;
+    }
+    if (k instanceof Uint8Array) {
+        return `0x${Buffer.from(k).toString('hex')}`;
+    }
+    if (Array.isArray(k)) {
+        return `[${k.map(keyToString).join(',')}]`;
+    }
+    return JSON.stringify(k);
+}
+/**
+ * Renders a value for snapshotting. Same type-prefix discipline as {@link keyToString} so primitives can't
+ * accidentally render identically to buffers carrying the same bytes.
+ *
+ * Resolution order:
+ *   1. `Buffer` / `Uint8Array` -> hex. This is the on-disk byte view; the kv-store layer treats these as opaque, so
+ *      what we see here is exactly what's persisted.
+ *   2. Tagged primitives (`num:`, `big:`, `utf8:`).
+ *   3. `Bufferable` fallback: any object with a `.toBuffer()` method renders as `value.toBuffer().toString('hex')`.
+ *      Covers stdlib domain types stored without pre-serialization. The canonical byte form is what we want to
+ *      fingerprint.
+ *   4. `JSON.stringify` for plain objects, matching how the kv-store layer encodes arbitrary structures on disk.
+ */ function valueToString(v) {
+    if (Buffer.isBuffer(v)) {
+        return v.toString('hex');
+    }
+    if (v instanceof Uint8Array) {
+        return Buffer.from(v).toString('hex');
+    }
+    if (typeof v === 'number') {
+        return `num:${v}`;
+    }
+    if (typeof v === 'bigint') {
+        return `big:${v.toString()}`;
+    }
+    if (typeof v === 'string') {
+        return `utf8:${v}`;
+    }
+    if (v && typeof v.toBuffer === 'function') {
+        return v.toBuffer().toString('hex');
+    }
+    return JSON.stringify(v);
+}

package/dest/storage/backwards_compatibility_tests/schema_tests.d.ts

@@ -0,0 +1,15 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+/**
+ * Template of a specific store's backwards compatibility checks.
+ *
+ * 1. `name` is the store's name (`AddressStore`, `NoteStore`, etc).
+ * 2. `writeToStore` drives writes through each store's own production API (`addNote`, `setCapsule`, etc).
+ * 3. `snapshotStore` re-opens the underlying kv-stores by name (raw) and renders them as snapshots.
+ */
+export type SchemaTest = {
+    name: string;
+    writeToStore: (kvStore: AztecAsyncKVStore) => Promise<void>;
+    snapshotStore: (kvStore: AztecAsyncKVStore) => Promise<Record<string, unknown>>;
+};
+export declare const SCHEMA_TESTS: readonly SchemaTest[];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hX3Rlc3RzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3RvcmFnZS9iYWNrd2FyZHNfY29tcGF0aWJpbGl0eV90ZXN0cy9zY2hlbWFfdGVzdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBT0EsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQXVDekQ7Ozs7OztHQU1HO0FBQ0gsTUFBTSxNQUFNLFVBQVUsR0FBRztJQUN2QixJQUFJLEVBQUUsTUFBTSxDQUFDO0lBQ2IsWUFBWSxFQUFFLENBQUMsT0FBTyxFQUFFLGlCQUFpQixLQUFLLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUM1RCxhQUFhLEVBQUUsQ0FBQyxPQUFPLEVBQUUsaUJBQWlCLEtBQUssT0FBTyxDQUFDLE1BQU0sQ0FBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQztDQUNqRixDQUFDO0FBRUYsZUFBTyxNQUFNLFlBQVksRUFBRSxTQUFTLFVBQVUsRUFvZ0I3QyxDQUFDIn0=

package/dest/storage/backwards_compatibility_tests/schema_tests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema_tests.d.ts","sourceRoot":"","sources":["../../../src/storage/backwards_compatibility_tests/schema_tests.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAuCzD;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,aAAa,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACjF,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,SAAS,UAAU,EAogB7C,CAAC"}