@algorandfoundation/algokit-utils 9.2.0 → 10.0.0-alpha.10

package/packages/sdk/src/encoding/encoding.d.ts

@@ -0,0 +1,237 @@
+import { IntDecoding } from "../types/intDecoding.js";
+import { RawBinaryString } from "algorand-msgpack";
+
+//#region packages/sdk/src/encoding/encoding.d.ts
+
+declare const ERROR_CONTAINS_EMPTY_STRING = "The object contains empty or 0 values. First empty or 0 value encountered during encoding: ";
+/**
+ * msgpackRawEncode encodes objects using msgpack, regardless of whether there are
+ * empty or 0 value fields.
+ * @param obj - a dictionary to be encoded. May or may not contain empty or 0 values.
+ * @returns msgpack representation of the object
+ */
+declare function msgpackRawEncode(obj: unknown): Uint8Array;
+/**
+ * encodeObj takes a javascript object and returns its msgpack encoding
+ * Note that the encoding sorts the fields alphabetically
+ * @param o - js object to be encoded. Must not contain empty or 0 values.
+ * @returns Uint8Array binary representation
+ * @throws Error containing ERROR_CONTAINS_EMPTY_STRING if the object contains empty or zero values
+ *
+ * @deprecated Use {@link msgpackRawEncode} instead. Note that function does not
+ *   check for empty values like this one does.
+ */
+declare function encodeObj(obj: Record<string | number | symbol, any>): Uint8Array;
+/**
+ * Decodes msgpack bytes into a plain JavaScript object.
+ * @param buffer - The msgpack bytes to decode
+ * @param options - Options for decoding, including int decoding mode. See {@link IntDecoding} for more information.
+ * @returns The decoded object
+ */
+declare function msgpackRawDecode(buffer: ArrayLike<number>, options?: {
+  intDecoding: IntDecoding;
+}): unknown;
+/**
+ * decodeObj takes a Uint8Array and returns its javascript obj
+ * @param o - Uint8Array to decode
+ * @returns object
+ *
+ * @deprecated Use {@link msgpackRawDecode} instead. Note that this function uses `IntDecoding.MIXED`
+ *   while `msgpackRawDecode` defaults to `IntDecoding.BIGINT` for int decoding, though it is
+ *   configurable.
+ */
+declare function decodeObj(o: ArrayLike<number>): unknown;
+/**
+ * Decodes msgpack bytes into a Map object. This supports decoding non-string map keys.
+ * @param encoded - The msgpack bytes to decode
+ * @param options - Options for decoding, including int decoding mode. See {@link IntDecoding} for more information.
+ * @returns The decoded Map object
+ */
+declare function msgpackRawDecodeAsMap(encoded: ArrayLike<number>, options?: {
+  intDecoding: IntDecoding;
+}): unknown;
+type MsgpackEncodingData = null | undefined | string | number | bigint | boolean | Uint8Array | MsgpackEncodingData[] | Map<string | number | bigint | Uint8Array, MsgpackEncodingData>;
+type JSONEncodingData = null | undefined | string | number | bigint | boolean | JSONEncodingData[] | {
+  [key: string]: JSONEncodingData;
+};
+declare function msgpackEncodingDataToJSONEncodingData(e: MsgpackEncodingData): JSONEncodingData;
+declare function jsonEncodingDataToMsgpackEncodingData(e: JSONEncodingData): MsgpackEncodingData;
+declare enum MsgpackObjectPathSegmentKind {
+  MAP_VALUE = 0,
+  ARRAY_ELEMENT = 1,
+}
+interface MsgpackObjectPathSegment {
+  kind: MsgpackObjectPathSegmentKind;
+  key: string | number | bigint | Uint8Array | RawBinaryString;
+}
+/**
+ * This class is used to index into an encoded msgpack object and extract raw strings.
+ */
+declare class MsgpackRawStringProvider {
+  private readonly parent?;
+  private readonly baseObjectBytes?;
+  private readonly segment?;
+  private resolvedCache;
+  private resolvedCachePresent;
+  constructor({
+    parent,
+    segment,
+    baseObjectBytes
+  }: {
+    parent: MsgpackRawStringProvider;
+    segment: MsgpackObjectPathSegment;
+    baseObjectBytes?: undefined;
+  } | {
+    parent?: undefined;
+    segment?: undefined;
+    baseObjectBytes: ArrayLike<number>;
+  });
+  /**
+   * Create a new provider that resolves to the current provider's map value at the given key.
+   */
+  withMapValue(key: string | number | bigint | Uint8Array | RawBinaryString): MsgpackRawStringProvider;
+  /**
+   * Create a new provider that resolves to the current provider's array element at the given index.
+   */
+  withArrayElement(index: number): MsgpackRawStringProvider;
+  /**
+   * Get the raw string at the current location. If the current location is not a raw string, an error is thrown.
+   */
+  getRawStringAtCurrentLocation(): Uint8Array;
+  /**
+   * Get the raw string map keys and values at the current location. If the current location is not a map, an error is thrown.
+   */
+  getRawStringKeysAndValuesAtCurrentLocation(): Map<Uint8Array, MsgpackEncodingData>;
+  /**
+   * Resolve the provider by extracting the value it indicates from the base msgpack object.
+   */
+  private resolve;
+  /**
+   * Get the path string of the current location indicated by the provider. Useful for debugging.
+   */
+  getPathString(): string;
+}
+/**
+ * Options for {@link Schema.prepareJSON}
+ */
+interface PrepareJSONOptions {
+  /**
+   * If true, allows invalid UTF-8 binary strings to be converted to JSON strings.
+   *
+   * Otherwise, an error will be thrown if encoding a binary string to a JSON cannot be done losslessly.
+   */
+  lossyBinaryStringConversion?: boolean;
+}
+/**
+ * A Schema is used to prepare objects for encoding and decoding from msgpack and JSON.
+ *
+ * Schemas represent a specific type.
+ */
+declare abstract class Schema {
+  /**
+   * Get the default value for this type.
+   */
+  abstract defaultValue(): unknown;
+  /**
+   * Checks if the value is the default value for this type.
+   * @param data - The value to check
+   * @returns True if the value is the default value, false otherwise
+   */
+  abstract isDefaultValue(data: unknown): boolean;
+  /**
+   * Prepares the encoding data for encoding to msgpack.
+   * @param data - Encoding data to be prepared.
+   * @returns A value ready to be msgpack encoded.
+   */
+  abstract prepareMsgpack(data: unknown): MsgpackEncodingData;
+  /**
+   * Restores the encoding data from a msgpack encoding object.
+   * @param encoded - The msgpack encoding object to restore.
+   * @param rawStringProvider - A provider for raw strings.
+   * @returns The original encoding data.
+   */
+  abstract fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): unknown;
+  /**
+   * Prepares the encoding data for encoding to JSON.
+   * @param data - The JSON encoding data to be prepared.
+   * @returns A value ready to be JSON encoded.
+   */
+  abstract prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData;
+  /**
+   * Restores the encoding data from a JSON encoding object.
+   * @param encoded - The JSON encoding object to restore.
+   * @returns The original encoding data.
+   */
+  abstract fromPreparedJSON(encoded: JSONEncodingData): unknown;
+}
+/**
+ * An interface for objects that can be encoded and decoded to/from msgpack and JSON.
+ */
+interface Encodable {
+  /**
+   * Extract the encoding data for this object. This data, after being prepared by the encoding
+   * Schema, can be encoded to msgpack or JSON.
+   */
+  toEncodingData(): unknown;
+  /**
+   * Get the encoding Schema for this object, used to prepare the encoding data for msgpack and JSON.
+   */
+  getEncodingSchema(): Schema;
+}
+/**
+ * A type that represents the class of an Encodable object.
+ */
+interface EncodableClass<T extends Encodable> {
+  /**
+   * Create a new instance of this class from the given encoding data.
+   * @param data - The encoding data to create the object from
+   */
+  fromEncodingData(data: unknown): T;
+  /**
+   * The encoding Schema for this class, used to prepare encoding data from msgpack and JSON.
+   */
+  readonly encodingSchema: Schema;
+}
+/**
+ * Decode a msgpack byte array to an Encodable object.
+ * @param encoded - The msgpack bytes to decode
+ * @param c - The class of the object to decode. This class must match the object that was encoded.
+ * @returns An instance of the class with the decoded data
+ */
+declare function decodeMsgpack<T extends Encodable>(encoded: ArrayLike<number>, c: EncodableClass<T>): T;
+/**
+ * Encode an Encodable object to a msgpack byte array.
+ * @param e - The object to encode
+ * @returns A msgpack byte array encoding of the object
+ */
+declare function encodeMsgpack(e: Encodable): Uint8Array;
+/**
+ * Decode a JSON string to an Encodable object.
+ * @param encoded - The JSON string to decode
+ * @param c - The class of the object to decode. This class must match the object that was encoded.
+ * @returns An instance of the class with the decoded data
+ */
+declare function decodeJSON<T extends Encodable>(encoded: string, c: EncodableClass<T>): T;
+interface EncodeJSONOptions {
+  /**
+   * Adds indentation, white space, and line break characters to the return-value JSON text to make
+   * it easier to read.
+   */
+  space?: string | number;
+  /**
+   * If true, allows invalid UTF-8 binary strings to be converted to JSON strings.
+   *
+   * Otherwise, an error will be thrown if encoding a binary string to a JSON cannot be done losslessly.
+   */
+  lossyBinaryStringConversion?: boolean;
+}
+/**
+ * Encode an Encodable object to a JSON string.
+ * @param e - The object to encode
+ * @param options - Optional encoding options. See {@link EncodeJSONOptions} for more information.
+ * @returns A JSON string encoding of the object
+ */
+declare function encodeJSON(e: Encodable, options?: EncodeJSONOptions): string;
+//#endregion
+export { ERROR_CONTAINS_EMPTY_STRING, Encodable, EncodableClass, EncodeJSONOptions, JSONEncodingData, MsgpackEncodingData, MsgpackRawStringProvider, PrepareJSONOptions, Schema, decodeJSON, decodeMsgpack, decodeObj, encodeJSON, encodeMsgpack, encodeObj, jsonEncodingDataToMsgpackEncodingData, msgpackEncodingDataToJSONEncodingData, msgpackRawDecode, msgpackRawDecodeAsMap, msgpackRawEncode };
+//# sourceMappingURL=encoding.d.ts.map

