@algorandfoundation/algokit-utils 9.2.0-beta.6 → 10.0.0-alpha.1

package/packages/common/src/address.mjs

@@ -0,0 +1,144 @@
+import { arrayEqual, concatArrays } from "./array.mjs";
+import { CHECKSUM_BYTE_LENGTH, HASH_BYTES_LENGTH } from "./constants.mjs";
+import base32 from "hi-base32";
+import sha512 from "js-sha512";
+
+//#region packages/common/src/address.ts
+const ALGORAND_ADDRESS_BYTE_LENGTH = 36;
+const ALGORAND_CHECKSUM_BYTE_LENGTH = 4;
+const ALGORAND_ADDRESS_LENGTH = 58;
+const ALGORAND_ZERO_ADDRESS_STRING = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ";
+const MALFORMED_ADDRESS_ERROR_MSG = "address seems to be malformed";
+const CHECKSUM_ADDRESS_ERROR_MSG = "wrong checksum for address";
+function checksumFromPublicKey(publicKey) {
+	return Uint8Array.from(sha512.sha512_256.array(publicKey).slice(HASH_BYTES_LENGTH - CHECKSUM_BYTE_LENGTH, HASH_BYTES_LENGTH));
+}
+function genericHash(arr) {
+	return sha512.sha512_256.array(arr);
+}
+function bytesToHex(bytes) {
+	return Buffer.from(bytes).toString("hex");
+}
+function encodeUint64(num) {
+	if (!(typeof num === "bigint" || Number.isInteger(num)) || num < 0 || num > BigInt("0xffffffffffffffff")) throw new Error("Input is not a 64-bit unsigned integer");
+	const encoding = new Uint8Array(8);
+	new DataView(encoding.buffer).setBigUint64(0, BigInt(num));
+	return encoding;
+}
+/** Symbol used for instanceof checks across packages (CJS/ESM) */
+const ADDR_SYMBOL = Symbol.for("algokit_common:Address");
+/**
+* Represents an Algorand address
+*/
+var Address = class Address {
+	/**
+	* The binary form of the address. For standard accounts, this is the public key.
+	*/
+	publicKey;
+	/** @internal */
+	[ADDR_SYMBOL];
+	/**
+	* Create a new Address object from its binary form.
+	* @param publicKey - The binary form of the address. Must be 32 bytes.
+	*/
+	constructor(publicKey) {
+		this[ADDR_SYMBOL] = true;
+		if (publicKey.length !== ALGORAND_ADDRESS_BYTE_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH) throw new Error(`${MALFORMED_ADDRESS_ERROR_MSG}: 0x${bytesToHex(publicKey)}, length ${publicKey.length}`);
+		this.publicKey = publicKey;
+	}
+	/**
+	* Check if the address is equal to another address.
+	*/
+	equals(other) {
+		return other instanceof Address && arrayEqual(this.publicKey, other.publicKey);
+	}
+	/**
+	* Compute the 4 byte checksum of the address.
+	*/
+	checksum() {
+		return checksumFromPublicKey(this.publicKey);
+	}
+	/**
+	* Encode the address into a string form.
+	*/
+	toString() {
+		return base32.encode(concatArrays(this.publicKey, this.checksum())).slice(0, ALGORAND_ADDRESS_LENGTH);
+	}
+	/**
+	* Decode an address from a string.
+	* @param address - The address to decode. Must be 58 characters long.
+	* @returns An Address object corresponding to the input string.
+	*/
+	static fromString(address) {
+		if (typeof address !== "string") throw new Error(`${MALFORMED_ADDRESS_ERROR_MSG}: expected string, got ${typeof address}, ${address}`);
+		if (address.length !== ALGORAND_ADDRESS_LENGTH) throw new Error(`${MALFORMED_ADDRESS_ERROR_MSG}: expected length ${ALGORAND_ADDRESS_LENGTH}, got ${address.length}: ${address}`);
+		const decoded = base32.decode.asBytes(address);
+		if (decoded.length !== ALGORAND_ADDRESS_BYTE_LENGTH) throw new Error(`${MALFORMED_ADDRESS_ERROR_MSG}: expected byte length ${ALGORAND_ADDRESS_BYTE_LENGTH}, got ${decoded.length}`);
+		const pk = new Uint8Array(decoded.slice(0, ALGORAND_ADDRESS_BYTE_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH));
+		const cs = new Uint8Array(decoded.slice(ALGORAND_ADDRESS_BYTE_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH, ALGORAND_ADDRESS_BYTE_LENGTH));
+		const checksum = checksumFromPublicKey(pk);
+		if (!arrayEqual(checksum, cs)) throw new Error(`${CHECKSUM_ADDRESS_ERROR_MSG}: ${address} (${cs}, ${checksum})`);
+		return new Address(pk);
+	}
+	/**
+	* Get the zero address.
+	*/
+	static zeroAddress() {
+		return new Address(new Uint8Array(ALGORAND_ADDRESS_BYTE_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH));
+	}
+	static [Symbol.hasInstance](obj) {
+		return Boolean(obj && typeof obj === "object" && ADDR_SYMBOL in obj && obj[ADDR_SYMBOL]);
+	}
+};
+function getAddress(addr) {
+	if (typeof addr == "string") return Address.fromString(addr);
+	else if ("addr" in addr) return addr.addr;
+	else return addr;
+}
+function getOptionalAddress(addr) {
+	if (addr === void 0) return;
+	return getAddress(addr);
+}
+/**
+* isValidAddress checks if a string is a valid Algorand address.
+* @param address - an Algorand address with checksum.
+* @returns true if valid, false otherwise
+*/
+function isValidAddress(address) {
+	try {
+		Address.fromString(address);
+	} catch {
+		return false;
+	}
+	return true;
+}
+const APP_ID_PREFIX = new TextEncoder().encode("appID");
+/**
+* Get the escrow address of an application.
+* @param appID - The ID of the application.
+* @returns The address corresponding to that application's escrow account.
+*/
+function getApplicationAddress(appID) {
+	const hash = genericHash(concatArrays(APP_ID_PREFIX, encodeUint64(appID)));
+	return new Address(Uint8Array.from(hash));
+}
+/**
+* decodeAddress takes an Algorand address in string form and decodes it into a Uint8Array.
+* @param address - an Algorand address with checksum.
+* @returns the decoded form of the address's public key and checksum
+*/
+function decodeAddress(address) {
+	return Address.fromString(address);
+}
+/**
+* encodeAddress takes an Algorand address as a Uint8Array and encodes it into a string with checksum.
+* @param address - a raw Algorand address
+* @returns the address and checksum encoded as a string.
+*/
+function encodeAddress(address) {
+	return new Address(address).toString();
+}
+
+//#endregion
+export { ALGORAND_ADDRESS_BYTE_LENGTH, ALGORAND_CHECKSUM_BYTE_LENGTH, ALGORAND_ZERO_ADDRESS_STRING, Address, decodeAddress, encodeAddress, getAddress, getApplicationAddress, getOptionalAddress, isValidAddress };
+//# sourceMappingURL=address.mjs.map

