@umbra-privacy/sdk 1.0.0 → 2.0.0

package/dist/chunk-TLR7A64G.js

@@ -0,0 +1,103 @@
+import { __name } from './chunk-7QVYU63E.js';
+
+// src/common/converters/miscellaneous.ts
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(sleep, "sleep");
+function base64ToUint8Array(base64) {
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(base64, "base64"));
+  }
+  return Uint8Array.from(atob(base64), (c) => c.codePointAt(0) ?? 0);
+}
+__name(base64ToUint8Array, "base64ToUint8Array");
+function uint8ArrayToBase64(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  return btoa(String.fromCodePoint(...bytes));
+}
+__name(uint8ArrayToBase64, "uint8ArrayToBase64");
+function hexToBytes(hex) {
+  const cleaned = hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
+  if (cleaned.length % 2 !== 0) {
+    throw new Error(`hexToBytes: hex string must have even length, got ${String(cleaned.length)}`);
+  }
+  const bytes = new Uint8Array(cleaned.length / 2);
+  for (let i = 0; i < cleaned.length; i += 2) {
+    const byte = parseInt(cleaned.substring(i, i + 2), 16);
+    if (Number.isNaN(byte)) {
+      throw new Error(`hexToBytes: invalid hex character at position ${String(i)}`);
+    }
+    bytes[i / 2] = byte;
+  }
+  return bytes;
+}
+__name(hexToBytes, "hexToBytes");
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+__name(bytesToHex, "bytesToHex");
+function encodeBigintToLeBytes(value, byteLength) {
+  if (value < 0n) {
+    throw new RangeError(`encodeBigintToLeBytes: value must be non-negative, got ${String(value)}`);
+  }
+  const maxValue = (1n << BigInt(byteLength * 8)) - 1n;
+  if (value > maxValue) {
+    throw new RangeError(
+      `encodeBigintToLeBytes: value ${String(value)} does not fit in ${String(byteLength)} bytes`
+    );
+  }
+  const bytes = new Uint8Array(byteLength);
+  let remaining = value;
+  for (let i = 0; i < byteLength; i++) {
+    bytes[i] = Number(remaining & 0xffn);
+    remaining >>= 8n;
+  }
+  return bytes;
+}
+__name(encodeBigintToLeBytes, "encodeBigintToLeBytes");
+function encodeBigintToBeBytes(value, byteLength) {
+  if (value < 0n) {
+    throw new RangeError(`encodeBigintToBeBytes: value must be non-negative, got ${String(value)}`);
+  }
+  const maxValue = (1n << BigInt(byteLength * 8)) - 1n;
+  if (value > maxValue) {
+    throw new RangeError(
+      `encodeBigintToBeBytes: value ${String(value)} does not fit in ${String(byteLength)} bytes`
+    );
+  }
+  const bytes = new Uint8Array(byteLength);
+  let remaining = value;
+  for (let i = byteLength - 1; i >= 0; i--) {
+    bytes[i] = Number(remaining & 0xffn);
+    remaining >>= 8n;
+  }
+  return bytes;
+}
+__name(encodeBigintToBeBytes, "encodeBigintToBeBytes");
+function decodeLeBytesToBigint(bytes) {
+  let value = 0n;
+  for (let i = bytes.length - 1; i >= 0; i--) {
+    value = value << 8n | BigInt(bytes[i]);
+  }
+  return value;
+}
+__name(decodeLeBytesToBigint, "decodeLeBytesToBigint");
+function decodeBeBytesToBigint(bytes) {
+  let value = 0n;
+  for (const byte of bytes) {
+    value = value << 8n | BigInt(byte);
+  }
+  return value;
+}
+__name(decodeBeBytesToBigint, "decodeBeBytesToBigint");
+
+export { base64ToUint8Array, bytesToHex, decodeBeBytesToBigint, decodeLeBytesToBigint, encodeBigintToBeBytes, encodeBigintToLeBytes, hexToBytes, sleep, uint8ArrayToBase64 };
+//# sourceMappingURL=chunk-TLR7A64G.js.map
+//# sourceMappingURL=chunk-TLR7A64G.js.map