package/packages/sdk/src/encoding/encoding.js

@@ -0,0 +1,312 @@
+const require_rolldown_runtime = require('../../../../_virtual/rolldown_runtime.js');
+const require_intDecoding = require('../types/intDecoding.js');
+const require_utils = require('../utils/utils.js');
+const require_binarydata = require('./binarydata.js');
+let algorand_msgpack = require("algorand-msgpack");
+
+//#region packages/sdk/src/encoding/encoding.ts
+/**
+* This file is a wrapper of msgpack.js.
+* The wrapper was written in order to ensure correct encoding of Algorand Transaction and other formats.
+* In particular, it matches go-algorand blockchain client, written in go (https://www.github.com/algorand/go-algorand.
+* Algorand's msgpack encoding follows to following rules -
+*  1. Every integer must be encoded to the smallest type possible (0-255-\>8bit, 256-65535-\>16bit, etx)
+*  2. All fields names must be sorted
+*  3. All empty and 0 fields should be omitted
+*  4. Every positive number must be encoded as uint
+*  5. Binary blob should be used for binary data and string for strings
+*  */
+const ERROR_CONTAINS_EMPTY_STRING = "The object contains empty or 0 values. First empty or 0 value encountered during encoding: ";
+/**
+* containsEmpty returns true if any of the object's values are empty, false otherwise.
+* Empty arrays considered empty
+* @param obj - The object to check
+* @returns \{true, empty key\} if contains empty, \{false, undefined\} otherwise
+*/
+function containsEmpty(obj) {
+	for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) {
+		if (!obj[key] || obj[key].length === 0) return {
+			containsEmpty: true,
+			firstEmptyKey: key
+		};
+	}
+	return {
+		containsEmpty: false,
+		firstEmptyKey: void 0
+	};
+}
+/**
+* msgpackRawEncode encodes objects using msgpack, regardless of whether there are
+* empty or 0 value fields.
+* @param obj - a dictionary to be encoded. May or may not contain empty or 0 values.
+* @returns msgpack representation of the object
+*/
+function msgpackRawEncode(obj) {
+	return (0, algorand_msgpack.encode)(obj, { sortKeys: true });
+}
+/**
+* encodeObj takes a javascript object and returns its msgpack encoding
+* Note that the encoding sorts the fields alphabetically
+* @param o - js object to be encoded. Must not contain empty or 0 values.
+* @returns Uint8Array binary representation
+* @throws Error containing ERROR_CONTAINS_EMPTY_STRING if the object contains empty or zero values
+*
+* @deprecated Use {@link msgpackRawEncode} instead. Note that function does not
+*   check for empty values like this one does.
+*/
+function encodeObj(obj) {
+	const emptyCheck = containsEmpty(obj);
+	if (emptyCheck.containsEmpty) throw new Error(ERROR_CONTAINS_EMPTY_STRING + emptyCheck.firstEmptyKey);
+	return msgpackRawEncode(obj);
+}
+function intDecodingToIntMode(intDecoding) {
+	switch (intDecoding) {
+		case require_intDecoding.default.UNSAFE: return algorand_msgpack.IntMode.UNSAFE_NUMBER;
+		case require_intDecoding.default.SAFE: return algorand_msgpack.IntMode.SAFE_NUMBER;
+		case require_intDecoding.default.MIXED: return algorand_msgpack.IntMode.MIXED;
+		case require_intDecoding.default.BIGINT: return algorand_msgpack.IntMode.BIGINT;
+		default: throw new Error(`Invalid intDecoding: ${intDecoding}`);
+	}
+}
+/**
+* Decodes msgpack bytes into a plain JavaScript object.
+* @param buffer - The msgpack bytes to decode
+* @param options - Options for decoding, including int decoding mode. See {@link IntDecoding} for more information.
+* @returns The decoded object
+*/
+function msgpackRawDecode(buffer, options) {
+	return (0, algorand_msgpack.decode)(buffer, { intMode: options?.intDecoding ? intDecodingToIntMode(options?.intDecoding) : algorand_msgpack.IntMode.BIGINT });
+}
+/**
+* decodeObj takes a Uint8Array and returns its javascript obj
+* @param o - Uint8Array to decode
+* @returns object
+*
+* @deprecated Use {@link msgpackRawDecode} instead. Note that this function uses `IntDecoding.MIXED`
+*   while `msgpackRawDecode` defaults to `IntDecoding.BIGINT` for int decoding, though it is
+*   configurable.
+*/
+function decodeObj(o) {
+	return msgpackRawDecode(o, { intDecoding: require_intDecoding.default.MIXED });
+}
+/**
+* Decodes msgpack bytes into a Map object. This supports decoding non-string map keys.
+* @param encoded - The msgpack bytes to decode
+* @param options - Options for decoding, including int decoding mode. See {@link IntDecoding} for more information.
+* @returns The decoded Map object
+*/
+function msgpackRawDecodeAsMap(encoded, options) {
+	return (0, algorand_msgpack.decode)(encoded, {
+		intMode: options?.intDecoding ? intDecodingToIntMode(options?.intDecoding) : algorand_msgpack.IntMode.BIGINT,
+		useMap: true
+	});
+}
+function msgpackRawDecodeAsMapWithRawStrings(encoded, options) {
+	return (0, algorand_msgpack.decode)(encoded, {
+		intMode: options?.intDecoding ? intDecodingToIntMode(options?.intDecoding) : algorand_msgpack.IntMode.BIGINT,
+		useMap: true,
+		rawBinaryStringKeys: true,
+		rawBinaryStringValues: true,
+		useRawBinaryStringClass: true
+	});
+}
+function msgpackEncodingDataToJSONEncodingData(e) {
+	if (e === null || e === void 0) return e;
+	if (e instanceof Uint8Array) return require_binarydata.bytesToBase64(e);
+	if (Array.isArray(e)) return e.map(msgpackEncodingDataToJSONEncodingData);
+	if (e instanceof Map) {
+		const obj = {};
+		for (const [k, v] of e) {
+			if (typeof k !== "string") throw new Error(`JSON map key must be a string: ${k}`);
+			obj[k] = msgpackEncodingDataToJSONEncodingData(v);
+		}
+		return obj;
+	}
+	return e;
+}
+function jsonEncodingDataToMsgpackEncodingData(e) {
+	if (e === null || e === void 0) return e;
+	if (typeof e === "string" || typeof e === "number" || typeof e === "bigint" || typeof e === "boolean") return e;
+	if (Array.isArray(e)) return e.map(jsonEncodingDataToMsgpackEncodingData);
+	if (typeof e === "object") {
+		const obj = /* @__PURE__ */ new Map();
+		for (const [key, value] of Object.entries(e)) obj.set(key, jsonEncodingDataToMsgpackEncodingData(value));
+		return obj;
+	}
+	throw new Error(`Invalid JSON encoding data: ${e}`);
+}
+var MsgpackObjectPathSegmentKind = /* @__PURE__ */ function(MsgpackObjectPathSegmentKind$1) {
+	MsgpackObjectPathSegmentKind$1[MsgpackObjectPathSegmentKind$1["MAP_VALUE"] = 0] = "MAP_VALUE";
+	MsgpackObjectPathSegmentKind$1[MsgpackObjectPathSegmentKind$1["ARRAY_ELEMENT"] = 1] = "ARRAY_ELEMENT";
+	return MsgpackObjectPathSegmentKind$1;
+}(MsgpackObjectPathSegmentKind || {});
+/**
+* This class is used to index into an encoded msgpack object and extract raw strings.
+*/
+var MsgpackRawStringProvider = class MsgpackRawStringProvider {
+	parent;
+	baseObjectBytes;
+	segment;
+	resolvedCache = null;
+	resolvedCachePresent = false;
+	constructor({ parent, segment, baseObjectBytes }) {
+		this.parent = parent;
+		this.segment = segment;
+		this.baseObjectBytes = baseObjectBytes;
+	}
+	/**
+	* Create a new provider that resolves to the current provider's map value at the given key.
+	*/
+	withMapValue(key) {
+		return new MsgpackRawStringProvider({
+			parent: this,
+			segment: {
+				kind: MsgpackObjectPathSegmentKind.MAP_VALUE,
+				key
+			}
+		});
+	}
+	/**
+	* Create a new provider that resolves to the current provider's array element at the given index.
+	*/
+	withArrayElement(index) {
+		return new MsgpackRawStringProvider({
+			parent: this,
+			segment: {
+				kind: MsgpackObjectPathSegmentKind.ARRAY_ELEMENT,
+				key: index
+			}
+		});
+	}
+	/**
+	* Get the raw string at the current location. If the current location is not a raw string, an error is thrown.
+	*/
+	getRawStringAtCurrentLocation() {
+		const resolved = this.resolve();
+		if (resolved instanceof algorand_msgpack.RawBinaryString) return resolved.rawBinaryValue;
+		throw new Error(`Invalid type. Expected RawBinaryString, got ${resolved} (${typeof resolved})`);
+	}
+	/**
+	* Get the raw string map keys and values at the current location. If the current location is not a map, an error is thrown.
+	*/
+	getRawStringKeysAndValuesAtCurrentLocation() {
+		const resolved = this.resolve();
+		if (!(resolved instanceof Map)) throw new Error(`Invalid type. Expected Map, got ${resolved} (${typeof resolved})`);
+		const keysAndValues = /* @__PURE__ */ new Map();
+		for (const [key, value] of resolved) if (key instanceof algorand_msgpack.RawBinaryString) keysAndValues.set(key.rawBinaryValue, value);
+		else throw new Error(`Invalid type for map key. Expected RawBinaryString, got ${key} (${typeof key})`);
+		return keysAndValues;
+	}
+	/**
+	* Resolve the provider by extracting the value it indicates from the base msgpack object.
+	*/
+	resolve() {
+		if (this.resolvedCachePresent) return this.resolvedCache;
+		let parentResolved;
+		if (this.parent) parentResolved = this.parent.resolve();
+		else parentResolved = msgpackRawDecodeAsMapWithRawStrings(this.baseObjectBytes);
+		if (!this.segment) {
+			this.resolvedCache = parentResolved;
+			this.resolvedCachePresent = true;
+			return parentResolved;
+		}
+		if (this.segment.kind === MsgpackObjectPathSegmentKind.MAP_VALUE) {
+			if (!(parentResolved instanceof Map)) throw new Error(`Invalid type. Expected Map, got ${parentResolved} (${typeof parentResolved})`);
+			if (typeof this.segment.key === "string" || this.segment.key instanceof Uint8Array || this.segment.key instanceof algorand_msgpack.RawBinaryString) {
+				const targetBytes = this.segment.key instanceof algorand_msgpack.RawBinaryString ? this.segment.key.rawBinaryValue : require_binarydata.coerceToBytes(this.segment.key);
+				const targetIsRawString = typeof this.segment.key === "string" || this.segment.key instanceof algorand_msgpack.RawBinaryString;
+				for (const [key, value] of parentResolved) {
+					let potentialKeyBytes;
+					if (targetIsRawString) {
+						if (key instanceof algorand_msgpack.RawBinaryString) potentialKeyBytes = key.rawBinaryValue;
+					} else if (key instanceof Uint8Array) potentialKeyBytes = key;
+					if (potentialKeyBytes && require_utils.arrayEqual(targetBytes, potentialKeyBytes)) {
+						this.resolvedCache = value;
+						break;
+					}
+				}
+			} else this.resolvedCache = parentResolved.get(this.segment.key);
+			this.resolvedCachePresent = true;
+			return this.resolvedCache;
+		}
+		if (this.segment.kind === MsgpackObjectPathSegmentKind.ARRAY_ELEMENT) {
+			if (!Array.isArray(parentResolved)) throw new Error(`Invalid type. Expected Array, got ${parentResolved} (${typeof parentResolved})`);
+			this.resolvedCache = parentResolved[this.segment.key];
+			this.resolvedCachePresent = true;
+			return this.resolvedCache;
+		}
+		throw new Error(`Invalid segment kind: ${this.segment.kind}`);
+	}
+	/**
+	* Get the path string of the current location indicated by the provider. Useful for debugging.
+	*/
+	getPathString() {
+		const parentPathString = this.parent ? this.parent.getPathString() : "root";
+		if (!this.segment) return parentPathString;
+		if (this.segment.kind === MsgpackObjectPathSegmentKind.MAP_VALUE) return `${parentPathString} -> map key "${this.segment.key}" (${typeof this.segment.key})`;
+		if (this.segment.kind === MsgpackObjectPathSegmentKind.ARRAY_ELEMENT) return `${parentPathString} -> array index ${this.segment.key} (${typeof this.segment.key})`;
+		return `${parentPathString} -> unknown segment kind ${this.segment.kind}`;
+	}
+};
+/**
+* A Schema is used to prepare objects for encoding and decoding from msgpack and JSON.
+*
+* Schemas represent a specific type.
+*/
+var Schema = class {};
+/**
+* Decode a msgpack byte array to an Encodable object.
+* @param encoded - The msgpack bytes to decode
+* @param c - The class of the object to decode. This class must match the object that was encoded.
+* @returns An instance of the class with the decoded data
+*/
+function decodeMsgpack(encoded, c) {
+	const decoded = msgpackRawDecodeAsMap(encoded);
+	const rawStringProvider = new MsgpackRawStringProvider({ baseObjectBytes: encoded });
+	return c.fromEncodingData(c.encodingSchema.fromPreparedMsgpack(decoded, rawStringProvider));
+}
+/**
+* Encode an Encodable object to a msgpack byte array.
+* @param e - The object to encode
+* @returns A msgpack byte array encoding of the object
+*/
+function encodeMsgpack(e) {
+	return msgpackRawEncode(e.getEncodingSchema().prepareMsgpack(e.toEncodingData()));
+}
+/**
+* Decode a JSON string to an Encodable object.
+* @param encoded - The JSON string to decode
+* @param c - The class of the object to decode. This class must match the object that was encoded.
+* @returns An instance of the class with the decoded data
+*/
+function decodeJSON(encoded, c) {
+	const decoded = require_utils.parseJSON(encoded, { intDecoding: require_intDecoding.default.BIGINT });
+	return c.fromEncodingData(c.encodingSchema.fromPreparedJSON(decoded));
+}
+/**
+* Encode an Encodable object to a JSON string.
+* @param e - The object to encode
+* @param options - Optional encoding options. See {@link EncodeJSONOptions} for more information.
+* @returns A JSON string encoding of the object
+*/
+function encodeJSON(e, options) {
+	const { space, ...prepareJSONOptions } = options ?? {};
+	return require_utils.stringifyJSON(e.getEncodingSchema().prepareJSON(e.toEncodingData(), prepareJSONOptions), void 0, space);
+}
+
+//#endregion
+exports.ERROR_CONTAINS_EMPTY_STRING = ERROR_CONTAINS_EMPTY_STRING;
+exports.MsgpackRawStringProvider = MsgpackRawStringProvider;
+exports.Schema = Schema;
+exports.decodeJSON = decodeJSON;
+exports.decodeMsgpack = decodeMsgpack;
+exports.decodeObj = decodeObj;
+exports.encodeJSON = encodeJSON;
+exports.encodeMsgpack = encodeMsgpack;
+exports.encodeObj = encodeObj;
+exports.jsonEncodingDataToMsgpackEncodingData = jsonEncodingDataToMsgpackEncodingData;
+exports.msgpackEncodingDataToJSONEncodingData = msgpackEncodingDataToJSONEncodingData;
+exports.msgpackRawDecode = msgpackRawDecode;
+exports.msgpackRawDecodeAsMap = msgpackRawDecodeAsMap;
+exports.msgpackRawEncode = msgpackRawEncode;
+//# sourceMappingURL=encoding.js.map