package/packages/common/src/address.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.mjs","names":[],"sources":["../../../../packages/common/src/address.ts"],"sourcesContent":["import base32 from 'hi-base32'\nimport sha512 from 'js-sha512'\nimport { arrayEqual, concatArrays } from './array'\nimport { CHECKSUM_BYTE_LENGTH, HASH_BYTES_LENGTH } from './constants'\n\nexport const ALGORAND_ADDRESS_BYTE_LENGTH = 36\nexport const ALGORAND_CHECKSUM_BYTE_LENGTH = 4\nexport const ALGORAND_ADDRESS_LENGTH = 58\nexport const ALGORAND_ZERO_ADDRESS_STRING = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ'\n\nexport const MALFORMED_ADDRESS_ERROR_MSG = 'address seems to be malformed'\nexport const CHECKSUM_ADDRESS_ERROR_MSG = 'wrong checksum for address'\n\nexport function checksumFromPublicKey(publicKey: Uint8Array): Uint8Array {\n  return Uint8Array.from(sha512.sha512_256.array(publicKey).slice(HASH_BYTES_LENGTH - CHECKSUM_BYTE_LENGTH, HASH_BYTES_LENGTH))\n}\n\nfunction genericHash(arr: sha512.Message) {\n  return sha512.sha512_256.array(arr)\n}\n\nfunction bytesToHex(bytes: Uint8Array): string {\n  return Buffer.from(bytes).toString('hex')\n}\n\nexport function encodeUint64(num: number | bigint) {\n  const isInteger = typeof num === 'bigint' || Number.isInteger(num)\n\n  if (!isInteger || num < 0 || num > BigInt('0xffffffffffffffff')) {\n    throw new Error('Input is not a 64-bit unsigned integer')\n  }\n\n  const encoding = new Uint8Array(8)\n  const view = new DataView(encoding.buffer)\n  view.setBigUint64(0, BigInt(num))\n\n  return encoding\n}\n\n/** Symbol used for instanceof checks across packages (CJS/ESM) */\nconst ADDR_SYMBOL = Symbol.for('algokit_common:Address')\n\n/**\n * Represents an Algorand address\n */\nexport class Address {\n  /**\n   * The binary form of the address. For standard accounts, this is the public key.\n   */\n  public readonly publicKey: Uint8Array;\n\n  /** @internal */\n  [ADDR_SYMBOL]: boolean\n\n  /**\n   * Create a new Address object from its binary form.\n   * @param publicKey - The binary form of the address. Must be 32 bytes.\n   */\n  constructor(publicKey: Uint8Array) {\n    this[ADDR_SYMBOL] = true\n    if (publicKey.length !== ALGORAND_ADDRESS_BYTE_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH)\n      throw new Error(`${MALFORMED_ADDRESS_ERROR_MSG}: 0x${bytesToHex(publicKey)}, length ${publicKey.length}`)\n    this.publicKey = publicKey\n  }\n\n  /**\n   * Check if the address is equal to another address.\n   */\n  equals(other: Address): boolean {\n    return other instanceof Address && arrayEqual(this.publicKey, other.publicKey)\n  }\n\n  /**\n   * Compute the 4 byte checksum of the address.\n   */\n  checksum(): Uint8Array {\n    return checksumFromPublicKey(this.publicKey)\n  }\n\n  /**\n   * Encode the address into a string form.\n   */\n  toString(): string {\n    const addr = base32.encode(concatArrays(this.publicKey, this.checksum()))\n    return addr.slice(0, ALGORAND_ADDRESS_LENGTH) // removing the extra '===='\n  }\n\n  /**\n   * Decode an address from a string.\n   * @param address - The address to decode. Must be 58 characters long.\n   * @returns An Address object corresponding to the input string.\n   */\n  static fromString(address: string): Address {\n    if (typeof address !== 'string') throw new Error(`${MALFORMED_ADDRESS_ERROR_MSG}: expected string, got ${typeof address}, ${address}`)\n    if (address.length !== ALGORAND_ADDRESS_LENGTH)\n      throw new Error(`${MALFORMED_ADDRESS_ERROR_MSG}: expected length ${ALGORAND_ADDRESS_LENGTH}, got ${address.length}: ${address}`)\n\n    // try to decode\n    const decoded = base32.decode.asBytes(address)\n    // Sanity check\n    if (decoded.length !== ALGORAND_ADDRESS_BYTE_LENGTH)\n      throw new Error(`${MALFORMED_ADDRESS_ERROR_MSG}: expected byte length ${ALGORAND_ADDRESS_BYTE_LENGTH}, got ${decoded.length}`)\n\n    // Find publickey and checksum\n    const pk = new Uint8Array(decoded.slice(0, ALGORAND_ADDRESS_BYTE_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH))\n    const cs = new Uint8Array(decoded.slice(ALGORAND_ADDRESS_BYTE_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH, ALGORAND_ADDRESS_BYTE_LENGTH))\n    const checksum = checksumFromPublicKey(pk)\n    // Check if the checksum and the address are equal\n    if (!arrayEqual(checksum, cs)) throw new Error(`${CHECKSUM_ADDRESS_ERROR_MSG}: ${address} (${cs}, ${checksum})`)\n\n    return new Address(pk)\n  }\n\n  /**\n   * Get the zero address.\n   */\n  static zeroAddress(): Address {\n    return new Address(new Uint8Array(ALGORAND_ADDRESS_BYTE_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH))\n  }\n\n  static [Symbol.hasInstance](obj: unknown) {\n    return Boolean(obj && typeof obj === 'object' && ADDR_SYMBOL in obj && obj[ADDR_SYMBOL as keyof typeof obj])\n  }\n}\n\nexport interface Addressable {\n  addr: Readonly<Address>\n}\n\nexport type ReadableAddress = Addressable | Address | string\n\nexport function getAddress(addr: ReadableAddress): Address {\n  if (typeof addr == 'string') {\n    return Address.fromString(addr)\n  } else if ('addr' in addr) {\n    return addr.addr\n  } else {\n    return addr\n  }\n}\n\nexport function getOptionalAddress(addr: ReadableAddress | undefined): Address | undefined {\n  if (addr === undefined) {\n    return undefined\n  }\n  return getAddress(addr)\n}\n\n/**\n * isValidAddress checks if a string is a valid Algorand address.\n * @param address - an Algorand address with checksum.\n * @returns true if valid, false otherwise\n */\nexport function isValidAddress(address: string): boolean {\n  // Try to decode\n  try {\n    Address.fromString(address)\n  } catch {\n    return false\n  }\n  return true\n}\n\nconst APP_ID_PREFIX = new TextEncoder().encode('appID')\n\n/**\n * Get the escrow address of an application.\n * @param appID - The ID of the application.\n * @returns The address corresponding to that application's escrow account.\n */\nexport function getApplicationAddress(appID: number | bigint): Address {\n  const toBeSigned = concatArrays(APP_ID_PREFIX, encodeUint64(appID))\n  const hash = genericHash(toBeSigned)\n  return new Address(Uint8Array.from(hash))\n}\n\n/**\n * decodeAddress takes an Algorand address in string form and decodes it into a Uint8Array.\n * @param address - an Algorand address with checksum.\n * @returns the decoded form of the address's public key and checksum\n */\nexport function decodeAddress(address: string): Address {\n  return Address.fromString(address)\n}\n\n/**\n * encodeAddress takes an Algorand address as a Uint8Array and encodes it into a string with checksum.\n * @param address - a raw Algorand address\n * @returns the address and checksum encoded as a string.\n */\nexport function encodeAddress(address: Uint8Array): string {\n  return new Address(address).toString()\n}\n"],"mappings":"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"}