package/dist/chunk-TLR7A64G.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/converters/miscellaneous.ts"],"names":[],"mappings":"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","file":"chunk-TLR7A64G.js","sourcesContent":["/**\n * Miscellaneous Utility Converters\n *\n * Provides general-purpose conversion and utility functions used across\n * multiple SDK modules. These are intentionally co-located in the converters\n * module to avoid duplication.\n *\n * @module common/converters/miscellaneous\n * @since 2.0.0\n */\n\n// =============================================================================\n// TYPE UTILITIES\n// =============================================================================\n\n/**\n * Utility type that removes `readonly` modifiers from all properties of a type.\n *\n * This is useful when you need to create a mutable version of an immutable type,\n * such as when building objects incrementally before freezing them.\n *\n * @typeParam T - The type to make writable\n *\n * @remarks\n * The `-readonly` modifier removes the `readonly` attribute from each property,\n * effectively making all properties mutable.\n *\n * @example\n * ```typescript\n * interface ReadonlyUser {\n *     readonly id: string;\n *     readonly name: string;\n * }\n *\n * // MutableUser has { id: string; name: string } (no readonly)\n * type MutableUser = Writable<ReadonlyUser>;\n *\n * const user: MutableUser = { id: \"1\", name: \"Alice\" };\n * user.name = \"Bob\"; // OK - property is now writable\n * ```\n *\n * @since 2.0.0\n * @public\n */\nexport type Writable<T> = {\n  -readonly [P in keyof T]: T[P];\n};\n\n// =============================================================================\n// ASYNC UTILITIES\n// =============================================================================\n\n/**\n * Pauses execution for the specified number of milliseconds.\n *\n * @param ms - Duration to sleep in milliseconds. Must be a non-negative integer.\n * @returns A `Promise<void>` that resolves after `ms` milliseconds.\n *\n * @example\n * ```typescript\n * await sleep(2000); // Wait 2 seconds\n * ```\n *\n * @since 2.0.0\n * @public\n */\nexport async function sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n// =============================================================================\n// ENCODING UTILITIES\n// =============================================================================\n\n/**\n * Decodes a base64-encoded string into a `Uint8Array`.\n *\n * Works in both browser (using `atob`) and Node.js (using `Buffer`) environments,\n * selecting the appropriate decoding strategy at runtime.\n *\n * @param base64 - The base64-encoded string to decode.\n * @returns The decoded bytes as a `Uint8Array`.\n *\n * @throws {Error} If the input is not valid base64.\n *\n * @example\n * ```typescript\n * const bytes = base64ToUint8Array(\"SGVsbG8=\"); // Uint8Array([72, 101, 108, 108, 111])\n * ```\n *\n * @since 2.0.0\n * @public\n */\nexport function base64ToUint8Array(base64: string): Uint8Array {\n  if (typeof Buffer !== \"undefined\") {\n    return new Uint8Array(Buffer.from(base64, \"base64\"));\n  }\n  return Uint8Array.from(atob(base64), (c) => c.codePointAt(0) ?? 0);\n}\n\n/**\n * Encodes a `Uint8Array` into a base64 string.\n *\n * Works in both browser (using `btoa`) and Node.js (using `Buffer`) environments.\n *\n * @param bytes - The byte array to encode.\n * @returns The base64-encoded string.\n *\n * @example\n * ```typescript\n * const b64 = uint8ArrayToBase64(new Uint8Array([72, 101, 108, 108, 111])); // \"SGVsbG8=\"\n * ```\n *\n * @since 2.0.0\n * @public\n */\nexport function uint8ArrayToBase64(bytes: Uint8Array): string {\n  if (typeof Buffer !== \"undefined\") {\n    return Buffer.from(bytes).toString(\"base64\");\n  }\n  return btoa(String.fromCodePoint(...bytes));\n}\n\n// =============================================================================\n// HEX ENCODING\n// =============================================================================\n\n/**\n * Decodes a hex string into a `Uint8Array`.\n *\n * @remarks\n * Accepts hex strings with or without a `0x` prefix. The input must have an\n * even number of hex characters (each byte is two hex digits).\n *\n * @param hex - The hex-encoded string to decode (e.g. `\"48656c6c6f\"` or `\"0x48656c6c6f\"`).\n * @returns The decoded bytes as a `Uint8Array`.\n *\n * @throws {Error} If the input contains non-hex characters or has odd length.\n *\n * @example\n * ```typescript\n * const bytes = hexToBytes(\"48656c6c6f\"); // Uint8Array([72, 101, 108, 108, 111])\n * const bytes2 = hexToBytes(\"0x48656c6c6f\"); // same result\n * ```\n *\n * @since 2.0.0\n * @public\n */\nexport function hexToBytes(hex: string): Uint8Array {\n  const cleaned = hex.startsWith(\"0x\") || hex.startsWith(\"0X\") ? hex.slice(2) : hex;\n  if (cleaned.length % 2 !== 0) {\n    throw new Error(`hexToBytes: hex string must have even length, got ${String(cleaned.length)}`);\n  }\n  const bytes = new Uint8Array(cleaned.length / 2);\n  for (let i = 0; i < cleaned.length; i += 2) {\n    const byte = parseInt(cleaned.substring(i, i + 2), 16);\n    if (Number.isNaN(byte)) {\n      throw new Error(`hexToBytes: invalid hex character at position ${String(i)}`);\n    }\n    bytes[i / 2] = byte;\n  }\n  return bytes;\n}\n\n/**\n * Encodes a `Uint8Array` into a lowercase hex string (without `0x` prefix).\n *\n * @param bytes - The byte array to encode.\n * @returns The hex-encoded string (lowercase, no prefix).\n *\n * @example\n * ```typescript\n * const hex = bytesToHex(new Uint8Array([72, 101, 108, 108, 111])); // \"48656c6c6f\"\n * ```\n *\n * @since 2.0.0\n * @public\n */\nexport function bytesToHex(bytes: Uint8Array): string {\n  let hex = \"\";\n  for (const byte of bytes) {\n    hex += byte.toString(16).padStart(2, \"0\");\n  }\n  return hex;\n}\n\n// =============================================================================\n// GENERIC BIGINT ↔ BYTES\n// =============================================================================\n\n/**\n * Encodes a non-negative bigint into a little-endian byte array of the specified length.\n *\n * @param value - The non-negative bigint to encode.\n * @param byteLength - The number of output bytes. The value must fit within this many bytes.\n * @returns A `Uint8Array` of exactly `byteLength` bytes in little-endian order.\n *\n * @throws {RangeError} If `value` is negative or doesn't fit in `byteLength` bytes.\n *\n * @example\n * ```typescript\n * const bytes = encodeBigintToLeBytes(256n, 4); // Uint8Array([0, 1, 0, 0])\n * ```\n *\n * @since 2.0.0\n * @public\n */\nexport function encodeBigintToLeBytes(value: bigint, byteLength: number): Uint8Array {\n  if (value < 0n) {\n    throw new RangeError(`encodeBigintToLeBytes: value must be non-negative, got ${String(value)}`);\n  }\n  const maxValue = (1n << BigInt(byteLength * 8)) - 1n;\n  if (value > maxValue) {\n    throw new RangeError(\n      `encodeBigintToLeBytes: value ${String(value)} does not fit in ${String(byteLength)} bytes`,\n    );\n  }\n  const bytes = new Uint8Array(byteLength);\n  let remaining = value;\n  for (let i = 0; i < byteLength; i++) {\n    bytes[i] = Number(remaining & 0xffn);\n    remaining >>= 8n;\n  }\n  return bytes;\n}\n\n/**\n * Encodes a non-negative bigint into a big-endian byte array of the specified length.\n *\n * @param value - The non-negative bigint to encode.\n * @param byteLength - The number of output bytes. The value must fit within this many bytes.\n * @returns A `Uint8Array` of exactly `byteLength` bytes in big-endian order.\n *\n * @throws {RangeError} If `value` is negative or doesn't fit in `byteLength` bytes.\n *\n * @example\n * ```typescript\n * const bytes = encodeBigintToBeBytes(256n, 4); // Uint8Array([0, 0, 1, 0])\n * ```\n *\n * @since 2.0.0\n * @public\n */\nexport function encodeBigintToBeBytes(value: bigint, byteLength: number): Uint8Array {\n  if (value < 0n) {\n    throw new RangeError(`encodeBigintToBeBytes: value must be non-negative, got ${String(value)}`);\n  }\n  const maxValue = (1n << BigInt(byteLength * 8)) - 1n;\n  if (value > maxValue) {\n    throw new RangeError(\n      `encodeBigintToBeBytes: value ${String(value)} does not fit in ${String(byteLength)} bytes`,\n    );\n  }\n  const bytes = new Uint8Array(byteLength);\n  let remaining = value;\n  for (let i = byteLength - 1; i >= 0; i--) {\n    bytes[i] = Number(remaining & 0xffn);\n    remaining >>= 8n;\n  }\n  return bytes;\n}\n\n/**\n * Decodes a little-endian `Uint8Array` into a non-negative bigint.\n *\n * @param bytes - The little-endian byte array to decode.\n * @returns The decoded bigint value.\n *\n * @example\n * ```typescript\n * const value = decodeLeBytesToBigint(new Uint8Array([0, 1, 0, 0])); // 256n\n * ```\n *\n * @since 2.0.0\n * @public\n */\nexport function decodeLeBytesToBigint(bytes: Uint8Array): bigint {\n  let value = 0n;\n  for (let i = bytes.length - 1; i >= 0; i--) {\n    value = (value << 8n) | BigInt(bytes[i]);\n  }\n  return value;\n}\n\n/**\n * Decodes a big-endian `Uint8Array` into a non-negative bigint.\n *\n * @param bytes - The big-endian byte array to decode.\n * @returns The decoded bigint value.\n *\n * @example\n * ```typescript\n * const value = decodeBeBytesToBigint(new Uint8Array([0, 0, 1, 0])); // 256n\n * ```\n *\n * @since 2.0.0\n * @public\n */\nexport function decodeBeBytesToBigint(bytes: Uint8Array): bigint {\n  let value = 0n;\n  for (const byte of bytes) {\n    value = (value << 8n) | BigInt(byte);\n  }\n  return value;\n}\n"]}