package/packages/sdk/src/encoding/encoding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.js","names":["IntDecoding","IntMode","bytesToBase64","obj: { [key: string]: JSONEncodingData }","RawBinaryString","parentResolved: MsgpackEncodingData","coerceToBytes","potentialKeyBytes: Uint8Array | undefined","arrayEqual","decoded: JSONEncodingData","parseJSON","stringifyJSON"],"sources":["../../../../../packages/sdk/src/encoding/encoding.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/**\n * This file is a wrapper of msgpack.js.\n * The wrapper was written in order to ensure correct encoding of Algorand Transaction and other formats.\n * In particular, it matches go-algorand blockchain client, written in go (https://www.github.com/algorand/go-algorand.\n * Algorand's msgpack encoding follows to following rules -\n *  1. Every integer must be encoded to the smallest type possible (0-255-\\>8bit, 256-65535-\\>16bit, etx)\n *  2. All fields names must be sorted\n *  3. All empty and 0 fields should be omitted\n *  4. Every positive number must be encoded as uint\n *  5. Binary blob should be used for binary data and string for strings\n *  */\n\nimport {\n  DecoderOptions,\n  EncoderOptions,\n  IntMode,\n  RawBinaryString,\n  decode as msgpackDecode,\n  encode as msgpackEncode,\n} from 'algorand-msgpack'\nimport IntDecoding from '../types/intDecoding.js'\nimport { arrayEqual, parseJSON, stringifyJSON } from '../utils/utils.js'\nimport { bytesToBase64, coerceToBytes } from './binarydata.js'\n\n// Errors\nexport const ERROR_CONTAINS_EMPTY_STRING = 'The object contains empty or 0 values. First empty or 0 value encountered during encoding: '\n\n/**\n * containsEmpty returns true if any of the object's values are empty, false otherwise.\n * Empty arrays considered empty\n * @param obj - The object to check\n * @returns \\{true, empty key\\} if contains empty, \\{false, undefined\\} otherwise\n */\nfunction containsEmpty(obj: Record<string | number | symbol, any>) {\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      if (!obj[key] || obj[key].length === 0) {\n        return { containsEmpty: true, firstEmptyKey: key }\n      }\n    }\n  }\n  return { containsEmpty: false, firstEmptyKey: undefined }\n}\n\n/**\n * msgpackRawEncode encodes objects using msgpack, regardless of whether there are\n * empty or 0 value fields.\n * @param obj - a dictionary to be encoded. May or may not contain empty or 0 values.\n * @returns msgpack representation of the object\n */\nexport function msgpackRawEncode(obj: unknown) {\n  // enable the canonical option\n  const options: EncoderOptions = { sortKeys: true }\n  return msgpackEncode(obj, options)\n}\n\n/**\n * encodeObj takes a javascript object and returns its msgpack encoding\n * Note that the encoding sorts the fields alphabetically\n * @param o - js object to be encoded. Must not contain empty or 0 values.\n * @returns Uint8Array binary representation\n * @throws Error containing ERROR_CONTAINS_EMPTY_STRING if the object contains empty or zero values\n *\n * @deprecated Use {@link msgpackRawEncode} instead. Note that function does not\n *   check for empty values like this one does.\n */\nexport function encodeObj(obj: Record<string | number | symbol, any>) {\n  // Check for empty values\n  const emptyCheck = containsEmpty(obj)\n  if (emptyCheck.containsEmpty) {\n    throw new Error(ERROR_CONTAINS_EMPTY_STRING + emptyCheck.firstEmptyKey)\n  }\n  return msgpackRawEncode(obj)\n}\n\nfunction intDecodingToIntMode(intDecoding: IntDecoding): IntMode {\n  switch (intDecoding) {\n    case IntDecoding.UNSAFE:\n      return IntMode.UNSAFE_NUMBER\n    case IntDecoding.SAFE:\n      return IntMode.SAFE_NUMBER\n    case IntDecoding.MIXED:\n      return IntMode.MIXED\n    case IntDecoding.BIGINT:\n      return IntMode.BIGINT\n    default:\n      throw new Error(`Invalid intDecoding: ${intDecoding}`)\n  }\n}\n\n/**\n * Decodes msgpack bytes into a plain JavaScript object.\n * @param buffer - The msgpack bytes to decode\n * @param options - Options for decoding, including int decoding mode. See {@link IntDecoding} for more information.\n * @returns The decoded object\n */\nexport function msgpackRawDecode(buffer: ArrayLike<number>, options?: { intDecoding: IntDecoding }) {\n  const decoderOptions: DecoderOptions = {\n    intMode: options?.intDecoding ? intDecodingToIntMode(options?.intDecoding) : IntMode.BIGINT,\n  }\n  return msgpackDecode(buffer, decoderOptions)\n}\n\n/**\n * decodeObj takes a Uint8Array and returns its javascript obj\n * @param o - Uint8Array to decode\n * @returns object\n *\n * @deprecated Use {@link msgpackRawDecode} instead. Note that this function uses `IntDecoding.MIXED`\n *   while `msgpackRawDecode` defaults to `IntDecoding.BIGINT` for int decoding, though it is\n *   configurable.\n */\nexport function decodeObj(o: ArrayLike<number>) {\n  return msgpackRawDecode(o, { intDecoding: IntDecoding.MIXED })\n}\n\n/**\n * Decodes msgpack bytes into a Map object. This supports decoding non-string map keys.\n * @param encoded - The msgpack bytes to decode\n * @param options - Options for decoding, including int decoding mode. See {@link IntDecoding} for more information.\n * @returns The decoded Map object\n */\nexport function msgpackRawDecodeAsMap(encoded: ArrayLike<number>, options?: { intDecoding: IntDecoding }) {\n  const decoderOptions: DecoderOptions = {\n    intMode: options?.intDecoding ? intDecodingToIntMode(options?.intDecoding) : IntMode.BIGINT,\n    useMap: true,\n  }\n  return msgpackDecode(encoded, decoderOptions)\n}\n\nfunction msgpackRawDecodeAsMapWithRawStrings(encoded: ArrayLike<number>, options?: { intDecoding: IntDecoding }) {\n  const decoderOptions: DecoderOptions = {\n    intMode: options?.intDecoding ? intDecodingToIntMode(options?.intDecoding) : IntMode.BIGINT,\n    useMap: true,\n    rawBinaryStringKeys: true,\n    rawBinaryStringValues: true,\n    useRawBinaryStringClass: true,\n  }\n  return msgpackDecode(encoded, decoderOptions)\n}\n\nexport type MsgpackEncodingData =\n  | null\n  | undefined\n  | string\n  | number\n  | bigint\n  | boolean\n  | Uint8Array\n  | MsgpackEncodingData[]\n  | Map<string | number | bigint | Uint8Array, MsgpackEncodingData>\n\nexport type JSONEncodingData =\n  | null\n  | undefined\n  | string\n  | number\n  | bigint\n  | boolean\n  | JSONEncodingData[]\n  | { [key: string]: JSONEncodingData }\n\nexport function msgpackEncodingDataToJSONEncodingData(e: MsgpackEncodingData): JSONEncodingData {\n  if (e === null || e === undefined) {\n    return e as JSONEncodingData\n  }\n  if (e instanceof Uint8Array) {\n    return bytesToBase64(e)\n  }\n  if (Array.isArray(e)) {\n    return e.map(msgpackEncodingDataToJSONEncodingData)\n  }\n  if (e instanceof Map) {\n    const obj: { [key: string]: JSONEncodingData } = {}\n    for (const [k, v] of e) {\n      if (typeof k !== 'string') {\n        throw new Error(`JSON map key must be a string: ${k}`)\n      }\n      obj[k] = msgpackEncodingDataToJSONEncodingData(v)\n    }\n    return obj\n  }\n  return e\n}\n\nexport function jsonEncodingDataToMsgpackEncodingData(e: JSONEncodingData): MsgpackEncodingData {\n  if (e === null || e === undefined) {\n    return e as MsgpackEncodingData\n  }\n  if (\n    typeof e === 'string' || // Note, this will not convert base64 to Uint8Array\n    typeof e === 'number' ||\n    typeof e === 'bigint' ||\n    typeof e === 'boolean'\n  ) {\n    return e\n  }\n  if (Array.isArray(e)) {\n    return e.map(jsonEncodingDataToMsgpackEncodingData)\n  }\n  if (typeof e === 'object') {\n    const obj = new Map<string, MsgpackEncodingData>()\n    for (const [key, value] of Object.entries(e)) {\n      obj.set(key, jsonEncodingDataToMsgpackEncodingData(value))\n    }\n    return obj\n  }\n  throw new Error(`Invalid JSON encoding data: ${e}`)\n}\n\nenum MsgpackObjectPathSegmentKind {\n  MAP_VALUE,\n  ARRAY_ELEMENT,\n}\n\ninterface MsgpackObjectPathSegment {\n  kind: MsgpackObjectPathSegmentKind\n  key: string | number | bigint | Uint8Array | RawBinaryString\n}\n\n/**\n * This class is used to index into an encoded msgpack object and extract raw strings.\n */\nexport class MsgpackRawStringProvider {\n  private readonly parent?: MsgpackRawStringProvider\n\n  private readonly baseObjectBytes?: ArrayLike<number>\n\n  private readonly segment?: MsgpackObjectPathSegment\n\n  private resolvedCache: MsgpackEncodingData = null\n  private resolvedCachePresent = false\n\n  public constructor({\n    parent,\n    segment,\n    baseObjectBytes,\n  }:\n    | {\n        parent: MsgpackRawStringProvider\n        segment: MsgpackObjectPathSegment\n        baseObjectBytes?: undefined\n      }\n    | {\n        parent?: undefined\n        segment?: undefined\n        baseObjectBytes: ArrayLike<number>\n      }) {\n    this.parent = parent\n    this.segment = segment\n    this.baseObjectBytes = baseObjectBytes\n  }\n\n  /**\n   * Create a new provider that resolves to the current provider's map value at the given key.\n   */\n  public withMapValue(key: string | number | bigint | Uint8Array | RawBinaryString): MsgpackRawStringProvider {\n    return new MsgpackRawStringProvider({\n      parent: this,\n      segment: {\n        kind: MsgpackObjectPathSegmentKind.MAP_VALUE,\n        key,\n      },\n    })\n  }\n\n  /**\n   * Create a new provider that resolves to the current provider's array element at the given index.\n   */\n  public withArrayElement(index: number): MsgpackRawStringProvider {\n    return new MsgpackRawStringProvider({\n      parent: this,\n      segment: {\n        kind: MsgpackObjectPathSegmentKind.ARRAY_ELEMENT,\n        key: index,\n      },\n    })\n  }\n\n  /**\n   * Get the raw string at the current location. If the current location is not a raw string, an error is thrown.\n   */\n  public getRawStringAtCurrentLocation(): Uint8Array {\n    const resolved = this.resolve()\n    if (resolved instanceof RawBinaryString) {\n      // Decoded rawBinaryValue will always be a Uint8Array\n      return resolved.rawBinaryValue as Uint8Array\n    }\n    throw new Error(`Invalid type. Expected RawBinaryString, got ${resolved} (${typeof resolved})`)\n  }\n\n  /**\n   * Get the raw string map keys and values at the current location. If the current location is not a map, an error is thrown.\n   */\n  public getRawStringKeysAndValuesAtCurrentLocation(): Map<Uint8Array, MsgpackEncodingData> {\n    const resolved = this.resolve()\n    if (!(resolved instanceof Map)) {\n      throw new Error(`Invalid type. Expected Map, got ${resolved} (${typeof resolved})`)\n    }\n    const keysAndValues = new Map<Uint8Array, MsgpackEncodingData>()\n    for (const [key, value] of resolved) {\n      if (key instanceof RawBinaryString) {\n        // Decoded rawBinaryValue will always be a Uint8Array\n        keysAndValues.set(key.rawBinaryValue as Uint8Array, value)\n      } else {\n        throw new Error(`Invalid type for map key. Expected RawBinaryString, got ${key} (${typeof key})`)\n      }\n    }\n    return keysAndValues\n  }\n\n  /**\n   * Resolve the provider by extracting the value it indicates from the base msgpack object.\n   */\n  private resolve(): MsgpackEncodingData {\n    if (this.resolvedCachePresent) {\n      return this.resolvedCache\n    }\n    let parentResolved: MsgpackEncodingData\n    if (this.parent) {\n      parentResolved = this.parent.resolve()\n    } else {\n      // Need to parse baseObjectBytes\n      parentResolved = msgpackRawDecodeAsMapWithRawStrings(this.baseObjectBytes!) as MsgpackEncodingData\n    }\n    if (!this.segment) {\n      this.resolvedCache = parentResolved\n      this.resolvedCachePresent = true\n      return parentResolved\n    }\n    if (this.segment.kind === MsgpackObjectPathSegmentKind.MAP_VALUE) {\n      if (!(parentResolved instanceof Map)) {\n        throw new Error(`Invalid type. Expected Map, got ${parentResolved} (${typeof parentResolved})`)\n      }\n      // All decoded map keys will be raw strings, and Map objects compare complex values by reference,\n      // so we must check all the values for value-equality.\n      if (typeof this.segment.key === 'string' || this.segment.key instanceof Uint8Array || this.segment.key instanceof RawBinaryString) {\n        const targetBytes =\n          this.segment.key instanceof RawBinaryString\n            ? // Decoded rawBinaryValue will always be a Uint8Array\n              (this.segment.key.rawBinaryValue as Uint8Array)\n            : coerceToBytes(this.segment.key)\n        const targetIsRawString = typeof this.segment.key === 'string' || this.segment.key instanceof RawBinaryString\n        for (const [key, value] of parentResolved) {\n          let potentialKeyBytes: Uint8Array | undefined\n          if (targetIsRawString) {\n            if (key instanceof RawBinaryString) {\n              // Decoded rawBinaryValue will always be a Uint8Array\n              potentialKeyBytes = key.rawBinaryValue as Uint8Array\n            }\n          } else if (key instanceof Uint8Array) {\n            potentialKeyBytes = key\n          }\n          if (potentialKeyBytes && arrayEqual(targetBytes, potentialKeyBytes)) {\n            this.resolvedCache = value\n            break\n          }\n        }\n      } else {\n        this.resolvedCache = parentResolved.get(this.segment.key)\n      }\n      this.resolvedCachePresent = true\n      return this.resolvedCache\n    }\n    if (this.segment.kind === MsgpackObjectPathSegmentKind.ARRAY_ELEMENT) {\n      if (!Array.isArray(parentResolved)) {\n        throw new Error(`Invalid type. Expected Array, got ${parentResolved} (${typeof parentResolved})`)\n      }\n      this.resolvedCache = parentResolved[this.segment.key as number]\n      this.resolvedCachePresent = true\n      return this.resolvedCache\n    }\n    throw new Error(`Invalid segment kind: ${this.segment.kind}`)\n  }\n\n  /**\n   * Get the path string of the current location indicated by the provider. Useful for debugging.\n   */\n  public getPathString(): string {\n    const parentPathString = this.parent ? this.parent.getPathString() : 'root'\n    if (!this.segment) {\n      return parentPathString\n    }\n    if (this.segment.kind === MsgpackObjectPathSegmentKind.MAP_VALUE) {\n      return `${parentPathString} -> map key \"${this.segment.key}\" (${typeof this.segment.key})`\n    }\n    if (this.segment.kind === MsgpackObjectPathSegmentKind.ARRAY_ELEMENT) {\n      return `${parentPathString} -> array index ${this.segment.key} (${typeof this.segment.key})`\n    }\n    return `${parentPathString} -> unknown segment kind ${this.segment.kind}`\n  }\n}\n\n/**\n * Options for {@link Schema.prepareJSON}\n */\nexport interface PrepareJSONOptions {\n  /**\n   * If true, allows invalid UTF-8 binary strings to be converted to JSON strings.\n   *\n   * Otherwise, an error will be thrown if encoding a binary string to a JSON cannot be done losslessly.\n   */\n  lossyBinaryStringConversion?: boolean\n}\n\n/**\n * A Schema is used to prepare objects for encoding and decoding from msgpack and JSON.\n *\n * Schemas represent a specific type.\n */\nexport abstract class Schema {\n  /**\n   * Get the default value for this type.\n   */\n  public abstract defaultValue(): unknown\n\n  /**\n   * Checks if the value is the default value for this type.\n   * @param data - The value to check\n   * @returns True if the value is the default value, false otherwise\n   */\n  public abstract isDefaultValue(data: unknown): boolean\n\n  /**\n   * Prepares the encoding data for encoding to msgpack.\n   * @param data - Encoding data to be prepared.\n   * @returns A value ready to be msgpack encoded.\n   */\n  public abstract prepareMsgpack(data: unknown): MsgpackEncodingData\n\n  /**\n   * Restores the encoding data from a msgpack encoding object.\n   * @param encoded - The msgpack encoding object to restore.\n   * @param rawStringProvider - A provider for raw strings.\n   * @returns The original encoding data.\n   */\n  public abstract fromPreparedMsgpack(encoded: MsgpackEncodingData, rawStringProvider: MsgpackRawStringProvider): unknown\n\n  /**\n   * Prepares the encoding data for encoding to JSON.\n   * @param data - The JSON encoding data to be prepared.\n   * @returns A value ready to be JSON encoded.\n   */\n  public abstract prepareJSON(data: unknown, options: PrepareJSONOptions): JSONEncodingData\n\n  /**\n   * Restores the encoding data from a JSON encoding object.\n   * @param encoded - The JSON encoding object to restore.\n   * @returns The original encoding data.\n   */\n  public abstract fromPreparedJSON(encoded: JSONEncodingData): unknown\n}\n\n/**\n * An interface for objects that can be encoded and decoded to/from msgpack and JSON.\n */\nexport interface Encodable {\n  /**\n   * Extract the encoding data for this object. This data, after being prepared by the encoding\n   * Schema, can be encoded to msgpack or JSON.\n   */\n  toEncodingData(): unknown\n  /**\n   * Get the encoding Schema for this object, used to prepare the encoding data for msgpack and JSON.\n   */\n  getEncodingSchema(): Schema\n}\n\n/**\n * A type that represents the class of an Encodable object.\n */\nexport interface EncodableClass<T extends Encodable> {\n  /**\n   * Create a new instance of this class from the given encoding data.\n   * @param data - The encoding data to create the object from\n   */\n  fromEncodingData(data: unknown): T\n  /**\n   * The encoding Schema for this class, used to prepare encoding data from msgpack and JSON.\n   */\n  readonly encodingSchema: Schema\n}\n\n/**\n * Decode a msgpack byte array to an Encodable object.\n * @param encoded - The msgpack bytes to decode\n * @param c - The class of the object to decode. This class must match the object that was encoded.\n * @returns An instance of the class with the decoded data\n */\nexport function decodeMsgpack<T extends Encodable>(encoded: ArrayLike<number>, c: EncodableClass<T>): T {\n  const decoded = msgpackRawDecodeAsMap(encoded) as MsgpackEncodingData\n  const rawStringProvider = new MsgpackRawStringProvider({\n    baseObjectBytes: encoded,\n  })\n  return c.fromEncodingData(c.encodingSchema.fromPreparedMsgpack(decoded, rawStringProvider))\n}\n\n/**\n * Encode an Encodable object to a msgpack byte array.\n * @param e - The object to encode\n * @returns A msgpack byte array encoding of the object\n */\nexport function encodeMsgpack(e: Encodable): Uint8Array {\n  return msgpackRawEncode(e.getEncodingSchema().prepareMsgpack(e.toEncodingData()))\n}\n\n/**\n * Decode a JSON string to an Encodable object.\n * @param encoded - The JSON string to decode\n * @param c - The class of the object to decode. This class must match the object that was encoded.\n * @returns An instance of the class with the decoded data\n */\nexport function decodeJSON<T extends Encodable>(encoded: string, c: EncodableClass<T>): T {\n  const decoded: JSONEncodingData = parseJSON(encoded, {\n    intDecoding: IntDecoding.BIGINT,\n  })\n  return c.fromEncodingData(c.encodingSchema.fromPreparedJSON(decoded) as JSONEncodingData)\n}\n\nexport interface EncodeJSONOptions {\n  /**\n   * Adds indentation, white space, and line break characters to the return-value JSON text to make\n   * it easier to read.\n   */\n  space?: string | number\n\n  /**\n   * If true, allows invalid UTF-8 binary strings to be converted to JSON strings.\n   *\n   * Otherwise, an error will be thrown if encoding a binary string to a JSON cannot be done losslessly.\n   */\n  lossyBinaryStringConversion?: boolean\n}\n\n/**\n * Encode an Encodable object to a JSON string.\n * @param e - The object to encode\n * @param options - Optional encoding options. See {@link EncodeJSONOptions} for more information.\n * @returns A JSON string encoding of the object\n */\nexport function encodeJSON(e: Encodable, options?: EncodeJSONOptions): string {\n  const { space, ...prepareJSONOptions } = options ?? {}\n  const prepared = e.getEncodingSchema().prepareJSON(e.toEncodingData(), prepareJSONOptions)\n  return stringifyJSON(prepared, undefined, space)\n}\n"],"mappings":"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"}