package/packages/common/src/array.js

@@ -0,0 +1,21 @@
+
+//#region packages/common/src/array.ts
+function arrayEqual(a, b) {
+	if (a.length !== b.length) return false;
+	return Array.from(a).every((val, i) => val === b[i]);
+}
+function concatArrays(...arrs) {
+	const size = arrs.reduce((sum, arr) => sum + arr.length, 0);
+	const c = new Uint8Array(size);
+	let offset = 0;
+	for (let i = 0; i < arrs.length; i++) {
+		c.set(arrs[i], offset);
+		offset += arrs[i].length;
+	}
+	return c;
+}
+
+//#endregion
+exports.arrayEqual = arrayEqual;
+exports.concatArrays = concatArrays;
+//# sourceMappingURL=array.js.map

package/packages/common/src/array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.js","names":[],"sources":["../../../../packages/common/src/array.ts"],"sourcesContent":["export function arrayEqual<T>(a: ArrayLike<T>, b: ArrayLike<T>): boolean {\n  if (a.length !== b.length) {\n    return false\n  }\n  return Array.from(a).every((val, i) => val === b[i])\n}\n\nexport function concatArrays(...arrs: ArrayLike<number>[]): Uint8Array {\n  const size = arrs.reduce((sum, arr) => sum + arr.length, 0)\n  const c = new Uint8Array(size)\n\n  let offset = 0\n  for (let i = 0; i < arrs.length; i++) {\n    c.set(arrs[i], offset)\n    offset += arrs[i].length\n  }\n\n  return c\n}\n"],"mappings":";;AAAA,SAAgB,WAAc,GAAiB,GAA0B;AACvE,KAAI,EAAE,WAAW,EAAE,OACjB,QAAO;AAET,QAAO,MAAM,KAAK,EAAE,CAAC,OAAO,KAAK,MAAM,QAAQ,EAAE,GAAG;;AAGtD,SAAgB,aAAa,GAAG,MAAuC;CACrE,MAAM,OAAO,KAAK,QAAQ,KAAK,QAAQ,MAAM,IAAI,QAAQ,EAAE;CAC3D,MAAM,IAAI,IAAI,WAAW,KAAK;CAE9B,IAAI,SAAS;AACb,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,IAAE,IAAI,KAAK,IAAI,OAAO;AACtB,YAAU,KAAK,GAAG;;AAGpB,QAAO"}

package/packages/common/src/array.mjs

@@ -0,0 +1,19 @@
+//#region packages/common/src/array.ts
+function arrayEqual(a, b) {
+	if (a.length !== b.length) return false;
+	return Array.from(a).every((val, i) => val === b[i]);
+}
+function concatArrays(...arrs) {
+	const size = arrs.reduce((sum, arr) => sum + arr.length, 0);
+	const c = new Uint8Array(size);
+	let offset = 0;
+	for (let i = 0; i < arrs.length; i++) {
+		c.set(arrs[i], offset);
+		offset += arrs[i].length;
+	}
+	return c;
+}
+
+//#endregion
+export { arrayEqual, concatArrays };
+//# sourceMappingURL=array.mjs.map

package/packages/common/src/array.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.mjs","names":[],"sources":["../../../../packages/common/src/array.ts"],"sourcesContent":["export function arrayEqual<T>(a: ArrayLike<T>, b: ArrayLike<T>): boolean {\n  if (a.length !== b.length) {\n    return false\n  }\n  return Array.from(a).every((val, i) => val === b[i])\n}\n\nexport function concatArrays(...arrs: ArrayLike<number>[]): Uint8Array {\n  const size = arrs.reduce((sum, arr) => sum + arr.length, 0)\n  const c = new Uint8Array(size)\n\n  let offset = 0\n  for (let i = 0; i < arrs.length; i++) {\n    c.set(arrs[i], offset)\n    offset += arrs[i].length\n  }\n\n  return c\n}\n"],"mappings":";AAAA,SAAgB,WAAc,GAAiB,GAA0B;AACvE,KAAI,EAAE,WAAW,EAAE,OACjB,QAAO;AAET,QAAO,MAAM,KAAK,EAAE,CAAC,OAAO,KAAK,MAAM,QAAQ,EAAE,GAAG;;AAGtD,SAAgB,aAAa,GAAG,MAAuC;CACrE,MAAM,OAAO,KAAK,QAAQ,KAAK,QAAQ,MAAM,IAAI,QAAQ,EAAE;CAC3D,MAAM,IAAI,IAAI,WAAW,KAAK;CAE9B,IAAI,SAAS;AACb,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,IAAE,IAAI,KAAK,IAAI,OAAO;AACtB,YAAU,KAAK,GAAG;;AAGpB,QAAO"}

package/packages/common/src/codecs/codec.d.ts