package/dist/{chunk-MVKTV3FT.cjs → chunk-TQQZGNOI.cjs}

@@ -16,5 +16,5 @@ exports.ARCIUM_EXEC_POOL_SEED = ARCIUM_EXEC_POOL_SEED;
 exports.ARCIUM_MEMPOOL_SEED = ARCIUM_MEMPOOL_SEED;
 exports.ARCIUM_MXE_ACCOUNT_SEED = ARCIUM_MXE_ACCOUNT_SEED;
 exports.ARCIUM_OFFSET_BUFFER_SIZE = ARCIUM_OFFSET_BUFFER_SIZE;
-//# sourceMappingURL=chunk-MVKTV3FT.cjs.map
-//# sourceMappingURL=chunk-MVKTV3FT.cjs.map
+//# sourceMappingURL=chunk-TQQZGNOI.cjs.map
+//# sourceMappingURL=chunk-TQQZGNOI.cjs.map

package/dist/chunk-TQQZGNOI.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/constants/arcium.ts"],"names":[],"mappings":";;;AAgBO,IAAM,uBAAA,GAA0B;AAQhC,IAAM,mBAAA,GAAsB;AAQ5B,IAAM,qBAAA,GAAwB;AAQ9B,IAAM,uBAAA,GAA0B;AAQhC,IAAM,oBAAA,GAAuB;AAQ7B,IAAM,mBAAA,GAAsB;AAQ5B,IAAM,yBAAA,GAA4B","file":"chunk-TQQZGNOI.cjs","sourcesContent":["/**\n * Arcium Protocol Constants\n *\n * This module contains constants for interacting with the Arcium protocol,\n * including the program address and PDA seed prefixes for various account types.\n *\n * @since 2.0.0\n * @module constants/arcium\n */\n\n/**\n * Seed prefix for MXE account PDAs.\n *\n * @remarks\n * Used to derive the MXE account address for a given program.\n */\nexport const ARCIUM_MXE_ACCOUNT_SEED = \"MXEAccount\";\n\n/**\n * Seed prefix for mempool account PDAs.\n *\n * @remarks\n * The mempool stores pending computations for a cluster.\n */\nexport const ARCIUM_MEMPOOL_SEED = \"Mempool\";\n\n/**\n * Seed prefix for executing pool account PDAs.\n *\n * @remarks\n * The executing pool tracks computations currently being processed.\n */\nexport const ARCIUM_EXEC_POOL_SEED = \"Execpool\";\n\n/**\n * Seed prefix for computation account PDAs.\n *\n * @remarks\n * Each computation gets its own account to track state and results.\n */\nexport const ARCIUM_COMPUTATION_SEED = \"ComputationAccount\";\n\n/**\n * Seed prefix for computation definition account PDAs.\n *\n * @remarks\n * Computation definitions describe the circuit/program to be executed.\n */\nexport const ARCIUM_COMP_DEF_SEED = \"ComputationDefinitionAccount\";\n\n/**\n * Seed prefix for cluster account PDAs.\n *\n * @remarks\n * Clusters are groups of MXE nodes that process computations together.\n */\nexport const ARCIUM_CLUSTER_SEED = \"Cluster\";\n\n/**\n * Buffer size for cluster/computation offsets in bytes.\n *\n * @remarks\n * Offsets are encoded as 4-byte little-endian unsigned integers.\n */\nexport const ARCIUM_OFFSET_BUFFER_SIZE = 4;\n"]}

