@amadeus-protocol/sdk 1.0.8 → 1.1.1

package/dist/serialization.d.ts

@@ -1,18 +1,6 @@
-/**
- * VecPack Canonical Serialization Format
- *
- * This module implements the VecPack canonical serialization format used by Amadeus.
- * VecPack provides deterministic, canonical encoding of values for use in cryptographic
- * operations (e.g., transaction signing). It ensures that equivalent data structures
- * always serialize to the same byte sequence through canonical ordering of map keys.
- *
- * Format specification:
- * - Supports: null, booleans, integers (varint), bytes, lists, and maps
- * - Maps/objects are sorted by their encoded key bytes for canonical ordering
- * - Varints are limited to 16 bytes maximum
- * - Zero values are encoded as a single 0x00 byte
- */
-import type { DecodedValue, SerializableValue } from './types';
+import { DecodedValue, SerializableValue } from "./types.js";
+
+//#region src/serialization.d.ts
 /**
  * Encode a value into canonical serialization format
  *
@@ -25,7 +13,7 @@ import type { DecodedValue, SerializableValue } from './types';
  * const encoded = encode({ foo: 'bar', count: 42 })
  * ```
  */
-export declare function encode(term: SerializableValue): Uint8Array;
+declare function encode(term: SerializableValue): Uint8Array;
 /**
  * Decode a value from canonical serialization format
  *
@@ -38,7 +26,7 @@ export declare function encode(term: SerializableValue): Uint8Array;
  * const decoded = decode(encodedBytes)
  * ```
  */
-export declare function decode(bytes: Uint8Array | number[]): DecodedValue;
+declare function decode(bytes: Uint8Array | number[]): DecodedValue;
 /**
  * Decode VecPack-encoded contract state into key-value pairs
  *
@@ -60,5 +48,7 @@ export declare function decode(bytes: Uint8Array | number[]): DecodedValue;
  * }
  * ```
  */
-export declare function decodeContractState(bytes: Uint8Array | ArrayBuffer): Array<[Uint8Array, Uint8Array]>;
+declare function decodeContractState(bytes: Uint8Array | ArrayBuffer): Array<[Uint8Array, Uint8Array]>;
+//#endregion
+export { decode, decodeContractState, encode };
 //# sourceMappingURL=serialization.d.ts.map

package/dist/serialization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serialization.d.ts","sourceRoot":"","sources":["../src/serialization.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAUH,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAM9D;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,iBAAiB,GAAG,UAAU,CAI1D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,GAAG,YAAY,CAQjE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,UAAU,GAAG,WAAW,GAC7B,KAAK,CAAC,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAiBjC"}
+{"version":3,"file":"serialization.d.ts","names":[],"sources":["../src/serialization.ts"],"mappings":";;;;;;;;;AA0FA;;;;;;iBAjDgB,MAAA,CAAO,IAAA,EAAM,iBAAA,GAAoB,UAAA;;;;;;;;;;;;;iBAkBjC,MAAA,CAAO,KAAA,EAAO,UAAA,cAAwB,YAAA;;;;;;;;;;;;;;;;;;;;;;iBA+BtC,mBAAA,CACf,KAAA,EAAO,UAAA,GAAa,WAAA,GAClB,KAAA,EAAO,UAAA,EAAY,UAAA"}

package/dist/serialization.js