@@ -0,0 +1,71 @@
+import { EncodingFormat } from "./types.js";
+
+//#region packages/common/src/codecs/codec.d.ts
+
+/**
+ * A bidirectional codec that transforms between application types and wire formats.
+ * Supports format-specific encoding (JSON vs msgpack).
+ *
+ * @template T - The application/runtime type (e.g., bigint, string, Uint8Array)
+ * @template TEncoded - The wire format type (may differ based on format, e.g., bigint → string in JSON)
+ */
+declare abstract class Codec<T, TEncoded = T, TWireEncoded = TEncoded> {
+  /**
+   * The default value for this type (used to determine if a value should be omitted during encoding)
+   */
+  abstract defaultValue(): T;
+  /**
+   * Encode a value, always returning the value regardless of if it is default
+   * @param value - The application value
+   * @param format - The wire format (json or msgpack)
+   * @returns The encoded value, or the default if it is undefined or null
+   */
+  encode(value: T | undefined | null, format: EncodingFormat): TEncoded;
+  /**
+   * Encode a value, omitting it if set to the default value.
+   * @param value - The application value
+   * @param format - The wire format (json or msgpack)
+   * @returns The encoded value, or undefined if it equals the default (will be omitted)
+   */
+  encodeOptional(value: T | undefined | null, format: EncodingFormat): TEncoded | undefined;
+  /**
+   * Decode a value from wire format
+   * @param value - The wire value
+   * @param format - The wire format (json or msgpack)
+   * @returns The decoded application value
+   */
+  decode(value: TWireEncoded | undefined | null, format: EncodingFormat): T;
+  /**
+   * Decode an optional value from wire format (preserves undefined vs default distinction)
+   * @param value - The wire value
+   * @param format - The wire format (json or msgpack)
+   * @returns The decoded application value, or undefined if wire value was undefined
+   */
+  decodeOptional(value: TWireEncoded | undefined | null, format: EncodingFormat): T | undefined;
+  /**
+   * Transform application value to wire format
+   * Override this method to implement encoding logic, otherwise defaults to pass-through
+   * @param value - The application value (guaranteed to not be undefined or default)
+   * @param format - The wire format
+   * @returns The encoded value
+   */
+  protected toEncoded(value: T, format: EncodingFormat): TEncoded;
+  /**
+   * Transform wire format to application value
+   * Override this method to implement specific decoding logic, otherwise defaults to pass-through
+   * @param value - The wire value (guaranteed to not be undefined)
+   * @param format - The wire format
+   * @returns The decoded value
+   */
+  protected fromEncoded(value: TWireEncoded, format: EncodingFormat): T;
+  /**
+   * Check if a value equals the default value (determines if it should be omitted during encoding)
+   * Override this method for custom default comparison logic, otherwise defaults to default value equality
+   * @param value - The value to check
+   * @returns True if value equals default
+   */
+  isDefaultValue(value: T): boolean;
+}
+//#endregion
+export { Codec };
+//# sourceMappingURL=codec.d.ts.map

package/packages/common/src/codecs/codec.js

@@ -0,0 +1,87 @@
+
+//#region packages/common/src/codecs/codec.ts
+/**
+* A bidirectional codec that transforms between application types and wire formats.
+* Supports format-specific encoding (JSON vs msgpack).
+*
+* @template T - The application/runtime type (e.g., bigint, string, Uint8Array)
+* @template TEncoded - The wire format type (may differ based on format, e.g., bigint → string in JSON)
+*/
+var Codec = class {
+	/**
+	* Encode a value, always returning the value regardless of if it is default
+	* @param value - The application value
+	* @param format - The wire format (json or msgpack)
+	* @returns The encoded value, or the default if it is undefined or null
+	*/
+	encode(value, format) {
+		if (value === void 0 || value === null || this.isDefaultValue(value)) return this.toEncoded(this.defaultValue(), format);
+		return this.toEncoded(value, format);
+	}
+	/**
+	* Encode a value, omitting it if set to the default value.
+	* @param value - The application value
+	* @param format - The wire format (json or msgpack)
+	* @returns The encoded value, or undefined if it equals the default (will be omitted)
+	*/
+	encodeOptional(value, format) {
+		if (value === void 0 || value === null) return void 0;
+		if (this.isDefaultValue(value)) return void 0;
+		return this.toEncoded(value, format);
+	}
+	/**
+	* Decode a value from wire format
+	* @param value - The wire value
+	* @param format - The wire format (json or msgpack)
+	* @returns The decoded application value
+	*/
+	decode(value, format) {
+		if (value === void 0 || value === null) return this.defaultValue();
+		const decoded = this.fromEncoded(value, format);
+		if (this.isDefaultValue(decoded)) return this.defaultValue();
+		return decoded;
+	}
+	/**
+	* Decode an optional value from wire format (preserves undefined vs default distinction)
+	* @param value - The wire value
+	* @param format - The wire format (json or msgpack)
+	* @returns The decoded application value, or undefined if wire value was undefined
+	*/
+	decodeOptional(value, format) {
+		if (value === void 0 || value === null) return void 0;
+		return this.fromEncoded(value, format);
+	}
+	/**
+	* Transform application value to wire format
+	* Override this method to implement encoding logic, otherwise defaults to pass-through
+	* @param value - The application value (guaranteed to not be undefined or default)
+	* @param format - The wire format
+	* @returns The encoded value
+	*/
+	toEncoded(value, format) {
+		return value;
+	}
+	/**
+	* Transform wire format to application value
+	* Override this method to implement specific decoding logic, otherwise defaults to pass-through
+	* @param value - The wire value (guaranteed to not be undefined)
+	* @param format - The wire format
+	* @returns The decoded value
+	*/
+	fromEncoded(value, format) {
+		return value;
+	}
+	/**
+	* Check if a value equals the default value (determines if it should be omitted during encoding)
+	* Override this method for custom default comparison logic, otherwise defaults to default value equality
+	* @param value - The value to check
+	* @returns True if value equals default
+	*/
+	isDefaultValue(value) {
+		return value === this.defaultValue();
+	}
+};
+
+//#endregion
+exports.Codec = Codec;
+//# sourceMappingURL=codec.js.map