package/dist/chunk-UOFYS6M3.js

@@ -0,0 +1,219 @@
+import { UmbraError } from './chunk-4TZVXB5G.js';
+import { assertBytes, U8_BYTE_LENGTH, U16_BYTE_LENGTH, U32_BYTE_LENGTH, U64_BYTE_LENGTH, U128_BYTE_LENGTH, U256_BYTE_LENGTH, U512_BYTE_LENGTH, U1024_BYTE_LENGTH, assertX25519Bytes, assertX25519PublicKey, assertX25519PrivateKey, assertSharedSecret } from './chunk-CFTW5WNG.js';
+import { __name } from './chunk-7QVYU63E.js';
+
+// src/common/converters/errors.ts
+var ConversionError = class extends UmbraError {
+  static {
+    __name(this, "ConversionError");
+  }
+  /** The original value that failed conversion. */
+  sourceValue;
+  /** The type name of the source value (e.g., `"bigint"`, `"number"`). */
+  sourceType;
+  /** The target branded type name (e.g., `"U8"`, `"Bn254FieldElement"`). */
+  targetType;
+  /**
+   * Human-readable explanation of why the conversion failed.
+   *
+   * @remarks
+   * Examples:
+   * - `"Value 300 exceeds U8 maximum of 255"`
+   * - `"Value exceeds BN254 field prime"`
+   * - `"Cannot convert negative value -1 to unsigned type"`
+   */
+  reason;
+  /**
+   * @param message - A human-readable summary of the failure.
+   * @param options - Structured metadata about the failed conversion.
+   */
+  constructor(message, options) {
+    super(message, {
+      code: `CONVERSION_${options.targetType.toUpperCase()}`
+    });
+    this.name = "ConversionError";
+    this.sourceValue = options.sourceValue;
+    this.sourceType = options.sourceType;
+    this.targetType = options.targetType;
+    this.reason = options.reason;
+  }
+};
+function isConversionError(error) {
+  return error instanceof ConversionError;
+}
+__name(isConversionError, "isConversionError");
+function assertBigintInRange(value, min, max, sourceType, targetType) {
+  if (value < min || value > max) {
+    throw new ConversionError(
+      `${sourceType} value ${String(value)} is out of range for ${targetType} [${String(min)}, ${String(max)}]`,
+      {
+        sourceValue: value,
+        sourceType,
+        targetType,
+        reason: `Value must be in range [${String(min)}, ${String(max)}]`
+      }
+    );
+  }
+}
+__name(assertBigintInRange, "assertBigintInRange");
+function assertNumberInRange(value, min, max, targetType) {
+  if (!Number.isSafeInteger(value)) {
+    throw new ConversionError(
+      `Value ${String(value)} is not a safe integer`,
+      {
+        sourceValue: value,
+        sourceType: "number",
+        targetType,
+        reason: "Value must be a safe integer (Number.isSafeInteger)"
+      }
+    );
+  }
+  if (value < min || value > max) {
+    throw new ConversionError(
+      `number value ${String(value)} is out of range for ${targetType} [${String(min)}, ${String(max)}]`,
+      {
+        sourceValue: value,
+        sourceType: "number",
+        targetType,
+        reason: `Value must be in range [${String(min)}, ${String(max)}]`
+      }
+    );
+  }
+}
+__name(assertNumberInRange, "assertNumberInRange");
+function assertByteLength(value, expectedLength, targetType) {
+  if (!(value instanceof Uint8Array)) {
+    throw new ConversionError(
+      `Expected Uint8Array, got ${typeof value}`,
+      {
+        sourceValue: value,
+        sourceType: typeof value,
+        targetType,
+        reason: "Input must be a Uint8Array"
+      }
+    );
+  }
+  if (value.length !== expectedLength) {
+    throw new ConversionError(
+      `Expected exactly ${String(expectedLength)} bytes, got ${String(value.length)}`,
+      {
+        sourceValue: value,
+        sourceType: "Uint8Array",
+        targetType,
+        reason: `Length must be exactly ${String(expectedLength)} bytes`
+      }
+    );
+  }
+}
+__name(assertByteLength, "assertByteLength");
+
+// src/common/converters/branded.ts
+function createBytes(value) {
+  assertBytes(value);
+  return value;
+}
+__name(createBytes, "createBytes");
+function createU8LeBytes(value) {
+  assertByteLength(value, U8_BYTE_LENGTH, "U8LeBytes");
+  return value;
+}
+__name(createU8LeBytes, "createU8LeBytes");
+function createU16LeBytes(value) {
+  assertByteLength(value, U16_BYTE_LENGTH, "U16LeBytes");
+  return value;
+}
+__name(createU16LeBytes, "createU16LeBytes");
+function createU32LeBytes(value) {
+  assertByteLength(value, U32_BYTE_LENGTH, "U32LeBytes");
+  return value;
+}
+__name(createU32LeBytes, "createU32LeBytes");
+function createU64LeBytes(value) {
+  assertByteLength(value, U64_BYTE_LENGTH, "U64LeBytes");
+  return value;
+}
+__name(createU64LeBytes, "createU64LeBytes");
+function createU128LeBytes(value) {
+  assertByteLength(value, U128_BYTE_LENGTH, "U128LeBytes");
+  return value;
+}
+__name(createU128LeBytes, "createU128LeBytes");
+function createU256LeBytes(value) {
+  assertByteLength(value, U256_BYTE_LENGTH, "U256LeBytes");
+  return value;
+}
+__name(createU256LeBytes, "createU256LeBytes");
+function createU512LeBytes(value) {
+  assertByteLength(value, U512_BYTE_LENGTH, "U512LeBytes");
+  return value;
+}
+__name(createU512LeBytes, "createU512LeBytes");
+function createU1024LeBytes(value) {
+  assertByteLength(value, U1024_BYTE_LENGTH, "U1024LeBytes");
+  return value;
+}
+__name(createU1024LeBytes, "createU1024LeBytes");
+function createU8BeBytes(value) {
+  assertByteLength(value, U8_BYTE_LENGTH, "U8BeBytes");
+  return value;
+}
+__name(createU8BeBytes, "createU8BeBytes");
+function createU16BeBytes(value) {
+  assertByteLength(value, U16_BYTE_LENGTH, "U16BeBytes");
+  return value;
+}
+__name(createU16BeBytes, "createU16BeBytes");
+function createU32BeBytes(value) {
+  assertByteLength(value, U32_BYTE_LENGTH, "U32BeBytes");
+  return value;
+}
+__name(createU32BeBytes, "createU32BeBytes");
+function createU64BeBytes(value) {
+  assertByteLength(value, U64_BYTE_LENGTH, "U64BeBytes");
+  return value;
+}
+__name(createU64BeBytes, "createU64BeBytes");
+function createU128BeBytes(value) {
+  assertByteLength(value, U128_BYTE_LENGTH, "U128BeBytes");
+  return value;
+}
+__name(createU128BeBytes, "createU128BeBytes");
+function createU256BeBytes(value) {
+  assertByteLength(value, U256_BYTE_LENGTH, "U256BeBytes");
+  return value;
+}
+__name(createU256BeBytes, "createU256BeBytes");
+function createU512BeBytes(value) {
+  assertByteLength(value, U512_BYTE_LENGTH, "U512BeBytes");
+  return value;
+}
+__name(createU512BeBytes, "createU512BeBytes");
+function createU1024BeBytes(value) {
+  assertByteLength(value, U1024_BYTE_LENGTH, "U1024BeBytes");
+  return value;
+}
+__name(createU1024BeBytes, "createU1024BeBytes");
+function createX25519Bytes(value) {
+  assertX25519Bytes(value);
+  return value;
+}
+__name(createX25519Bytes, "createX25519Bytes");
+function createX25519PublicKey(value) {
+  assertX25519PublicKey(value);
+  return value;
+}
+__name(createX25519PublicKey, "createX25519PublicKey");
+function createX25519PrivateKey(value) {
+  assertX25519PrivateKey(value);
+  return value;
+}
+__name(createX25519PrivateKey, "createX25519PrivateKey");
+function createSharedSecret(value) {
+  assertSharedSecret(value);
+  return value;
+}
+__name(createSharedSecret, "createSharedSecret");
+
+export { ConversionError, assertBigintInRange, assertByteLength, assertNumberInRange, createBytes, createSharedSecret, createU1024BeBytes, createU1024LeBytes, createU128BeBytes, createU128LeBytes, createU16BeBytes, createU16LeBytes, createU256BeBytes, createU256LeBytes, createU32BeBytes, createU32LeBytes, createU512BeBytes, createU512LeBytes, createU64BeBytes, createU64LeBytes, createU8BeBytes, createU8LeBytes, createX25519Bytes, createX25519PrivateKey, createX25519PublicKey, isConversionError };
+//# sourceMappingURL=chunk-UOFYS6M3.js.map
+//# sourceMappingURL=chunk-UOFYS6M3.js.map