@@ -1,284 +1,231 @@
+//#region src/serialization.ts
 /**
- * VecPack Canonical Serialization Format
- *
- * This module implements the VecPack canonical serialization format used by Amadeus.
- * VecPack provides deterministic, canonical encoding of values for use in cryptographic
- * operations (e.g., transaction signing). It ensures that equivalent data structures
- * always serialize to the same byte sequence through canonical ordering of map keys.
- *
- * Format specification:
- * - Supports: null, booleans, integers (varint), bytes, lists, and maps
- * - Maps/objects are sorted by their encoded key bytes for canonical ordering
- * - Varints are limited to 16 bytes maximum
- * - Zero values are encoded as a single 0x00 byte
- */
-const TYPE_NULL = 0x00;
-const TYPE_TRUE = 0x01;
-const TYPE_FALSE = 0x02;
-const TYPE_INT = 0x03;
-const TYPE_BYTES = 0x05;
-const TYPE_LIST = 0x06;
-const TYPE_MAP = 0x07;
+* VecPack Canonical Serialization Format
+*
+* This module implements the VecPack canonical serialization format used by Amadeus.
+* VecPack provides deterministic, canonical encoding of values for use in cryptographic
+* operations (e.g., transaction signing). It ensures that equivalent data structures
+* always serialize to the same byte sequence through canonical ordering of map keys.
+*
+* Format specification:
+* - Supports: null, booleans, integers (varint), bytes, lists, and maps
+* - Maps/objects are sorted by their encoded key bytes for canonical ordering
+* - Varints are limited to 16 bytes maximum
+* - Zero values are encoded as a single 0x00 byte
+*/
+const TYPE_NULL = 0;
+const TYPE_TRUE = 1;
+const TYPE_FALSE = 2;
+const TYPE_INT = 3;
+const TYPE_BYTES = 5;
+const TYPE_LIST = 6;
+const TYPE_MAP = 7;
 /**
- * Encode a value into canonical serialization format
- *
- * @param term - The value to encode
- * @returns Encoded bytes as Uint8Array
- * @throws Error if the value contains unsupported types
- *
- * @example
- * ```ts
- * const encoded = encode({ foo: 'bar', count: 42 })
- * ```
- */
-export function encode(term) {
-    const bytesOut = [];
-    encodeTerm(term, bytesOut);
-    return new Uint8Array(bytesOut);
+* Encode a value into canonical serialization format
+*
+* @param term - The value to encode
+* @returns Encoded bytes as Uint8Array
+* @throws Error if the value contains unsupported types
+*
+* @example
+* ```ts
+* const encoded = encode({ foo: 'bar', count: 42 })
+* ```
+*/
+function encode(term) {
+	const bytesOut = [];
+	encodeTerm(term, bytesOut);
+	return new Uint8Array(bytesOut);
 }
 /**
- * Decode a value from canonical serialization format
- *
- * @param bytes - The encoded bytes to decode
- * @returns Decoded value
- * @throws Error if the bytes are invalid or contain trailing bytes
- *
- * @example
- * ```ts
- * const decoded = decode(encodedBytes)
- * ```
- */
-export function decode(bytes) {
-    const data = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
-    const ref = { offset: 0 };
-    const value = decodeTerm(data, ref);
-    if (ref.offset !== data.length) {
-        throw new Error('trailing_bytes');
-    }
-    return value;
+* Decode a value from canonical serialization format
+*
+* @param bytes - The encoded bytes to decode
+* @returns Decoded value
+* @throws Error if the bytes are invalid or contain trailing bytes
+*
+* @example
+* ```ts
+* const decoded = decode(encodedBytes)
+* ```
+*/
+function decode(bytes) {
+	const data = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+	const ref = { offset: 0 };
+	const value = decodeTerm(data, ref);
+	if (ref.offset !== data.length) throw new Error("trailing_bytes");
+	return value;
 }
 /**
- * Decode VecPack-encoded contract state into key-value pairs
- *
- * Contract state prefix queries return a VecPack-encoded map where both
- * keys and values are binary (Uint8Array). This convenience function decodes
- * the binary data and returns the entries as an array of tuples.
- *
- * @param bytes - VecPack-encoded bytes (Uint8Array or ArrayBuffer)
- * @returns Array of [key, value] tuples
- * @throws Error if the data is not a valid VecPack map or entries are not binary
- *
- * @example
- * ```ts
- * const response = await fetch('/contract/state/prefix?prefix=...')
- * const buffer = await response.arrayBuffer()
- * const entries = decodeContractState(buffer)
- * for (const [key, value] of entries) {
- *   console.log(key, value)
- * }
- * ```
- */
-export function decodeContractState(bytes) {
-    const data = bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes;
-    const decoded = decode(data);
-    if (!(decoded instanceof Map)) {
-        throw new Error(`Expected MAP type, got ${typeof decoded}`);
-    }
-    const result = [];
-    for (const [key, value] of decoded.entries()) {
-        if (!(key instanceof Uint8Array) || !(value instanceof Uint8Array)) {
-            throw new Error('Expected Uint8Array for key and value');
-        }
-        result.push([key, value]);
-    }
-    return result;
+* Decode VecPack-encoded contract state into key-value pairs
+*
+* Contract state prefix queries return a VecPack-encoded map where both
+* keys and values are binary (Uint8Array). This convenience function decodes
+* the binary data and returns the entries as an array of tuples.
+*
+* @param bytes - VecPack-encoded bytes (Uint8Array or ArrayBuffer)
+* @returns Array of [key, value] tuples
+* @throws Error if the data is not a valid VecPack map or entries are not binary
+*
+* @example
+* ```ts
+* const response = await fetch('/contract/state/prefix?prefix=...')
+* const buffer = await response.arrayBuffer()
+* const entries = decodeContractState(buffer)
+* for (const [key, value] of entries) {
+*   console.log(key, value)
+* }
+* ```
+*/
+function decodeContractState(bytes) {
+	const decoded = decode(bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes);
+	if (!(decoded instanceof Map)) throw new Error(`Expected MAP type, got ${typeof decoded}`);
+	const result = [];
+	for (const [key, value] of decoded.entries()) {
+		if (!(key instanceof Uint8Array) || !(value instanceof Uint8Array)) throw new Error("Expected Uint8Array for key and value");
+		result.push([key, value]);
+	}
+	return result;
 }
-/*
- * Helper functions for encoding and decoding
- */
 function appendBytes(out, bytes) {
-    for (const b of bytes) {
-        out.push(b);
-    }
+	for (const b of bytes) out.push(b);
 }
 function compareBytes(a, b) {
-    const n = Math.min(a.length, b.length);
-    for (let i = 0; i < n; i++) {
-        if (a[i] !== b[i])
-            return a[i] - b[i];
-    }
-    return a.length - b.length; // shorter wins if prefix equal
+	const n = Math.min(a.length, b.length);
+	for (let i = 0; i < n; i++) if (a[i] !== b[i]) return a[i] - b[i];
+	return a.length - b.length;
 }
 function encodeKeyBytes(k) {
-    const tmp = [];
-    encodeTerm(k, tmp);
-    return tmp;
+	const tmp = [];
+	encodeTerm(k, tmp);
+	return tmp;
 }
 function encodeVarint(n, out) {
-    let value = typeof n === 'bigint' ? n : BigInt(n);
-    if (value === 0n) {
-        out.push(0);
-        return;
-    }
-    const isNegative = value < 0n;
-    if (isNegative)
-        value = -value;
-    // build big-endian magnitude
-    const magBytes = [];
-    while (value > 0n) {
-        magBytes.push(Number(value & 0xffn));
-        value >>= 8n;
-    }
-    magBytes.reverse(); // now big-endian
-    const len = magBytes.length;
-    if (len === 0 || len > 16) {
-        throw new Error('bad_varint_length');
-    }
-    // Rust also rejects leading zero in decode; we don't generate those here
-    if (magBytes[0] === 0) {
-        throw new Error('varint_leading_zero');
-    }
-    const header = ((isNegative ? 1 : 0) << 7) | len;
-    out.push(header);
-    appendBytes(out, magBytes);
+	let value = typeof n === "bigint" ? n : BigInt(n);
+	if (value === 0n) {
+		out.push(0);
+		return;
+	}
+	const isNegative = value < 0n;
+	if (isNegative) value = -value;
+	const magBytes = [];
+	while (value > 0n) {
+		magBytes.push(Number(value & 255n));
+		value >>= 8n;
+	}
+	magBytes.reverse();
+	const len = magBytes.length;
+	if (len === 0 || len > 16) throw new Error("bad_varint_length");
+	if (magBytes[0] === 0) throw new Error("varint_leading_zero");
+	const header = (isNegative ? 1 : 0) << 7 | len;
+	out.push(header);
+	appendBytes(out, magBytes);
 }
 function decodeVarint(data, ref) {
-    const header = data[ref.offset++];
-    if (header === 0)
-        return 0n;
-    if (header === 0x80)
-        throw new Error('noncanonical_zero');
-    const signBit = header >> 7;
-    const length = header & 0x7f;
-    let mag = 0n;
-    for (let i = 0; i < length; i++) {
-        mag = (mag << 8n) | BigInt(data[ref.offset++]);
-    }
-    if (signBit === 1) {
-        return -mag;
-    }
-    else {
-        return mag;
-    }
+	const header = data[ref.offset++];
+	if (header === 0) return 0n;
+	if (header === 128) throw new Error("noncanonical_zero");
+	const signBit = header >> 7;
+	const length = header & 127;
+	let mag = 0n;
+	for (let i = 0; i < length; i++) mag = mag << 8n | BigInt(data[ref.offset++]);
+	if (signBit === 1) return -mag;
+	else return mag;
 }
 function decodeVarintGteZero(data, ref) {
-    const n = decodeVarint(data, ref);
-    if (n < 0n) {
-        throw new Error('length_is_negative');
-    }
-    if (n > BigInt(Number.MAX_SAFE_INTEGER)) {
-        throw new Error('length_overflow');
-    }
-    return Number(n);
+	const n = decodeVarint(data, ref);
+	if (n < 0n) throw new Error("length_is_negative");
+	if (n > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("length_overflow");
+	return Number(n);
 }
 function encodeTerm(value, out) {
-    if (value === null) {
-        out.push(TYPE_NULL);
-    }
-    else if (typeof value === 'boolean') {
-        out.push(value ? TYPE_TRUE : TYPE_FALSE);
-    }
-    else if (typeof value === 'number' || typeof value === 'bigint') {
-        out.push(TYPE_INT);
-        encodeVarint(value, out);
-    }
-    else if (typeof value === 'string') {
-        out.push(TYPE_BYTES);
-        const utf8 = new TextEncoder().encode(value);
-        encodeVarint(utf8.length, out);
-        appendBytes(out, utf8);
-    }
-    else if (value instanceof Uint8Array) {
-        out.push(TYPE_BYTES);
-        encodeVarint(value.length, out);
-        appendBytes(out, value);
-    }
-    else if (Array.isArray(value)) {
-        out.push(TYPE_LIST);
-        encodeVarint(value.length, out);
-        for (const element of value) {
-            encodeTerm(element, out);
-        }
-    }
-    else if (value instanceof Map ||
-        (typeof value === 'object' && !Array.isArray(value) && !(value instanceof Uint8Array))) {
-        const entries = [];
-        if (value instanceof Map) {
-            for (const [k, v] of value.entries()) {
-                const bytes = encodeKeyBytes(k); // encodes key as Term
-                entries.push({ k, v, bytes });
-            }
-        }
-        else {
-            for (const k of Object.keys(value)) {
-                const v = value[k];
-                const bytes = encodeKeyBytes(k); // k is string; still encoded via encodeValue
-                entries.push({ k, v, bytes });
-            }
-        }
-        entries.sort((a, b) => compareBytes(a.bytes, b.bytes));
-        out.push(TYPE_MAP);
-        encodeVarint(entries.length, out);
-        for (const entry of entries) {
-            encodeTerm(entry.k, out);
-            encodeTerm(entry.v, out);
-        }
-    }
-    else {
-        throw new Error(`Unsupported type: ${typeof value}`);
-    }
+	if (value === null) out.push(TYPE_NULL);
+	else if (typeof value === "boolean") out.push(value ? TYPE_TRUE : TYPE_FALSE);
+	else if (typeof value === "number" || typeof value === "bigint") {
+		out.push(TYPE_INT);
+		encodeVarint(value, out);
+	} else if (typeof value === "string") {
+		out.push(TYPE_BYTES);
+		const utf8 = new TextEncoder().encode(value);
+		encodeVarint(utf8.length, out);
+		appendBytes(out, utf8);
+	} else if (value instanceof Uint8Array) {
+		out.push(TYPE_BYTES);
+		encodeVarint(value.length, out);
+		appendBytes(out, value);
+	} else if (Array.isArray(value)) {
+		out.push(TYPE_LIST);
+		encodeVarint(value.length, out);
+		for (const element of value) encodeTerm(element, out);
+	} else if (value instanceof Map || typeof value === "object" && !Array.isArray(value) && !(value instanceof Uint8Array)) {
+		const entries = [];
+		if (value instanceof Map) for (const [k, v] of value.entries()) {
+			const bytes = encodeKeyBytes(k);
+			entries.push({
+				k,
+				v,
+				bytes
+			});
+		}
+		else for (const k of Object.keys(value)) {
+			const v = value[k];
+			const bytes = encodeKeyBytes(k);
+			entries.push({
+				k,
+				v,
+				bytes
+			});
+		}
+		entries.sort((a, b) => compareBytes(a.bytes, b.bytes));
+		out.push(TYPE_MAP);
+		encodeVarint(entries.length, out);
+		for (const entry of entries) {
+			encodeTerm(entry.k, out);
+			encodeTerm(entry.v, out);
+		}
+	} else throw new Error(`Unsupported type: ${typeof value}`);
 }
 function decodeTerm(data, ref) {
-    if (ref.offset >= data.length) {
-        throw new Error('decodeBytes: Out of bounds read');
-    }
-    const type = data[ref.offset++];
-    switch (type) {
-        case TYPE_NULL:
-            return null;
-        case TYPE_TRUE:
-            return true;
-        case TYPE_FALSE:
-            return false;
-        case TYPE_INT:
-            return decodeVarint(data, ref);
-        case TYPE_BYTES: {
-            const length = decodeVarintGteZero(data, ref);
-            const bytes = data.slice(ref.offset, ref.offset + length);
-            ref.offset += length;
-            return bytes;
-        }
-        case TYPE_LIST: {
-            const count = decodeVarintGteZero(data, ref);
-            const items = new Array(count);
-            for (let i = 0; i < count; i++) {
-                items[i] = decodeTerm(data, ref);
-            }
-            return items;
-        }
-        case TYPE_MAP: {
-            const count = decodeVarintGteZero(data, ref);
-            let prevKeyBytes = null;
-            const map = new Map();
-            for (let idx = 0; idx < count; idx++) {
-                // canonical check: track raw key bytes
-                const kStart = ref.offset;
-                const key = decodeTerm(data, ref);
-                const kEnd = ref.offset;
-                const keyBytes = data.slice(kStart, kEnd);
-                if (prevKeyBytes !== null) {
-                    if (compareBytes(keyBytes, prevKeyBytes) <= 0) {
-                        throw new Error('map_not_canonical');
-                    }
-                }
-                prevKeyBytes = keyBytes;
-                const value = decodeTerm(data, ref);
-                map.set(key, value);
-            }
-            return map;
-        }
-        default:
-            throw new Error('decodeBytes: Unknown type');
-    }
+	if (ref.offset >= data.length) throw new Error("decodeBytes: Out of bounds read");
+	switch (data[ref.offset++]) {
+		case TYPE_NULL: return null;
+		case TYPE_TRUE: return true;
+		case TYPE_FALSE: return false;
+		case TYPE_INT: return decodeVarint(data, ref);
+		case TYPE_BYTES: {
+			const length = decodeVarintGteZero(data, ref);
+			const bytes = data.slice(ref.offset, ref.offset + length);
+			ref.offset += length;
+			return bytes;
+		}
+		case TYPE_LIST: {
+			const count = decodeVarintGteZero(data, ref);
+			const items = new Array(count);
+			for (let i = 0; i < count; i++) items[i] = decodeTerm(data, ref);
+			return items;
+		}
+		case TYPE_MAP: {
+			const count = decodeVarintGteZero(data, ref);
+			let prevKeyBytes = null;
+			const map = /* @__PURE__ */ new Map();
+			for (let idx = 0; idx < count; idx++) {
+				const kStart = ref.offset;
+				const key = decodeTerm(data, ref);
+				const kEnd = ref.offset;
+				const keyBytes = data.slice(kStart, kEnd);
+				if (prevKeyBytes !== null) {
+					if (compareBytes(keyBytes, prevKeyBytes) <= 0) throw new Error("map_not_canonical");
+				}
+				prevKeyBytes = keyBytes;
+				const value = decodeTerm(data, ref);
+				map.set(key, value);
+			}
+			return map;
+		}
+		default: throw new Error("decodeBytes: Unknown type");
+	}
 }
+//#endregion
+export { decode, decodeContractState, encode };
+
 //# sourceMappingURL=serialization.js.map

package/dist/serialization.js.map

@@ -1 +1 @@
-{"version":3,"file":"serialization.js","sourceRoot":"","sources":["../src/serialization.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"serialization.js","names":[],"sources":["../src/serialization.ts"],"sourcesContent":["/**\n * VecPack Canonical Serialization Format\n *\n * This module implements the VecPack canonical serialization format used by Amadeus.\n * VecPack provides deterministic, canonical encoding of values for use in cryptographic\n * operations (e.g., transaction signing). It ensures that equivalent data structures\n * always serialize to the same byte sequence through canonical ordering of map keys.\n *\n * Format specification:\n * - Supports: null, booleans, integers (varint), bytes, lists, and maps\n * - Maps/objects are sorted by their encoded key bytes for canonical ordering\n * - Varints are limited to 16 bytes maximum\n * - Zero values are encoded as a single 0x00 byte\n */\n\nconst TYPE_NULL = 0x00\nconst TYPE_TRUE = 0x01\nconst TYPE_FALSE = 0x02\nconst TYPE_INT = 0x03\nconst TYPE_BYTES = 0x05\nconst TYPE_LIST = 0x06\nconst TYPE_MAP = 0x07\n\nimport type { DecodedValue, SerializableValue } from './types'\n\ninterface DecodeRef {\n\toffset: number\n}\n\n/**\n * Encode a value into canonical serialization format\n *\n * @param term - The value to encode\n * @returns Encoded bytes as Uint8Array\n * @throws Error if the value contains unsupported types\n *\n * @example\n * ```ts\n * const encoded = encode({ foo: 'bar', count: 42 })\n * ```\n */\nexport function encode(term: SerializableValue): Uint8Array {\n\tconst bytesOut: number[] = []\n\tencodeTerm(term, bytesOut)\n\treturn new Uint8Array(bytesOut)\n}\n\n/**\n * Decode a value from canonical serialization format\n *\n * @param bytes - The encoded bytes to decode\n * @returns Decoded value\n * @throws Error if the bytes are invalid or contain trailing bytes\n *\n * @example\n * ```ts\n * const decoded = decode(encodedBytes)\n * ```\n */\nexport function decode(bytes: Uint8Array | number[]): DecodedValue {\n\tconst data = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes)\n\tconst ref: DecodeRef = { offset: 0 }\n\tconst value = decodeTerm(data, ref)\n\tif (ref.offset !== data.length) {\n\t\tthrow new Error('trailing_bytes')\n\t}\n\treturn value\n}\n\n/**\n * Decode VecPack-encoded contract state into key-value pairs\n *\n * Contract state prefix queries return a VecPack-encoded map where both\n * keys and values are binary (Uint8Array). This convenience function decodes\n * the binary data and returns the entries as an array of tuples.\n *\n * @param bytes - VecPack-encoded bytes (Uint8Array or ArrayBuffer)\n * @returns Array of [key, value] tuples\n * @throws Error if the data is not a valid VecPack map or entries are not binary\n *\n * @example\n * ```ts\n * const response = await fetch('/contract/state/prefix?prefix=...')\n * const buffer = await response.arrayBuffer()\n * const entries = decodeContractState(buffer)\n * for (const [key, value] of entries) {\n *   console.log(key, value)\n * }\n * ```\n */\nexport function decodeContractState(\n\tbytes: Uint8Array | ArrayBuffer\n): Array<[Uint8Array, Uint8Array]> {\n\tconst data = bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes\n\tconst decoded = decode(data)\n\n\tif (!(decoded instanceof Map)) {\n\t\tthrow new Error(`Expected MAP type, got ${typeof decoded}`)\n\t}\n\n\tconst result: Array<[Uint8Array, Uint8Array]> = []\n\tfor (const [key, value] of decoded.entries()) {\n\t\tif (!(key instanceof Uint8Array) || !(value instanceof Uint8Array)) {\n\t\t\tthrow new Error('Expected Uint8Array for key and value')\n\t\t}\n\t\tresult.push([key, value])\n\t}\n\n\treturn result\n}\n\n/*\n * Helper functions for encoding and decoding\n */\nfunction appendBytes(out: number[], bytes: Uint8Array | number[]): void {\n\tfor (const b of bytes) {\n\t\tout.push(b)\n\t}\n}\n\nfunction compareBytes(a: Uint8Array | number[], b: Uint8Array | number[]): number {\n\tconst n = Math.min(a.length, b.length)\n\tfor (let i = 0; i < n; i++) {\n\t\tif (a[i] !== b[i]) return a[i] - b[i]\n\t}\n\treturn a.length - b.length // shorter wins if prefix equal\n}\n\nfunction encodeKeyBytes(k: SerializableValue): number[] {\n\tconst tmp: number[] = []\n\tencodeTerm(k, tmp)\n\treturn tmp\n}\n\nfunction encodeVarint(n: number | bigint, out: number[]): void {\n\tlet value = typeof n === 'bigint' ? n : BigInt(n)\n\n\tif (value === 0n) {\n\t\tout.push(0)\n\t\treturn\n\t}\n\n\tconst isNegative = value < 0n\n\tif (isNegative) value = -value\n\n\t// build big-endian magnitude\n\tconst magBytes: number[] = []\n\twhile (value > 0n) {\n\t\tmagBytes.push(Number(value & 0xffn))\n\t\tvalue >>= 8n\n\t}\n\tmagBytes.reverse() // now big-endian\n\n\tconst len = magBytes.length\n\tif (len === 0 || len > 16) {\n\t\tthrow new Error('bad_varint_length')\n\t}\n\n\t// Rust also rejects leading zero in decode; we don't generate those here\n\tif (magBytes[0] === 0) {\n\t\tthrow new Error('varint_leading_zero')\n\t}\n\n\tconst header = ((isNegative ? 1 : 0) << 7) | len\n\tout.push(header)\n\tappendBytes(out, magBytes)\n}\n\nfunction decodeVarint(data: Uint8Array, ref: DecodeRef): bigint {\n\tconst header = data[ref.offset++]\n\tif (header === 0) return 0n\n\tif (header === 0x80) throw new Error('noncanonical_zero')\n\n\tconst signBit = header >> 7\n\tconst length = header & 0x7f\n\n\tlet mag = 0n\n\tfor (let i = 0; i < length; i++) {\n\t\tmag = (mag << 8n) | BigInt(data[ref.offset++])\n\t}\n\n\tif (signBit === 1) {\n\t\treturn -mag\n\t} else {\n\t\treturn mag\n\t}\n}\n\nfunction decodeVarintGteZero(data: Uint8Array, ref: DecodeRef): number {\n\tconst n = decodeVarint(data, ref)\n\tif (n < 0n) {\n\t\tthrow new Error('length_is_negative')\n\t}\n\tif (n > BigInt(Number.MAX_SAFE_INTEGER)) {\n\t\tthrow new Error('length_overflow')\n\t}\n\treturn Number(n)\n}\n\nfunction encodeTerm(value: SerializableValue, out: number[]): void {\n\tif (value === null) {\n\t\tout.push(TYPE_NULL)\n\t} else if (typeof value === 'boolean') {\n\t\tout.push(value ? TYPE_TRUE : TYPE_FALSE)\n\t} else if (typeof value === 'number' || typeof value === 'bigint') {\n\t\tout.push(TYPE_INT)\n\t\tencodeVarint(value, out)\n\t} else if (typeof value === 'string') {\n\t\tout.push(TYPE_BYTES)\n\t\tconst utf8 = new TextEncoder().encode(value)\n\t\tencodeVarint(utf8.length, out)\n\t\tappendBytes(out, utf8)\n\t} else if (value instanceof Uint8Array) {\n\t\tout.push(TYPE_BYTES)\n\t\tencodeVarint(value.length, out)\n\t\tappendBytes(out, value)\n\t} else if (Array.isArray(value)) {\n\t\tout.push(TYPE_LIST)\n\t\tencodeVarint(value.length, out)\n\t\tfor (const element of value) {\n\t\t\tencodeTerm(element, out)\n\t\t}\n\t} else if (\n\t\tvalue instanceof Map ||\n\t\t(typeof value === 'object' && !Array.isArray(value) && !(value instanceof Uint8Array))\n\t) {\n\t\tconst entries: Array<{ k: SerializableValue; v: SerializableValue; bytes: number[] }> = []\n\t\tif (value instanceof Map) {\n\t\t\tfor (const [k, v] of value.entries()) {\n\t\t\t\tconst bytes = encodeKeyBytes(k) // encodes key as Term\n\t\t\t\tentries.push({ k, v, bytes })\n\t\t\t}\n\t\t} else {\n\t\t\tfor (const k of Object.keys(value)) {\n\t\t\t\tconst v = value[k]\n\t\t\t\tconst bytes = encodeKeyBytes(k) // k is string; still encoded via encodeValue\n\t\t\t\tentries.push({ k, v, bytes })\n\t\t\t}\n\t\t}\n\t\tentries.sort((a, b) => compareBytes(a.bytes, b.bytes))\n\n\t\tout.push(TYPE_MAP)\n\t\tencodeVarint(entries.length, out)\n\t\tfor (const entry of entries) {\n\t\t\tencodeTerm(entry.k, out)\n\t\t\tencodeTerm(entry.v, out)\n\t\t}\n\t} else {\n\t\tthrow new Error(`Unsupported type: ${typeof value}`)\n\t}\n}\n\nfunction decodeTerm(data: Uint8Array, ref: DecodeRef): DecodedValue {\n\tif (ref.offset >= data.length) {\n\t\tthrow new Error('decodeBytes: Out of bounds read')\n\t}\n\n\tconst type = data[ref.offset++]\n\n\tswitch (type) {\n\t\tcase TYPE_NULL:\n\t\t\treturn null\n\t\tcase TYPE_TRUE:\n\t\t\treturn true\n\t\tcase TYPE_FALSE:\n\t\t\treturn false\n\t\tcase TYPE_INT:\n\t\t\treturn decodeVarint(data, ref)\n\t\tcase TYPE_BYTES: {\n\t\t\tconst length = decodeVarintGteZero(data, ref)\n\t\t\tconst bytes = data.slice(ref.offset, ref.offset + length)\n\t\t\tref.offset += length\n\t\t\treturn bytes\n\t\t}\n\t\tcase TYPE_LIST: {\n\t\t\tconst count = decodeVarintGteZero(data, ref)\n\t\t\tconst items: DecodedValue[] = new Array(count)\n\t\t\tfor (let i = 0; i < count; i++) {\n\t\t\t\titems[i] = decodeTerm(data, ref)\n\t\t\t}\n\t\t\treturn items\n\t\t}\n\t\tcase TYPE_MAP: {\n\t\t\tconst count = decodeVarintGteZero(data, ref)\n\n\t\t\tlet prevKeyBytes: Uint8Array | null = null\n\t\t\tconst map = new Map<DecodedValue, DecodedValue>()\n\n\t\t\tfor (let idx = 0; idx < count; idx++) {\n\t\t\t\t// canonical check: track raw key bytes\n\t\t\t\tconst kStart = ref.offset\n\t\t\t\tconst key = decodeTerm(data, ref)\n\t\t\t\tconst kEnd = ref.offset\n\t\t\t\tconst keyBytes = data.slice(kStart, kEnd)\n\n\t\t\t\tif (prevKeyBytes !== null) {\n\t\t\t\t\tif (compareBytes(keyBytes, prevKeyBytes) <= 0) {\n\t\t\t\t\t\tthrow new Error('map_not_canonical')\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tprevKeyBytes = keyBytes\n\n\t\t\t\tconst value = decodeTerm(data, ref)\n\t\t\t\tmap.set(key, value)\n\t\t\t}\n\t\t\treturn map\n\t\t}\n\t\tdefault:\n\t\t\tthrow new Error('decodeBytes: Unknown type')\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;AAeA,MAAM,YAAY;AAClB,MAAM,YAAY;AAClB,MAAM,aAAa;AACnB,MAAM,WAAW;AACjB,MAAM,aAAa;AACnB,MAAM,YAAY;AAClB,MAAM,WAAW;;;;;;;;;;;;;AAoBjB,SAAgB,OAAO,MAAqC;CAC3D,MAAM,WAAqB,EAAE;CAC7B,WAAW,MAAM,SAAS;CAC1B,OAAO,IAAI,WAAW,SAAS;;;;;;;;;;;;;;AAehC,SAAgB,OAAO,OAA4C;CAClE,MAAM,OAAO,iBAAiB,aAAa,QAAQ,IAAI,WAAW,MAAM;CACxE,MAAM,MAAiB,EAAE,QAAQ,GAAG;CACpC,MAAM,QAAQ,WAAW,MAAM,IAAI;CACnC,IAAI,IAAI,WAAW,KAAK,QACvB,MAAM,IAAI,MAAM,iBAAiB;CAElC,OAAO;;;;;;;;;;;;;;;;;;;;;;;AAwBR,SAAgB,oBACf,OACkC;CAElC,MAAM,UAAU,OADH,iBAAiB,cAAc,IAAI,WAAW,MAAM,GAAG,MACxC;CAE5B,IAAI,EAAE,mBAAmB,MACxB,MAAM,IAAI,MAAM,0BAA0B,OAAO,UAAU;CAG5D,MAAM,SAA0C,EAAE;CAClD,KAAK,MAAM,CAAC,KAAK,UAAU,QAAQ,SAAS,EAAE;EAC7C,IAAI,EAAE,eAAe,eAAe,EAAE,iBAAiB,aACtD,MAAM,IAAI,MAAM,wCAAwC;EAEzD,OAAO,KAAK,CAAC,KAAK,MAAM,CAAC;;CAG1B,OAAO;;AAMR,SAAS,YAAY,KAAe,OAAoC;CACvE,KAAK,MAAM,KAAK,OACf,IAAI,KAAK,EAAE;;AAIb,SAAS,aAAa,GAA0B,GAAkC;CACjF,MAAM,IAAI,KAAK,IAAI,EAAE,QAAQ,EAAE,OAAO;CACtC,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KACtB,IAAI,EAAE,OAAO,EAAE,IAAI,OAAO,EAAE,KAAK,EAAE;CAEpC,OAAO,EAAE,SAAS,EAAE;;AAGrB,SAAS,eAAe,GAAgC;CACvD,MAAM,MAAgB,EAAE;CACxB,WAAW,GAAG,IAAI;CAClB,OAAO;;AAGR,SAAS,aAAa,GAAoB,KAAqB;CAC9D,IAAI,QAAQ,OAAO,MAAM,WAAW,IAAI,OAAO,EAAE;CAEjD,IAAI,UAAU,IAAI;EACjB,IAAI,KAAK,EAAE;EACX;;CAGD,MAAM,aAAa,QAAQ;CAC3B,IAAI,YAAY,QAAQ,CAAC;CAGzB,MAAM,WAAqB,EAAE;CAC7B,OAAO,QAAQ,IAAI;EAClB,SAAS,KAAK,OAAO,QAAQ,KAAM,CAAC;EACpC,UAAU;;CAEX,SAAS,SAAS;CAElB,MAAM,MAAM,SAAS;CACrB,IAAI,QAAQ,KAAK,MAAM,IACtB,MAAM,IAAI,MAAM,oBAAoB;CAIrC,IAAI,SAAS,OAAO,GACnB,MAAM,IAAI,MAAM,sBAAsB;CAGvC,MAAM,UAAW,aAAa,IAAI,MAAM,IAAK;CAC7C,IAAI,KAAK,OAAO;CAChB,YAAY,KAAK,SAAS;;AAG3B,SAAS,aAAa,MAAkB,KAAwB;CAC/D,MAAM,SAAS,KAAK,IAAI;CACxB,IAAI,WAAW,GAAG,OAAO;CACzB,IAAI,WAAW,KAAM,MAAM,IAAI,MAAM,oBAAoB;CAEzD,MAAM,UAAU,UAAU;CAC1B,MAAM,SAAS,SAAS;CAExB,IAAI,MAAM;CACV,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,KAC3B,MAAO,OAAO,KAAM,OAAO,KAAK,IAAI,UAAU;CAG/C,IAAI,YAAY,GACf,OAAO,CAAC;MAER,OAAO;;AAIT,SAAS,oBAAoB,MAAkB,KAAwB;CACtE,MAAM,IAAI,aAAa,MAAM,IAAI;CACjC,IAAI,IAAI,IACP,MAAM,IAAI,MAAM,qBAAqB;CAEtC,IAAI,IAAI,OAAO,OAAO,iBAAiB,EACtC,MAAM,IAAI,MAAM,kBAAkB;CAEnC,OAAO,OAAO,EAAE;;AAGjB,SAAS,WAAW,OAA0B,KAAqB;CAClE,IAAI,UAAU,MACb,IAAI,KAAK,UAAU;MACb,IAAI,OAAO,UAAU,WAC3B,IAAI,KAAK,QAAQ,YAAY,WAAW;MAClC,IAAI,OAAO,UAAU,YAAY,OAAO,UAAU,UAAU;EAClE,IAAI,KAAK,SAAS;EAClB,aAAa,OAAO,IAAI;QAClB,IAAI,OAAO,UAAU,UAAU;EACrC,IAAI,KAAK,WAAW;EACpB,MAAM,OAAO,IAAI,aAAa,CAAC,OAAO,MAAM;EAC5C,aAAa,KAAK,QAAQ,IAAI;EAC9B,YAAY,KAAK,KAAK;QAChB,IAAI,iBAAiB,YAAY;EACvC,IAAI,KAAK,WAAW;EACpB,aAAa,MAAM,QAAQ,IAAI;EAC/B,YAAY,KAAK,MAAM;QACjB,IAAI,MAAM,QAAQ,MAAM,EAAE;EAChC,IAAI,KAAK,UAAU;EACnB,aAAa,MAAM,QAAQ,IAAI;EAC/B,KAAK,MAAM,WAAW,OACrB,WAAW,SAAS,IAAI;QAEnB,IACN,iBAAiB,OAChB,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,MAAM,IAAI,EAAE,iBAAiB,aACzE;EACD,MAAM,UAAkF,EAAE;EAC1F,IAAI,iBAAiB,KACpB,KAAK,MAAM,CAAC,GAAG,MAAM,MAAM,SAAS,EAAE;GACrC,MAAM,QAAQ,eAAe,EAAE;GAC/B,QAAQ,KAAK;IAAE;IAAG;IAAG;IAAO,CAAC;;OAG9B,KAAK,MAAM,KAAK,OAAO,KAAK,MAAM,EAAE;GACnC,MAAM,IAAI,MAAM;GAChB,MAAM,QAAQ,eAAe,EAAE;GAC/B,QAAQ,KAAK;IAAE;IAAG;IAAG;IAAO,CAAC;;EAG/B,QAAQ,MAAM,GAAG,MAAM,aAAa,EAAE,OAAO,EAAE,MAAM,CAAC;EAEtD,IAAI,KAAK,SAAS;EAClB,aAAa,QAAQ,QAAQ,IAAI;EACjC,KAAK,MAAM,SAAS,SAAS;GAC5B,WAAW,MAAM,GAAG,IAAI;GACxB,WAAW,MAAM,GAAG,IAAI;;QAGzB,MAAM,IAAI,MAAM,qBAAqB,OAAO,QAAQ;;AAItD,SAAS,WAAW,MAAkB,KAA8B;CACnE,IAAI,IAAI,UAAU,KAAK,QACtB,MAAM,IAAI,MAAM,kCAAkC;CAKnD,QAFa,KAAK,IAAI,WAEtB;EACC,KAAK,WACJ,OAAO;EACR,KAAK,WACJ,OAAO;EACR,KAAK,YACJ,OAAO;EACR,KAAK,UACJ,OAAO,aAAa,MAAM,IAAI;EAC/B,KAAK,YAAY;GAChB,MAAM,SAAS,oBAAoB,MAAM,IAAI;GAC7C,MAAM,QAAQ,KAAK,MAAM,IAAI,QAAQ,IAAI,SAAS,OAAO;GACzD,IAAI,UAAU;GACd,OAAO;;EAER,KAAK,WAAW;GACf,MAAM,QAAQ,oBAAoB,MAAM,IAAI;GAC5C,MAAM,QAAwB,IAAI,MAAM,MAAM;GAC9C,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAC1B,MAAM,KAAK,WAAW,MAAM,IAAI;GAEjC,OAAO;;EAER,KAAK,UAAU;GACd,MAAM,QAAQ,oBAAoB,MAAM,IAAI;GAE5C,IAAI,eAAkC;GACtC,MAAM,sBAAM,IAAI,KAAiC;GAEjD,KAAK,IAAI,MAAM,GAAG,MAAM,OAAO,OAAO;IAErC,MAAM,SAAS,IAAI;IACnB,MAAM,MAAM,WAAW,MAAM,IAAI;IACjC,MAAM,OAAO,IAAI;IACjB,MAAM,WAAW,KAAK,MAAM,QAAQ,KAAK;IAEzC,IAAI,iBAAiB;SAChB,aAAa,UAAU,aAAa,IAAI,GAC3C,MAAM,IAAI,MAAM,oBAAoB;;IAGtC,eAAe;IAEf,MAAM,QAAQ,WAAW,MAAM,IAAI;IACnC,IAAI,IAAI,KAAK,MAAM;;GAEpB,OAAO;;EAER,SACC,MAAM,IAAI,MAAM,4BAA4B"}