package/packages/common/src/codecs/codec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.js","names":[],"sources":["../../../../../packages/common/src/codecs/codec.ts"],"sourcesContent":["/* eslint-disable unused-imports/no-unused-vars */\nimport type { EncodingFormat } from './types'\n\n/**\n * A bidirectional codec that transforms between application types and wire formats.\n * Supports format-specific encoding (JSON vs msgpack).\n *\n * @template T - The application/runtime type (e.g., bigint, string, Uint8Array)\n * @template TEncoded - The wire format type (may differ based on format, e.g., bigint → string in JSON)\n */\nexport abstract class Codec<T, TEncoded = T, TWireEncoded = TEncoded> {\n  /**\n   * The default value for this type (used to determine if a value should be omitted during encoding)\n   */\n  public abstract defaultValue(): T\n\n  /**\n   * Encode a value, always returning the value regardless of if it is default\n   * @param value - The application value\n   * @param format - The wire format (json or msgpack)\n   * @returns The encoded value, or the default if it is undefined or null\n   */\n  public encode(value: T | undefined | null, format: EncodingFormat): TEncoded {\n    if (value === undefined || value === null || this.isDefaultValue(value)) return this.toEncoded(this.defaultValue(), format)\n    return this.toEncoded(value, format)\n  }\n\n  /**\n   * Encode a value, omitting it if set to the default value.\n   * @param value - The application value\n   * @param format - The wire format (json or msgpack)\n   * @returns The encoded value, or undefined if it equals the default (will be omitted)\n   */\n  public encodeOptional(value: T | undefined | null, format: EncodingFormat): TEncoded | undefined {\n    if (value === undefined || value === null) return undefined\n    if (this.isDefaultValue(value)) return undefined\n    return this.toEncoded(value, format)\n  }\n\n  /**\n   * Decode a value from wire format\n   * @param value - The wire value\n   * @param format - The wire format (json or msgpack)\n   * @returns The decoded application value\n   */\n  public decode(value: TWireEncoded | undefined | null, format: EncodingFormat): T {\n    // undefined is encoded as msgpack nil, which may be decoded as JS null. Treat null and undefined the same.\n    if (value === undefined || value === null) return this.defaultValue()\n    const decoded = this.fromEncoded(value, format)\n    if (this.isDefaultValue(decoded)) return this.defaultValue()\n    return decoded\n  }\n\n  /**\n   * Decode an optional value from wire format (preserves undefined vs default distinction)\n   * @param value - The wire value\n   * @param format - The wire format (json or msgpack)\n   * @returns The decoded application value, or undefined if wire value was undefined\n   */\n  public decodeOptional(value: TWireEncoded | undefined | null, format: EncodingFormat): T | undefined {\n    // undefined is encoded as msgpack nil, which may be decoded as JS null. Treat null and undefined the same.\n    if (value === undefined || value === null) return undefined\n    return this.fromEncoded(value, format)\n  }\n\n  /**\n   * Transform application value to wire format\n   * Override this method to implement encoding logic, otherwise defaults to pass-through\n   * @param value - The application value (guaranteed to not be undefined or default)\n   * @param format - The wire format\n   * @returns The encoded value\n   */\n  protected toEncoded(value: T, format: EncodingFormat): TEncoded {\n    return value as unknown as TEncoded\n  }\n\n  /**\n   * Transform wire format to application value\n   * Override this method to implement specific decoding logic, otherwise defaults to pass-through\n   * @param value - The wire value (guaranteed to not be undefined)\n   * @param format - The wire format\n   * @returns The decoded value\n   */\n  protected fromEncoded(value: TWireEncoded, format: EncodingFormat): T {\n    return value as unknown as T\n  }\n\n  /**\n   * Check if a value equals the default value (determines if it should be omitted during encoding)\n   * Override this method for custom default comparison logic, otherwise defaults to default value equality\n   * @param value - The value to check\n   * @returns True if value equals default\n   */\n  public isDefaultValue(value: T): boolean {\n    return value === this.defaultValue()\n  }\n}\n"],"mappings":";;;;;;;;;AAUA,IAAsB,QAAtB,MAAsE;;;;;;;CAYpE,AAAO,OAAO,OAA6B,QAAkC;AAC3E,MAAI,UAAU,UAAa,UAAU,QAAQ,KAAK,eAAe,MAAM,CAAE,QAAO,KAAK,UAAU,KAAK,cAAc,EAAE,OAAO;AAC3H,SAAO,KAAK,UAAU,OAAO,OAAO;;;;;;;;CAStC,AAAO,eAAe,OAA6B,QAA8C;AAC/F,MAAI,UAAU,UAAa,UAAU,KAAM,QAAO;AAClD,MAAI,KAAK,eAAe,MAAM,CAAE,QAAO;AACvC,SAAO,KAAK,UAAU,OAAO,OAAO;;;;;;;;CAStC,AAAO,OAAO,OAAwC,QAA2B;AAE/E,MAAI,UAAU,UAAa,UAAU,KAAM,QAAO,KAAK,cAAc;EACrE,MAAM,UAAU,KAAK,YAAY,OAAO,OAAO;AAC/C,MAAI,KAAK,eAAe,QAAQ,CAAE,QAAO,KAAK,cAAc;AAC5D,SAAO;;;;;;;;CAST,AAAO,eAAe,OAAwC,QAAuC;AAEnG,MAAI,UAAU,UAAa,UAAU,KAAM,QAAO;AAClD,SAAO,KAAK,YAAY,OAAO,OAAO;;;;;;;;;CAUxC,AAAU,UAAU,OAAU,QAAkC;AAC9D,SAAO;;;;;;;;;CAUT,AAAU,YAAY,OAAqB,QAA2B;AACpE,SAAO;;;;;;;;CAST,AAAO,eAAe,OAAmB;AACvC,SAAO,UAAU,KAAK,cAAc"}

package/packages/common/src/codecs/codec.mjs

@@ -0,0 +1,86 @@
+//#region packages/common/src/codecs/codec.ts
+/**
+* A bidirectional codec that transforms between application types and wire formats.
+* Supports format-specific encoding (JSON vs msgpack).
+*
+* @template T - The application/runtime type (e.g., bigint, string, Uint8Array)
+* @template TEncoded - The wire format type (may differ based on format, e.g., bigint → string in JSON)
+*/
+var Codec = class {
+	/**
+	* Encode a value, always returning the value regardless of if it is default
+	* @param value - The application value
+	* @param format - The wire format (json or msgpack)
+	* @returns The encoded value, or the default if it is undefined or null
+	*/
+	encode(value, format) {
+		if (value === void 0 || value === null || this.isDefaultValue(value)) return this.toEncoded(this.defaultValue(), format);
+		return this.toEncoded(value, format);
+	}
+	/**
+	* Encode a value, omitting it if set to the default value.
+	* @param value - The application value
+	* @param format - The wire format (json or msgpack)
+	* @returns The encoded value, or undefined if it equals the default (will be omitted)
+	*/
+	encodeOptional(value, format) {
+		if (value === void 0 || value === null) return void 0;
+		if (this.isDefaultValue(value)) return void 0;
+		return this.toEncoded(value, format);
+	}
+	/**
+	* Decode a value from wire format
+	* @param value - The wire value
+	* @param format - The wire format (json or msgpack)
+	* @returns The decoded application value
+	*/
+	decode(value, format) {
+		if (value === void 0 || value === null) return this.defaultValue();
+		const decoded = this.fromEncoded(value, format);
+		if (this.isDefaultValue(decoded)) return this.defaultValue();
+		return decoded;
+	}
+	/**
+	* Decode an optional value from wire format (preserves undefined vs default distinction)
+	* @param value - The wire value
+	* @param format - The wire format (json or msgpack)
+	* @returns The decoded application value, or undefined if wire value was undefined
+	*/
+	decodeOptional(value, format) {
+		if (value === void 0 || value === null) return void 0;
+		return this.fromEncoded(value, format);
+	}
+	/**
+	* Transform application value to wire format
+	* Override this method to implement encoding logic, otherwise defaults to pass-through
+	* @param value - The application value (guaranteed to not be undefined or default)
+	* @param format - The wire format
+	* @returns The encoded value
+	*/
+	toEncoded(value, format) {
+		return value;
+	}
+	/**
+	* Transform wire format to application value
+	* Override this method to implement specific decoding logic, otherwise defaults to pass-through
+	* @param value - The wire value (guaranteed to not be undefined)
+	* @param format - The wire format
+	* @returns The decoded value
+	*/
+	fromEncoded(value, format) {
+		return value;
+	}
+	/**
+	* Check if a value equals the default value (determines if it should be omitted during encoding)
+	* Override this method for custom default comparison logic, otherwise defaults to default value equality
+	* @param value - The value to check
+	* @returns True if value equals default
+	*/
+	isDefaultValue(value) {
+		return value === this.defaultValue();
+	}
+};
+
+//#endregion
+export { Codec };
+//# sourceMappingURL=codec.mjs.map

package/packages/common/src/codecs/codec.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.mjs","names":[],"sources":["../../../../../packages/common/src/codecs/codec.ts"],"sourcesContent":["/* eslint-disable unused-imports/no-unused-vars */\nimport type { EncodingFormat } from './types'\n\n/**\n * A bidirectional codec that transforms between application types and wire formats.\n * Supports format-specific encoding (JSON vs msgpack).\n *\n * @template T - The application/runtime type (e.g., bigint, string, Uint8Array)\n * @template TEncoded - The wire format type (may differ based on format, e.g., bigint → string in JSON)\n */\nexport abstract class Codec<T, TEncoded = T, TWireEncoded = TEncoded> {\n  /**\n   * The default value for this type (used to determine if a value should be omitted during encoding)\n   */\n  public abstract defaultValue(): T\n\n  /**\n   * Encode a value, always returning the value regardless of if it is default\n   * @param value - The application value\n   * @param format - The wire format (json or msgpack)\n   * @returns The encoded value, or the default if it is undefined or null\n   */\n  public encode(value: T | undefined | null, format: EncodingFormat): TEncoded {\n    if (value === undefined || value === null || this.isDefaultValue(value)) return this.toEncoded(this.defaultValue(), format)\n    return this.toEncoded(value, format)\n  }\n\n  /**\n   * Encode a value, omitting it if set to the default value.\n   * @param value - The application value\n   * @param format - The wire format (json or msgpack)\n   * @returns The encoded value, or undefined if it equals the default (will be omitted)\n   */\n  public encodeOptional(value: T | undefined | null, format: EncodingFormat): TEncoded | undefined {\n    if (value === undefined || value === null) return undefined\n    if (this.isDefaultValue(value)) return undefined\n    return this.toEncoded(value, format)\n  }\n\n  /**\n   * Decode a value from wire format\n   * @param value - The wire value\n   * @param format - The wire format (json or msgpack)\n   * @returns The decoded application value\n   */\n  public decode(value: TWireEncoded | undefined | null, format: EncodingFormat): T {\n    // undefined is encoded as msgpack nil, which may be decoded as JS null. Treat null and undefined the same.\n    if (value === undefined || value === null) return this.defaultValue()\n    const decoded = this.fromEncoded(value, format)\n    if (this.isDefaultValue(decoded)) return this.defaultValue()\n    return decoded\n  }\n\n  /**\n   * Decode an optional value from wire format (preserves undefined vs default distinction)\n   * @param value - The wire value\n   * @param format - The wire format (json or msgpack)\n   * @returns The decoded application value, or undefined if wire value was undefined\n   */\n  public decodeOptional(value: TWireEncoded | undefined | null, format: EncodingFormat): T | undefined {\n    // undefined is encoded as msgpack nil, which may be decoded as JS null. Treat null and undefined the same.\n    if (value === undefined || value === null) return undefined\n    return this.fromEncoded(value, format)\n  }\n\n  /**\n   * Transform application value to wire format\n   * Override this method to implement encoding logic, otherwise defaults to pass-through\n   * @param value - The application value (guaranteed to not be undefined or default)\n   * @param format - The wire format\n   * @returns The encoded value\n   */\n  protected toEncoded(value: T, format: EncodingFormat): TEncoded {\n    return value as unknown as TEncoded\n  }\n\n  /**\n   * Transform wire format to application value\n   * Override this method to implement specific decoding logic, otherwise defaults to pass-through\n   * @param value - The wire value (guaranteed to not be undefined)\n   * @param format - The wire format\n   * @returns The decoded value\n   */\n  protected fromEncoded(value: TWireEncoded, format: EncodingFormat): T {\n    return value as unknown as T\n  }\n\n  /**\n   * Check if a value equals the default value (determines if it should be omitted during encoding)\n   * Override this method for custom default comparison logic, otherwise defaults to default value equality\n   * @param value - The value to check\n   * @returns True if value equals default\n   */\n  public isDefaultValue(value: T): boolean {\n    return value === this.defaultValue()\n  }\n}\n"],"mappings":";;;;;;;;AAUA,IAAsB,QAAtB,MAAsE;;;;;;;CAYpE,AAAO,OAAO,OAA6B,QAAkC;AAC3E,MAAI,UAAU,UAAa,UAAU,QAAQ,KAAK,eAAe,MAAM,CAAE,QAAO,KAAK,UAAU,KAAK,cAAc,EAAE,OAAO;AAC3H,SAAO,KAAK,UAAU,OAAO,OAAO;;;;;;;;CAStC,AAAO,eAAe,OAA6B,QAA8C;AAC/F,MAAI,UAAU,UAAa,UAAU,KAAM,QAAO;AAClD,MAAI,KAAK,eAAe,MAAM,CAAE,QAAO;AACvC,SAAO,KAAK,UAAU,OAAO,OAAO;;;;;;;;CAStC,AAAO,OAAO,OAAwC,QAA2B;AAE/E,MAAI,UAAU,UAAa,UAAU,KAAM,QAAO,KAAK,cAAc;EACrE,MAAM,UAAU,KAAK,YAAY,OAAO,OAAO;AAC/C,MAAI,KAAK,eAAe,QAAQ,CAAE,QAAO,KAAK,cAAc;AAC5D,SAAO;;;;;;;;CAST,AAAO,eAAe,OAAwC,QAAuC;AAEnG,MAAI,UAAU,UAAa,UAAU,KAAM,QAAO;AAClD,SAAO,KAAK,YAAY,OAAO,OAAO;;;;;;;;;CAUxC,AAAU,UAAU,OAAU,QAAkC;AAC9D,SAAO;;;;;;;;;CAUT,AAAU,YAAY,OAAqB,QAA2B;AACpE,SAAO;;;;;;;;CAST,AAAO,eAAe,OAAmB;AACvC,SAAO,UAAU,KAAK,cAAc"}

package/packages/common/src/codecs/composite/array.js

@@ -0,0 +1,45 @@
+const require_codec = require('../codec.js');
+const require_address = require('../primitives/address.js');
+const require_bigint = require('../primitives/bigint.js');
+const require_boolean = require('../primitives/boolean.js');
+const require_bytes = require('../primitives/bytes.js');
+const require_number = require('../primitives/number.js');
+const require_string = require('../primitives/string.js');
+
+//#region packages/common/src/codecs/composite/array.ts
+/**
+* Array codec - encodes each element using the item codec
+*/
+var ArrayCodec = class extends require_codec.Codec {
+	constructor(itemCodec) {
+		super();
+		this.itemCodec = itemCodec;
+	}
+	defaultValue() {
+		return [];
+	}
+	toEncoded(value, format) {
+		return value.map((item) => this.itemCodec.encode(item, format));
+	}
+	fromEncoded(value, format) {
+		return value.map((item) => this.itemCodec.decode(item, format));
+	}
+	isDefaultValue(value) {
+		return value.length === 0;
+	}
+};
+const bytesArrayCodec = new ArrayCodec(require_bytes.bytesCodec);
+const addressArrayCodec = new ArrayCodec(require_address.addressCodec);
+const bigIntArrayCodec = new ArrayCodec(require_bigint.bigIntCodec);
+const numberArrayCodec = new ArrayCodec(require_number.numberCodec);
+const booleanArrayCodec = new ArrayCodec(require_boolean.booleanCodec);
+const stringArrayCodec = new ArrayCodec(require_string.stringCodec);
+
+//#endregion
+exports.ArrayCodec = ArrayCodec;
+exports.addressArrayCodec = addressArrayCodec;
+exports.bigIntArrayCodec = bigIntArrayCodec;
+exports.bytesArrayCodec = bytesArrayCodec;
+exports.numberArrayCodec = numberArrayCodec;
+exports.stringArrayCodec = stringArrayCodec;
+//# sourceMappingURL=array.js.map

package/packages/common/src/codecs/composite/array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.js","names":["Codec","itemCodec: Codec<T, TEncoded>","bytesCodec","addressCodec","bigIntCodec","numberCodec","booleanCodec","stringCodec"],"sources":["../../../../../../packages/common/src/codecs/composite/array.ts"],"sourcesContent":["import { Codec } from '../codec'\nimport { addressCodec } from '../primitives/address'\nimport { bigIntCodec } from '../primitives/bigint'\nimport { booleanCodec } from '../primitives/boolean'\nimport { bytesCodec } from '../primitives/bytes'\nimport { numberCodec } from '../primitives/number'\nimport { stringCodec } from '../primitives/string'\nimport type { EncodingFormat } from '../types'\n\n/**\n * Array codec - encodes each element using the item codec\n */\nexport class ArrayCodec<T, TEncoded = T> extends Codec<T[], TEncoded[]> {\n  constructor(private readonly itemCodec: Codec<T, TEncoded>) {\n    super()\n  }\n\n  public defaultValue(): T[] {\n    return []\n  }\n\n  protected toEncoded(value: T[], format: EncodingFormat): TEncoded[] {\n    return value.map((item) => this.itemCodec.encode(item, format))\n  }\n\n  protected fromEncoded(value: TEncoded[], format: EncodingFormat): T[] {\n    return value.map((item) => this.itemCodec.decode(item, format))\n  }\n\n  public isDefaultValue(value: T[]): boolean {\n    return value.length === 0\n  }\n}\n\nexport const bytesArrayCodec = new ArrayCodec(bytesCodec)\nexport const addressArrayCodec = new ArrayCodec(addressCodec)\nexport const bigIntArrayCodec = new ArrayCodec(bigIntCodec)\nexport const numberArrayCodec = new ArrayCodec(numberCodec)\nexport const booleanArrayCodec = new ArrayCodec(booleanCodec)\nexport const stringArrayCodec = new ArrayCodec(stringCodec)\n"],"mappings":";;;;;;;;;;;;AAYA,IAAa,aAAb,cAAiDA,oBAAuB;CACtE,YAAY,AAAiBC,WAA+B;AAC1D,SAAO;EADoB;;CAI7B,AAAO,eAAoB;AACzB,SAAO,EAAE;;CAGX,AAAU,UAAU,OAAY,QAAoC;AAClE,SAAO,MAAM,KAAK,SAAS,KAAK,UAAU,OAAO,MAAM,OAAO,CAAC;;CAGjE,AAAU,YAAY,OAAmB,QAA6B;AACpE,SAAO,MAAM,KAAK,SAAS,KAAK,UAAU,OAAO,MAAM,OAAO,CAAC;;CAGjE,AAAO,eAAe,OAAqB;AACzC,SAAO,MAAM,WAAW;;;AAI5B,MAAa,kBAAkB,IAAI,WAAWC,yBAAW;AACzD,MAAa,oBAAoB,IAAI,WAAWC,6BAAa;AAC7D,MAAa,mBAAmB,IAAI,WAAWC,2BAAY;AAC3D,MAAa,mBAAmB,IAAI,WAAWC,2BAAY;AAC3D,MAAa,oBAAoB,IAAI,WAAWC,6BAAa;AAC7D,MAAa,mBAAmB,IAAI,WAAWC,2BAAY"}

package/packages/common/src/codecs/composite/array.mjs

@@ -0,0 +1,40 @@
+import { Codec } from "../codec.mjs";
+import { addressCodec } from "../primitives/address.mjs";
+import { bigIntCodec } from "../primitives/bigint.mjs";
+import { booleanCodec } from "../primitives/boolean.mjs";
+import { bytesCodec } from "../primitives/bytes.mjs";
+import { numberCodec } from "../primitives/number.mjs";
+import { stringCodec } from "../primitives/string.mjs";
+
+//#region packages/common/src/codecs/composite/array.ts
+/**
+* Array codec - encodes each element using the item codec
+*/
+var ArrayCodec = class extends Codec {
+	constructor(itemCodec) {
+		super();
+		this.itemCodec = itemCodec;
+	}
+	defaultValue() {
+		return [];
+	}
+	toEncoded(value, format) {
+		return value.map((item) => this.itemCodec.encode(item, format));
+	}
+	fromEncoded(value, format) {
+		return value.map((item) => this.itemCodec.decode(item, format));
+	}
+	isDefaultValue(value) {
+		return value.length === 0;
+	}
+};
+const bytesArrayCodec = new ArrayCodec(bytesCodec);
+const addressArrayCodec = new ArrayCodec(addressCodec);
+const bigIntArrayCodec = new ArrayCodec(bigIntCodec);
+const numberArrayCodec = new ArrayCodec(numberCodec);
+const booleanArrayCodec = new ArrayCodec(booleanCodec);
+const stringArrayCodec = new ArrayCodec(stringCodec);
+
+//#endregion
+export { ArrayCodec, addressArrayCodec, bigIntArrayCodec, bytesArrayCodec, numberArrayCodec, stringArrayCodec };
+//# sourceMappingURL=array.mjs.map

package/packages/common/src/codecs/composite/array.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.mjs","names":["itemCodec: Codec<T, TEncoded>"],"sources":["../../../../../../packages/common/src/codecs/composite/array.ts"],"sourcesContent":["import { Codec } from '../codec'\nimport { addressCodec } from '../primitives/address'\nimport { bigIntCodec } from '../primitives/bigint'\nimport { booleanCodec } from '../primitives/boolean'\nimport { bytesCodec } from '../primitives/bytes'\nimport { numberCodec } from '../primitives/number'\nimport { stringCodec } from '../primitives/string'\nimport type { EncodingFormat } from '../types'\n\n/**\n * Array codec - encodes each element using the item codec\n */\nexport class ArrayCodec<T, TEncoded = T> extends Codec<T[], TEncoded[]> {\n  constructor(private readonly itemCodec: Codec<T, TEncoded>) {\n    super()\n  }\n\n  public defaultValue(): T[] {\n    return []\n  }\n\n  protected toEncoded(value: T[], format: EncodingFormat): TEncoded[] {\n    return value.map((item) => this.itemCodec.encode(item, format))\n  }\n\n  protected fromEncoded(value: TEncoded[], format: EncodingFormat): T[] {\n    return value.map((item) => this.itemCodec.decode(item, format))\n  }\n\n  public isDefaultValue(value: T[]): boolean {\n    return value.length === 0\n  }\n}\n\nexport const bytesArrayCodec = new ArrayCodec(bytesCodec)\nexport const addressArrayCodec = new ArrayCodec(addressCodec)\nexport const bigIntArrayCodec = new ArrayCodec(bigIntCodec)\nexport const numberArrayCodec = new ArrayCodec(numberCodec)\nexport const booleanArrayCodec = new ArrayCodec(booleanCodec)\nexport const stringArrayCodec = new ArrayCodec(stringCodec)\n"],"mappings":";;;;;;;;;;;;AAYA,IAAa,aAAb,cAAiD,MAAuB;CACtE,YAAY,AAAiBA,WAA+B;AAC1D,SAAO;EADoB;;CAI7B,AAAO,eAAoB;AACzB,SAAO,EAAE;;CAGX,AAAU,UAAU,OAAY,QAAoC;AAClE,SAAO,MAAM,KAAK,SAAS,KAAK,UAAU,OAAO,MAAM,OAAO,CAAC;;CAGjE,AAAU,YAAY,OAAmB,QAA6B;AACpE,SAAO,MAAM,KAAK,SAAS,KAAK,UAAU,OAAO,MAAM,OAAO,CAAC;;CAGjE,AAAO,eAAe,OAAqB;AACzC,SAAO,MAAM,WAAW;;;AAI5B,MAAa,kBAAkB,IAAI,WAAW,WAAW;AACzD,MAAa,oBAAoB,IAAI,WAAW,aAAa;AAC7D,MAAa,mBAAmB,IAAI,WAAW,YAAY;AAC3D,MAAa,mBAAmB,IAAI,WAAW,YAAY;AAC3D,MAAa,oBAAoB,IAAI,WAAW,aAAa;AAC7D,MAAa,mBAAmB,IAAI,WAAW,YAAY"}

package/packages/common/src/codecs/composite/map.js

@@ -0,0 +1,65 @@
+const require_codec = require('../codec.js');
+
+//#region packages/common/src/codecs/composite/map.ts
+/**
+* Map codec - handles Maps with any key type (including Uint8Array, bigint, number)
+* Depending on the encoding format, the map is encoded differently:
+* - json: Only supports string keys and is represented as an object when encoding.
+*   An exception is thrown upon encountering a non-string key.
+* - msgpack: Preserves key types and is represented as a Map when encoding.
+*/
+var MapCodec = class extends require_codec.Codec {
+	keyType;
+	constructor(keyCodec, valueCodec) {
+		super();
+		this.keyCodec = keyCodec;
+		this.valueCodec = valueCodec;
+		const defaultKeyValue = this.keyCodec.defaultValue();
+		this.keyType = defaultKeyValue instanceof Uint8Array ? "Uint8Array" : typeof defaultKeyValue;
+	}
+	defaultValue() {
+		return /* @__PURE__ */ new Map();
+	}
+	ensureKeyIsSupported(format) {
+		if (format === "msgpack") return true;
+		if (this.keyType !== "string") throw new Error(`Map key of type '${this.keyType}' is not supported in ${format} format`);
+	}
+	toEncoded(value, format) {
+		this.ensureKeyIsSupported(format);
+		const entries = [];
+		for (const [k, v] of value.entries()) {
+			const encodedKey = this.keyCodec.encode(k, format);
+			const encodedValue = this.valueCodec.encode(v, format);
+			entries.push([encodedKey, encodedValue]);
+		}
+		if (format === "json") {
+			const obj = {};
+			for (const [k, v] of entries) {
+				const keyStr = typeof k === "string" ? k : String(k);
+				obj[keyStr] = v;
+			}
+			return obj;
+		}
+		return new Map(entries);
+	}
+	fromEncoded(value, format) {
+		this.ensureKeyIsSupported(format);
+		const result = /* @__PURE__ */ new Map();
+		let entries;
+		if (value instanceof Map) entries = Array.from(value.entries());
+		else entries = Object.entries(value);
+		for (const [encodedKey, encodedValue] of entries) {
+			const key = this.keyCodec.decode(encodedKey, format);
+			const val = this.valueCodec.decode(encodedValue, format);
+			result.set(key, val);
+		}
+		return result;
+	}
+	isDefaultValue(value) {
+		return value.size === 0;
+	}
+};
+
+//#endregion
+exports.MapCodec = MapCodec;
+//# sourceMappingURL=map.js.map