package/dist/chunk-UOFYS6M3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/converters/errors.ts","../src/common/converters/branded.ts"],"names":[],"mappings":"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","file":"chunk-UOFYS6M3.js","sourcesContent":["/**\n * Converter Error Classes\n *\n * Provides the {@link ConversionError} class thrown by all `convert*`, `create*`,\n * `encode*`, and `decode*` functions when a type transformation fails, along with\n * shared validation helpers used across all converter modules.\n *\n * @module common/converters/errors\n * @since 2.0.0\n */\n\nimport { UmbraError } from \"../errors\";\n\n/* =============================================================================\n * CONVERSION ERROR\n * ============================================================================= */\n\n/**\n * Error thrown when a type conversion fails.\n *\n * @remarks\n * Provides structured metadata about the failure: which value was being converted,\n * from which type, to which target type, and why it failed.\n *\n * ## When is this thrown?\n *\n * - **Narrowing conversions** (`convertU128ToU8`, etc.) — value exceeds target range.\n * - **Sign conversions** (`convertI64ToU64`, etc.) — negative to unsigned, or overflow.\n * - **Field element conversions** (`convertU256ToBn254FieldElement`, etc.) — value >= field prime.\n * - **Byte array constructors** (`createU128LeBytes`, etc.) — wrong length.\n * - **Number conversions** (`convertU64ToNumber`, etc.) — value exceeds `Number.MAX_SAFE_INTEGER`.\n *\n * @example\n * ```typescript\n * try {\n *   const narrow = convertU128ToU8(createU128(300n));\n * } catch (error) {\n *   if (error instanceof ConversionError) {\n *     console.error(`Cannot convert ${error.sourceType} to ${error.targetType}`);\n *     console.error(`Reason: ${error.reason}`);\n *   }\n * }\n * ```\n *\n * @since 2.0.0\n * @public\n */\nexport class ConversionError extends UmbraError {\n  /** The original value that failed conversion. */\n  public readonly sourceValue: unknown;\n\n  /** The type name of the source value (e.g., `\"bigint\"`, `\"number\"`). */\n  public readonly sourceType: string;\n\n  /** The target branded type name (e.g., `\"U8\"`, `\"Bn254FieldElement\"`). */\n  public readonly targetType: string;\n\n  /**\n   * Human-readable explanation of why the conversion failed.\n   *\n   * @remarks\n   * Examples:\n   * - `\"Value 300 exceeds U8 maximum of 255\"`\n   * - `\"Value exceeds BN254 field prime\"`\n   * - `\"Cannot convert negative value -1 to unsigned type\"`\n   */\n  public readonly reason: string;\n\n  /**\n   * @param message - A human-readable summary of the failure.\n   * @param options - Structured metadata about the failed conversion.\n   */\n  constructor(\n    message: string,\n    options: {\n      sourceValue: unknown;\n      sourceType: string;\n      targetType: string;\n      reason: string;\n    },\n  ) {\n    super(message, {\n      code: `CONVERSION_${options.targetType.toUpperCase()}`,\n    });\n    this.name = \"ConversionError\";\n    this.sourceValue = options.sourceValue;\n    this.sourceType = options.sourceType;\n    this.targetType = options.targetType;\n    this.reason = options.reason;\n  }\n}\n\n/**\n * Type guard to check if a value is a {@link ConversionError}.\n *\n * @param error - The value to test.\n * @returns `true` and narrows `error` to {@link ConversionError}.\n *\n * @since 2.0.0\n * @public\n */\nexport function isConversionError(error: unknown): error is ConversionError {\n  return error instanceof ConversionError;\n}\n\n/* =============================================================================\n * SHARED VALIDATION HELPERS\n * ============================================================================= */\n\n/**\n * Asserts that a bigint value is within the range `[min, max]` (inclusive).\n * Throws {@link ConversionError} if out of range.\n *\n * @param value - The value to check.\n * @param min - Minimum allowed value (inclusive).\n * @param max - Maximum allowed value (inclusive).\n * @param sourceType - Source type name for the error message.\n * @param targetType - Target type name for the error message.\n *\n * @throws {ConversionError} If value is outside the range.\n *\n * @internal\n */\nexport function assertBigintInRange(\n  value: bigint,\n  min: bigint,\n  max: bigint,\n  sourceType: string,\n  targetType: string,\n): void {\n  if (value < min || value > max) {\n    throw new ConversionError(\n      `${sourceType} value ${String(value)} is out of range for ${targetType} [${String(min)}, ${String(max)}]`,\n      {\n        sourceValue: value,\n        sourceType,\n        targetType,\n        reason: `Value must be in range [${String(min)}, ${String(max)}]`,\n      },\n    );\n  }\n}\n\n/**\n * Asserts that a number value is a safe integer within the range `[min, max]`.\n * Throws {@link ConversionError} if not a safe integer or out of range.\n *\n * @param value - The value to check.\n * @param min - Minimum allowed value (inclusive).\n * @param max - Maximum allowed value (inclusive).\n * @param targetType - Target type name for the error message.\n *\n * @throws {ConversionError} If value is not a safe integer or outside the range.\n *\n * @internal\n */\nexport function assertNumberInRange(\n  value: number,\n  min: number,\n  max: number,\n  targetType: string,\n): void {\n  if (!Number.isSafeInteger(value)) {\n    throw new ConversionError(\n      `Value ${String(value)} is not a safe integer`,\n      {\n        sourceValue: value,\n        sourceType: \"number\",\n        targetType,\n        reason: \"Value must be a safe integer (Number.isSafeInteger)\",\n      },\n    );\n  }\n  if (value < min || value > max) {\n    throw new ConversionError(\n      `number value ${String(value)} is out of range for ${targetType} [${String(min)}, ${String(max)}]`,\n      {\n        sourceValue: value,\n        sourceType: \"number\",\n        targetType,\n        reason: `Value must be in range [${String(min)}, ${String(max)}]`,\n      },\n    );\n  }\n}\n\n/**\n * Asserts that a Uint8Array has exactly the expected length.\n * Throws {@link ConversionError} if the length doesn't match.\n *\n * @param value - The byte array to check.\n * @param expectedLength - The required byte length.\n * @param targetType - Target type name for the error message.\n *\n * @throws {ConversionError} If value is not a Uint8Array or has wrong length.\n *\n * @internal\n */\nexport function assertByteLength(\n  value: Uint8Array,\n  expectedLength: number,\n  targetType: string,\n): void {\n  if (!(value instanceof Uint8Array)) {\n    throw new ConversionError(\n      `Expected Uint8Array, got ${typeof value}`,\n      {\n        sourceValue: value,\n        sourceType: typeof value,\n        targetType,\n        reason: \"Input must be a Uint8Array\",\n      },\n    );\n  }\n  if (value.length !== expectedLength) {\n    throw new ConversionError(\n      `Expected exactly ${String(expectedLength)} bytes, got ${String(value.length)}`,\n      {\n        sourceValue: value,\n        sourceType: \"Uint8Array\",\n        targetType,\n        reason: `Length must be exactly ${String(expectedLength)} bytes`,\n      },\n    );\n  }\n}\n","/**\n * Branded Type Constructors\n *\n * Provides `create*` factory functions that wrap raw `Uint8Array` values into\n * their corresponding branded byte-array types after validating length constraints.\n *\n * For constructing branded types from raw `bigint` values, use the `assert*`\n * helpers exported from `common/types` or the `encode*` functions from\n * `byte-encoding`.\n *\n * @packageDocumentation\n * @module common/converters/branded\n * @since 2.0.0\n */\n\nimport {\n  type Bytes,\n  type U8LeBytes,\n  type U8BeBytes,\n  type U16LeBytes,\n  type U16BeBytes,\n  type U32LeBytes,\n  type U32BeBytes,\n  type U64LeBytes,\n  type U64BeBytes,\n  type U128LeBytes,\n  type U128BeBytes,\n  type U256LeBytes,\n  type U256BeBytes,\n  type U512LeBytes,\n  type U512BeBytes,\n  type U1024LeBytes,\n  type U1024BeBytes,\n  assertBytes,\n  U8_BYTE_LENGTH,\n  U16_BYTE_LENGTH,\n  U32_BYTE_LENGTH,\n  U64_BYTE_LENGTH,\n  U128_BYTE_LENGTH,\n  U256_BYTE_LENGTH,\n  U512_BYTE_LENGTH,\n  U1024_BYTE_LENGTH,\n} from \"../types\";\n\nimport {\n  type X25519PublicKey,\n  type X25519PrivateKey,\n  type X25519Bytes,\n  type SharedSecret,\n  assertX25519PublicKey,\n  assertX25519PrivateKey,\n  assertX25519Bytes,\n  assertSharedSecret,\n} from \"../../types/cryptography\";\n\nimport { assertByteLength } from \"./errors\";\n\n/* =============================================================================\n * GENERIC BYTE ARRAY CONSTRUCTOR\n * ============================================================================= */\n\n/**\n * Wraps a `Uint8Array` in the {@link Bytes} branded type.\n *\n * @param value - The raw `Uint8Array` to validate and brand.\n * @returns The same `Uint8Array`, branded as {@link Bytes}.\n * @throws {ConversionError} If `value` is not a `Uint8Array`.\n *\n * @since 2.0.0\n * @public\n */\nexport function createBytes(value: Uint8Array): Bytes {\n  assertBytes(value);\n  return value;\n}\n\n/* =============================================================================\n * LITTLE-ENDIAN BYTE ARRAY CONSTRUCTORS\n * ============================================================================= */\n\n/**\n * Wraps a 1-byte `Uint8Array` in the {@link U8LeBytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 1 byte.\n * @returns The same `Uint8Array`, branded as {@link U8LeBytes}.\n * @throws {ConversionError} If not exactly 1 byte.\n *\n * @since 2.0.0\n * @public\n */\nexport function createU8LeBytes(value: Uint8Array): U8LeBytes {\n  assertByteLength(value, U8_BYTE_LENGTH, \"U8LeBytes\");\n  return value as U8LeBytes;\n}\n\n/**\n * Wraps a 2-byte `Uint8Array` in the {@link U16LeBytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 2 bytes in little-endian order.\n * @returns The same `Uint8Array`, branded as {@link U16LeBytes}.\n * @throws {ConversionError} If not exactly 2 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createU16LeBytes(value: Uint8Array): U16LeBytes {\n  assertByteLength(value, U16_BYTE_LENGTH, \"U16LeBytes\");\n  return value as U16LeBytes;\n}\n\n/**\n * Wraps a 4-byte `Uint8Array` in the {@link U32LeBytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 4 bytes in little-endian order.\n * @returns The same `Uint8Array`, branded as {@link U32LeBytes}.\n * @throws {ConversionError} If not exactly 4 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createU32LeBytes(value: Uint8Array): U32LeBytes {\n  assertByteLength(value, U32_BYTE_LENGTH, \"U32LeBytes\");\n  return value as U32LeBytes;\n}\n\n/**\n * Wraps an 8-byte `Uint8Array` in the {@link U64LeBytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 8 bytes in little-endian order.\n * @returns The same `Uint8Array`, branded as {@link U64LeBytes}.\n * @throws {ConversionError} If not exactly 8 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createU64LeBytes(value: Uint8Array): U64LeBytes {\n  assertByteLength(value, U64_BYTE_LENGTH, \"U64LeBytes\");\n  return value as U64LeBytes;\n}\n\n/**\n * Wraps a 16-byte `Uint8Array` in the {@link U128LeBytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 16 bytes in little-endian order.\n * @returns The same `Uint8Array`, branded as {@link U128LeBytes}.\n * @throws {ConversionError} If not exactly 16 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createU128LeBytes(value: Uint8Array): U128LeBytes {\n  assertByteLength(value, U128_BYTE_LENGTH, \"U128LeBytes\");\n  return value as U128LeBytes;\n}\n\n/**\n * Wraps a 32-byte `Uint8Array` in the {@link U256LeBytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 32 bytes in little-endian order.\n * @returns The same `Uint8Array`, branded as {@link U256LeBytes}.\n * @throws {ConversionError} If not exactly 32 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createU256LeBytes(value: Uint8Array): U256LeBytes {\n  assertByteLength(value, U256_BYTE_LENGTH, \"U256LeBytes\");\n  return value as U256LeBytes;\n}\n\n/**\n * Wraps a 64-byte `Uint8Array` in the {@link U512LeBytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 64 bytes in little-endian order.\n * @returns The same `Uint8Array`, branded as {@link U512LeBytes}.\n * @throws {ConversionError} If not exactly 64 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createU512LeBytes(value: Uint8Array): U512LeBytes {\n  assertByteLength(value, U512_BYTE_LENGTH, \"U512LeBytes\");\n  return value as U512LeBytes;\n}\n\n/**\n * Wraps a 128-byte `Uint8Array` in the {@link U1024LeBytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 128 bytes in little-endian order.\n * @returns The same `Uint8Array`, branded as {@link U1024LeBytes}.\n * @throws {ConversionError} If not exactly 128 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createU1024LeBytes(value: Uint8Array): U1024LeBytes {\n  assertByteLength(value, U1024_BYTE_LENGTH, \"U1024LeBytes\");\n  return value as U1024LeBytes;\n}\n\n/* =============================================================================\n * BIG-ENDIAN BYTE ARRAY CONSTRUCTORS\n * ============================================================================= */\n\n/**\n * Wraps a 1-byte `Uint8Array` in the {@link U8BeBytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 1 byte.\n * @returns The same `Uint8Array`, branded as {@link U8BeBytes}.\n * @throws {ConversionError} If not exactly 1 byte.\n *\n * @since 2.0.0\n * @public\n */\nexport function createU8BeBytes(value: Uint8Array): U8BeBytes {\n  assertByteLength(value, U8_BYTE_LENGTH, \"U8BeBytes\");\n  return value as U8BeBytes;\n}\n\n/**\n * Wraps a 2-byte `Uint8Array` in the {@link U16BeBytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 2 bytes in big-endian order.\n * @returns The same `Uint8Array`, branded as {@link U16BeBytes}.\n * @throws {ConversionError} If not exactly 2 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createU16BeBytes(value: Uint8Array): U16BeBytes {\n  assertByteLength(value, U16_BYTE_LENGTH, \"U16BeBytes\");\n  return value as U16BeBytes;\n}\n\n/**\n * Wraps a 4-byte `Uint8Array` in the {@link U32BeBytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 4 bytes in big-endian order.\n * @returns The same `Uint8Array`, branded as {@link U32BeBytes}.\n * @throws {ConversionError} If not exactly 4 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createU32BeBytes(value: Uint8Array): U32BeBytes {\n  assertByteLength(value, U32_BYTE_LENGTH, \"U32BeBytes\");\n  return value as U32BeBytes;\n}\n\n/**\n * Wraps an 8-byte `Uint8Array` in the {@link U64BeBytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 8 bytes in big-endian order.\n * @returns The same `Uint8Array`, branded as {@link U64BeBytes}.\n * @throws {ConversionError} If not exactly 8 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createU64BeBytes(value: Uint8Array): U64BeBytes {\n  assertByteLength(value, U64_BYTE_LENGTH, \"U64BeBytes\");\n  return value as U64BeBytes;\n}\n\n/**\n * Wraps a 16-byte `Uint8Array` in the {@link U128BeBytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 16 bytes in big-endian order.\n * @returns The same `Uint8Array`, branded as {@link U128BeBytes}.\n * @throws {ConversionError} If not exactly 16 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createU128BeBytes(value: Uint8Array): U128BeBytes {\n  assertByteLength(value, U128_BYTE_LENGTH, \"U128BeBytes\");\n  return value as U128BeBytes;\n}\n\n/**\n * Wraps a 32-byte `Uint8Array` in the {@link U256BeBytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 32 bytes in big-endian order.\n * @returns The same `Uint8Array`, branded as {@link U256BeBytes}.\n * @throws {ConversionError} If not exactly 32 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createU256BeBytes(value: Uint8Array): U256BeBytes {\n  assertByteLength(value, U256_BYTE_LENGTH, \"U256BeBytes\");\n  return value as U256BeBytes;\n}\n\n/**\n * Wraps a 64-byte `Uint8Array` in the {@link U512BeBytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 64 bytes in big-endian order.\n * @returns The same `Uint8Array`, branded as {@link U512BeBytes}.\n * @throws {ConversionError} If not exactly 64 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createU512BeBytes(value: Uint8Array): U512BeBytes {\n  assertByteLength(value, U512_BYTE_LENGTH, \"U512BeBytes\");\n  return value as U512BeBytes;\n}\n\n/**\n * Wraps a 128-byte `Uint8Array` in the {@link U1024BeBytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 128 bytes in big-endian order.\n * @returns The same `Uint8Array`, branded as {@link U1024BeBytes}.\n * @throws {ConversionError} If not exactly 128 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createU1024BeBytes(value: Uint8Array): U1024BeBytes {\n  assertByteLength(value, U1024_BYTE_LENGTH, \"U1024BeBytes\");\n  return value as U1024BeBytes;\n}\n\n/* =============================================================================\n * CRYPTOGRAPHIC BYTE ARRAY CONSTRUCTORS\n * ============================================================================= */\n\n/**\n * Wraps a 32-byte `Uint8Array` in the {@link X25519Bytes} branded type.\n *\n * @param value - A `Uint8Array` of exactly 32 bytes.\n * @returns The same `Uint8Array`, branded as {@link X25519Bytes}.\n * @throws {CryptographyAssertionError} If not exactly 32 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createX25519Bytes(value: Uint8Array): X25519Bytes {\n  assertX25519Bytes(value);\n  return value;\n}\n\n/**\n * Wraps a 32-byte `Uint8Array` in the {@link X25519PublicKey} branded type.\n *\n * @param value - A `Uint8Array` of exactly 32 bytes representing an X25519 public key.\n * @returns The same `Uint8Array`, branded as {@link X25519PublicKey}.\n * @throws {CryptographyAssertionError} If not exactly 32 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createX25519PublicKey(value: Uint8Array): X25519PublicKey {\n  assertX25519PublicKey(value);\n  return value;\n}\n\n/**\n * Wraps a 32-byte `Uint8Array` in the {@link X25519PrivateKey} branded type.\n *\n * @remarks\n * **Security:** The caller is responsible for ensuring this value is treated as\n * secret material. Do not log, serialize, or transmit private keys.\n *\n * @param value - A `Uint8Array` of exactly 32 bytes representing an X25519 private key.\n * @returns The same `Uint8Array`, branded as {@link X25519PrivateKey}.\n * @throws {CryptographyAssertionError} If not exactly 32 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createX25519PrivateKey(value: Uint8Array): X25519PrivateKey {\n  assertX25519PrivateKey(value);\n  return value;\n}\n\n/**\n * Wraps a 32-byte `Uint8Array` in the {@link SharedSecret} branded type.\n *\n * @remarks\n * **Security:** Shared secrets are key material derived from ECDH.\n * Do not log or transmit.\n *\n * @param value - A `Uint8Array` of exactly 32 bytes.\n * @returns The same `Uint8Array`, branded as {@link SharedSecret}.\n * @throws {CryptographyAssertionError} If not exactly 32 bytes.\n *\n * @since 2.0.0\n * @public\n */\nexport function createSharedSecret(value: Uint8Array): SharedSecret {\n  assertSharedSecret(value);\n  return value;\n}\n\n// NOTE: createOptionalData32 is in common/type-helpers.ts (not duplicated here)\n"]}