@umbra-privacy/sdk 1.0.0

package/dist/chunk-GXKSUB2U.cjs

@@ -0,0 +1,4416 @@
+'use strict';
+
+var chunkMVKTV3FT_cjs = require('./chunk-MVKTV3FT.cjs');
+var chunkMDFSBU5W_cjs = require('./chunk-MDFSBU5W.cjs');
+var chunkPK6SKIKE_cjs = require('./chunk-PK6SKIKE.cjs');
+var kit = require('@solana/kit');
+var codama = require('@umbra-privacy/codama');
+var sha2_js = require('@noble/hashes/sha2.js');
+
+// src/common/converters/branded.ts
+var ConversionError = class _ConversionError extends Error {
+  static {
+    chunkPK6SKIKE_cjs.__name(this, "ConversionError");
+  }
+  /**
+   * The original value that failed conversion.
+   * @public
+   */
+  sourceValue;
+  /**
+   * The type name of the source value (e.g., "number", "string", "Uint8Array").
+   * @public
+   */
+  sourceType;
+  /**
+   * The target branded type name (e.g., "U8", "U256LeBytes", "Bn254FieldElement").
+   * @public
+   */
+  targetType;
+  /**
+   * Human-readable explanation of why the conversion failed.
+   * @public
+   */
+  reason;
+  /**
+   * Creates a new ConversionError with structured metadata.
+   *
+   * @param message - A human-readable error message summarising the failure
+   * @param options - Structured details about the failed conversion
+   * @param options.sourceValue - The original value that could not be converted
+   * @param options.sourceType - The type name of the source value
+   * @param options.targetType - The branded type name that was the conversion target
+   * @param options.reason - A concise description of why the conversion was rejected
+   * @public
+   */
+  constructor(message, options) {
+    super(message);
+    this.name = "ConversionError";
+    this.sourceValue = options.sourceValue;
+    this.sourceType = options.sourceType;
+    this.targetType = options.targetType;
+    this.reason = options.reason;
+    Error.captureStackTrace(this, _ConversionError);
+    Object.setPrototypeOf(this, _ConversionError.prototype);
+  }
+};
+function getTypeName(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (value instanceof Uint8Array) {
+    return "Uint8Array";
+  }
+  if (value instanceof ArrayBuffer) {
+    return "ArrayBuffer";
+  }
+  if (value instanceof DataView) {
+    return "DataView";
+  }
+  if (Array.isArray(value)) {
+    return "Array";
+  }
+  return typeof value;
+}
+chunkPK6SKIKE_cjs.__name(getTypeName, "getTypeName");
+function parseStringToBigInt(value, targetType) {
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    throw new ConversionError(`Cannot convert empty string to ${targetType}`, {
+      sourceValue: value,
+      sourceType: "string",
+      targetType,
+      reason: "Empty string is not a valid number"
+    });
+  }
+  try {
+    if (trimmed.toLowerCase().startsWith("0x")) {
+      return BigInt(trimmed);
+    }
+    if (trimmed.toLowerCase().startsWith("0b")) {
+      return BigInt(trimmed);
+    }
+    if (trimmed.toLowerCase().startsWith("0o")) {
+      return BigInt(trimmed);
+    }
+    if (/^[0-9a-fA-F]+$/.test(trimmed) && /[a-fA-F]/.test(trimmed)) {
+      return BigInt(`0x${trimmed}`);
+    }
+    return BigInt(trimmed);
+  } catch {
+    throw new ConversionError(`Cannot parse string "${value}" to ${targetType}`, {
+      sourceValue: value,
+      sourceType: "string",
+      targetType,
+      reason: "Invalid number format"
+    });
+  }
+}
+chunkPK6SKIKE_cjs.__name(parseStringToBigInt, "parseStringToBigInt");
+function toBigIntValue(value, targetType) {
+  if (typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new ConversionError(`Cannot convert ${String(value)} to ${targetType}`, {
+        sourceValue: value,
+        sourceType: "number",
+        targetType,
+        reason: "Value must be a finite number"
+      });
+    }
+    if (!Number.isInteger(value)) {
+      throw new ConversionError(`Cannot convert ${String(value)} to ${targetType}`, {
+        sourceValue: value,
+        sourceType: "number",
+        targetType,
+        reason: "Value must be an integer"
+      });
+    }
+    return BigInt(value);
+  }
+  if (typeof value === "string") {
+    return parseStringToBigInt(value, targetType);
+  }
+  if (value instanceof Uint8Array) {
+    return bytesToBigInt(value);
+  }
+  if (value instanceof ArrayBuffer) {
+    return bytesToBigInt(new Uint8Array(value));
+  }
+  if (value instanceof DataView) {
+    return bytesToBigInt(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+  }
+  throw new ConversionError(`Cannot convert ${getTypeName(value)} to ${targetType}`, {
+    sourceValue: value,
+    sourceType: getTypeName(value),
+    targetType,
+    reason: "Unsupported input type"
+  });
+}
+chunkPK6SKIKE_cjs.__name(toBigIntValue, "toBigIntValue");
+function bytesToBigInt(bytes) {
+  let result = 0n;
+  for (const byte of bytes) {
+    result = result << 8n | BigInt(byte);
+  }
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(bytesToBigInt, "bytesToBigInt");
+function toByteArrayValue(value, targetLength, targetType) {
+  let bytes;
+  if (value instanceof Uint8Array) {
+    bytes = value;
+  } else if (value instanceof ArrayBuffer) {
+    bytes = new Uint8Array(value);
+  } else if (value instanceof DataView) {
+    bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  } else if (typeof value === "string") {
+    bytes = hexStringToBytes(value, targetType);
+  } else if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index++) {
+      const element = value[index];
+      if (typeof element !== "number" || element < 0 || element > 255 || !Number.isInteger(element)) {
+        throw new ConversionError(`Invalid byte value at index ${String(index)}`, {
+          sourceValue: value,
+          sourceType: "Array",
+          targetType,
+          reason: `Array element at index ${String(index)} must be an integer between 0 and 255`
+        });
+      }
+    }
+    bytes = new Uint8Array(value);
+  } else if (typeof value === "bigint") {
+    bytes = bigIntToBytes(value, targetLength ?? 0, targetType);
+  } else {
+    throw new ConversionError(`Cannot convert ${getTypeName(value)} to ${targetType}`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType,
+      reason: "Unsupported input type"
+    });
+  }
+  if (targetLength !== null) {
+    if (bytes.length > targetLength) {
+      throw new ConversionError(
+        `Byte array too large for ${targetType}: ${String(bytes.length)} > ${String(targetLength)}`,
+        {
+          sourceValue: value,
+          sourceType: getTypeName(value),
+          targetType,
+          reason: `Maximum length is ${String(targetLength)} bytes`
+        }
+      );
+    }
+    if (bytes.length < targetLength) {
+      const padded = new Uint8Array(targetLength);
+      padded.set(bytes, 0);
+      bytes = padded;
+    }
+  }
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(toByteArrayValue, "toByteArrayValue");
+function hexStringToBytes(value, targetType) {
+  let hex = value.trim();
+  if (hex.toLowerCase().startsWith("0x")) {
+    hex = hex.slice(2);
+  }
+  if (!/^[0-9a-fA-F]*$/.test(hex)) {
+    throw new ConversionError(`Invalid hex string: "${value}"`, {
+      sourceValue: value,
+      sourceType: "string",
+      targetType,
+      reason: "String contains non-hexadecimal characters"
+    });
+  }
+  if (hex === "") {
+    return new Uint8Array(0);
+  }
+  if (hex.length % 2 !== 0) {
+    hex = `0${hex}`;
+  }
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let index = 0; index < bytes.length; index++) {
+    bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+  }
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(hexStringToBytes, "hexStringToBytes");
+function bigIntToBytes(value, minLength, targetType) {
+  if (value < 0n) {
+    throw new ConversionError(`Cannot convert negative bigint to ${targetType}`, {
+      sourceValue: value,
+      sourceType: "bigint",
+      targetType,
+      reason: "Byte arrays cannot represent negative values directly"
+    });
+  }
+  if (value === 0n) {
+    return new Uint8Array(minLength);
+  }
+  const hex = value.toString(16);
+  const byteLength = Math.ceil(hex.length / 2);
+  const bytes = new Uint8Array(Math.max(byteLength, minLength));
+  let temporary = value;
+  for (let index = bytes.length - 1; index >= 0 && temporary > 0n; index--) {
+    bytes[index] = Number(temporary & 0xffn);
+    temporary >>= 8n;
+  }
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(bigIntToBytes, "bigIntToBytes");
+function createLeBytes(value) {
+  const bytes = toByteArrayValue(value, null, "LeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createLeBytes, "createLeBytes");
+function createBeBytes(value) {
+  const bytes = toByteArrayValue(value, null, "BeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createBeBytes, "createBeBytes");
+function createU8LeBytes(value) {
+  const bytes = toByteArrayValue(value, chunkMDFSBU5W_cjs.U8_BYTE_LENGTH, "U8LeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createU8LeBytes, "createU8LeBytes");
+function createU16LeBytes(value) {
+  const bytes = toByteArrayValue(value, chunkMDFSBU5W_cjs.U16_BYTE_LENGTH, "U16LeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createU16LeBytes, "createU16LeBytes");
+function createU32LeBytes(value) {
+  const bytes = toByteArrayValue(value, chunkMDFSBU5W_cjs.U32_BYTE_LENGTH, "U32LeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createU32LeBytes, "createU32LeBytes");
+function createU64LeBytes(value) {
+  const bytes = toByteArrayValue(value, chunkMDFSBU5W_cjs.U64_BYTE_LENGTH, "U64LeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createU64LeBytes, "createU64LeBytes");
+function createU128LeBytes(value) {
+  const bytes = toByteArrayValue(value, chunkMDFSBU5W_cjs.U128_BYTE_LENGTH, "U128LeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createU128LeBytes, "createU128LeBytes");
+function createU256LeBytes(value) {
+  const bytes = toByteArrayValue(value, chunkMDFSBU5W_cjs.U256_BYTE_LENGTH, "U256LeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createU256LeBytes, "createU256LeBytes");
+function createU512LeBytes(value) {
+  const bytes = toByteArrayValue(value, chunkMDFSBU5W_cjs.U512_BYTE_LENGTH, "U512LeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createU512LeBytes, "createU512LeBytes");
+function createU1024LeBytes(value) {
+  const bytes = toByteArrayValue(value, chunkMDFSBU5W_cjs.U1024_BYTE_LENGTH, "U1024LeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createU1024LeBytes, "createU1024LeBytes");
+function createU8BeBytes(value) {
+  const bytes = toByteArrayValue(value, chunkMDFSBU5W_cjs.U8_BYTE_LENGTH, "U8BeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createU8BeBytes, "createU8BeBytes");
+function createU16BeBytes(value) {
+  const bytes = toByteArrayValue(value, chunkMDFSBU5W_cjs.U16_BYTE_LENGTH, "U16BeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createU16BeBytes, "createU16BeBytes");
+function createU32BeBytes(value) {
+  const bytes = toByteArrayValue(value, chunkMDFSBU5W_cjs.U32_BYTE_LENGTH, "U32BeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createU32BeBytes, "createU32BeBytes");
+function createU64BeBytes(value) {
+  const bytes = toByteArrayValue(value, chunkMDFSBU5W_cjs.U64_BYTE_LENGTH, "U64BeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createU64BeBytes, "createU64BeBytes");
+function createU128BeBytes(value) {
+  const bytes = toByteArrayValue(value, chunkMDFSBU5W_cjs.U128_BYTE_LENGTH, "U128BeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createU128BeBytes, "createU128BeBytes");
+function createU256BeBytes(value) {
+  const bytes = toByteArrayValue(value, chunkMDFSBU5W_cjs.U256_BYTE_LENGTH, "U256BeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createU256BeBytes, "createU256BeBytes");
+function createU512BeBytes(value) {
+  const bytes = toByteArrayValue(value, chunkMDFSBU5W_cjs.U512_BYTE_LENGTH, "U512BeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createU512BeBytes, "createU512BeBytes");
+function createU1024BeBytes(value) {
+  const bytes = toByteArrayValue(value, chunkMDFSBU5W_cjs.U1024_BYTE_LENGTH, "U1024BeBytes");
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createU1024BeBytes, "createU1024BeBytes");
+function createUnsignedInteger(value) {
+  const bigIntValue = toBigIntValue(value, "UnsignedInteger");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Cannot convert negative value to UnsignedInteger`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "UnsignedInteger",
+      reason: "Unsigned integers must be non-negative"
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createUnsignedInteger, "createUnsignedInteger");
+function createSignedInteger(value) {
+  const bigIntValue = toBigIntValue(value, "SignedInteger");
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createSignedInteger, "createSignedInteger");
+function createU8(value) {
+  const bigIntValue = toBigIntValue(value, "U8");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value ${String(bigIntValue)} is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "U8",
+      reason: "U8 must be non-negative"
+    });
+  }
+  if (bigIntValue > chunkMDFSBU5W_cjs.U8_MAX) {
+    throw new ConversionError(
+      `Value ${String(bigIntValue)} exceeds U8 maximum (${String(chunkMDFSBU5W_cjs.U8_MAX)})`,
+      {
+        sourceValue: value,
+        sourceType: getTypeName(value),
+        targetType: "U8",
+        reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U8_MAX)}`
+      }
+    );
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createU8, "createU8");
+function createU16(value) {
+  const bigIntValue = toBigIntValue(value, "U16");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value ${String(bigIntValue)} is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "U16",
+      reason: "U16 must be non-negative"
+    });
+  }
+  if (bigIntValue > chunkMDFSBU5W_cjs.U16_MAX) {
+    throw new ConversionError(
+      `Value ${String(bigIntValue)} exceeds U16 maximum (${String(chunkMDFSBU5W_cjs.U16_MAX)})`,
+      {
+        sourceValue: value,
+        sourceType: getTypeName(value),
+        targetType: "U16",
+        reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U16_MAX)}`
+      }
+    );
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createU16, "createU16");
+function createU32(value) {
+  const bigIntValue = toBigIntValue(value, "U32");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value ${String(bigIntValue)} is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "U32",
+      reason: "U32 must be non-negative"
+    });
+  }
+  if (bigIntValue > chunkMDFSBU5W_cjs.U32_MAX) {
+    throw new ConversionError(
+      `Value ${String(bigIntValue)} exceeds U32 maximum (${String(chunkMDFSBU5W_cjs.U32_MAX)})`,
+      {
+        sourceValue: value,
+        sourceType: getTypeName(value),
+        targetType: "U32",
+        reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U32_MAX)}`
+      }
+    );
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createU32, "createU32");
+function createU64(value) {
+  const bigIntValue = toBigIntValue(value, "U64");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value ${String(bigIntValue)} is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "U64",
+      reason: "U64 must be non-negative"
+    });
+  }
+  if (bigIntValue > chunkMDFSBU5W_cjs.U64_MAX) {
+    throw new ConversionError(`Value exceeds U64 maximum`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "U64",
+      reason: "Value must be <= 2^64 - 1"
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createU64, "createU64");
+function createU128(value) {
+  const bigIntValue = toBigIntValue(value, "U128");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "U128",
+      reason: "U128 must be non-negative"
+    });
+  }
+  if (bigIntValue > chunkMDFSBU5W_cjs.U128_MAX) {
+    throw new ConversionError(`Value exceeds U128 maximum`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "U128",
+      reason: "Value must be <= 2^128 - 1"
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createU128, "createU128");
+function createU256(value) {
+  const bigIntValue = toBigIntValue(value, "U256");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "U256",
+      reason: "U256 must be non-negative"
+    });
+  }
+  if (bigIntValue > chunkMDFSBU5W_cjs.U256_MAX) {
+    throw new ConversionError(`Value exceeds U256 maximum`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "U256",
+      reason: "Value must be <= 2^256 - 1"
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createU256, "createU256");
+function createU512(value) {
+  const bigIntValue = toBigIntValue(value, "U512");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "U512",
+      reason: "U512 must be non-negative"
+    });
+  }
+  if (bigIntValue > chunkMDFSBU5W_cjs.U512_MAX) {
+    throw new ConversionError(`Value exceeds U512 maximum`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "U512",
+      reason: "Value must be <= 2^512 - 1"
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createU512, "createU512");
+function createU1024(value) {
+  const bigIntValue = toBigIntValue(value, "U1024");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "U1024",
+      reason: "U1024 must be non-negative"
+    });
+  }
+  if (bigIntValue > chunkMDFSBU5W_cjs.U1024_MAX) {
+    throw new ConversionError(`Value exceeds U1024 maximum`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "U1024",
+      reason: "Value must be <= 2^1024 - 1"
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createU1024, "createU1024");
+function createI8(value) {
+  const bigIntValue = toBigIntValue(value, "I8");
+  if (bigIntValue < chunkMDFSBU5W_cjs.I8_MIN || bigIntValue > chunkMDFSBU5W_cjs.I8_MAX) {
+    throw new ConversionError(`Value ${String(bigIntValue)} is out of range for I8`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "I8",
+      reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I8_MIN)}, ${String(chunkMDFSBU5W_cjs.I8_MAX)}]`
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createI8, "createI8");
+function createI16(value) {
+  const bigIntValue = toBigIntValue(value, "I16");
+  if (bigIntValue < chunkMDFSBU5W_cjs.I16_MIN || bigIntValue > chunkMDFSBU5W_cjs.I16_MAX) {
+    throw new ConversionError(`Value ${String(bigIntValue)} is out of range for I16`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "I16",
+      reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I16_MIN)}, ${String(chunkMDFSBU5W_cjs.I16_MAX)}]`
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createI16, "createI16");
+function createI32(value) {
+  const bigIntValue = toBigIntValue(value, "I32");
+  if (bigIntValue < chunkMDFSBU5W_cjs.I32_MIN || bigIntValue > chunkMDFSBU5W_cjs.I32_MAX) {
+    throw new ConversionError(`Value ${String(bigIntValue)} is out of range for I32`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "I32",
+      reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I32_MIN)}, ${String(chunkMDFSBU5W_cjs.I32_MAX)}]`
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createI32, "createI32");
+function createI64(value) {
+  const bigIntValue = toBigIntValue(value, "I64");
+  if (bigIntValue < chunkMDFSBU5W_cjs.I64_MIN || bigIntValue > chunkMDFSBU5W_cjs.I64_MAX) {
+    throw new ConversionError(`Value is out of range for I64`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "I64",
+      reason: "Value must be in range [-2^63, 2^63 - 1]"
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createI64, "createI64");
+function createI128(value) {
+  const bigIntValue = toBigIntValue(value, "I128");
+  if (bigIntValue < chunkMDFSBU5W_cjs.I128_MIN || bigIntValue > chunkMDFSBU5W_cjs.I128_MAX) {
+    throw new ConversionError(`Value is out of range for I128`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "I128",
+      reason: "Value must be in range [-2^127, 2^127 - 1]"
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createI128, "createI128");
+function createI256(value) {
+  const bigIntValue = toBigIntValue(value, "I256");
+  if (bigIntValue < chunkMDFSBU5W_cjs.I256_MIN || bigIntValue > chunkMDFSBU5W_cjs.I256_MAX) {
+    throw new ConversionError(`Value is out of range for I256`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "I256",
+      reason: "Value must be in range [-2^255, 2^255 - 1]"
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createI256, "createI256");
+function createI512(value) {
+  const bigIntValue = toBigIntValue(value, "I512");
+  if (bigIntValue < chunkMDFSBU5W_cjs.I512_MIN || bigIntValue > chunkMDFSBU5W_cjs.I512_MAX) {
+    throw new ConversionError(`Value is out of range for I512`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "I512",
+      reason: "Value must be in range [-2^511, 2^511 - 1]"
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createI512, "createI512");
+function createI1024(value) {
+  const bigIntValue = toBigIntValue(value, "I1024");
+  if (bigIntValue < chunkMDFSBU5W_cjs.I1024_MIN || bigIntValue > chunkMDFSBU5W_cjs.I1024_MAX) {
+    throw new ConversionError(`Value is out of range for I1024`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "I1024",
+      reason: "Value must be in range [-2^1023, 2^1023 - 1]"
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createI1024, "createI1024");
+function createBn254FieldElement(value) {
+  const bigIntValue = toBigIntValue(value, "Bn254FieldElement");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "Bn254FieldElement",
+      reason: "Field elements must be non-negative"
+    });
+  }
+  if (bigIntValue >= chunkMDFSBU5W_cjs.BN254_FIELD_PRIME) {
+    throw new ConversionError(`Value exceeds BN254 field prime`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "Bn254FieldElement",
+      reason: `Value must be < ${String(chunkMDFSBU5W_cjs.BN254_FIELD_PRIME)}`
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createBn254FieldElement, "createBn254FieldElement");
+function createCurve25519FieldElement(value) {
+  const bigIntValue = toBigIntValue(value, "Curve25519FieldElement");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "Curve25519FieldElement",
+      reason: "Field elements must be non-negative"
+    });
+  }
+  if (bigIntValue >= chunkMDFSBU5W_cjs.CURVE25519_FIELD_PRIME) {
+    throw new ConversionError(`Value exceeds Curve25519 field prime`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "Curve25519FieldElement",
+      reason: `Value must be < 2^255 - 19`
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createCurve25519FieldElement, "createCurve25519FieldElement");
+function createPoseidonPlaintext(value) {
+  const bigIntValue = toBigIntValue(value, "PoseidonPlaintext");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "PoseidonPlaintext",
+      reason: "Poseidon plaintexts must be non-negative"
+    });
+  }
+  if (bigIntValue >= chunkMDFSBU5W_cjs.BN254_FIELD_PRIME) {
+    throw new ConversionError(`Value exceeds BN254 field prime`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "PoseidonPlaintext",
+      reason: `Poseidon plaintexts must be < ${String(chunkMDFSBU5W_cjs.BN254_FIELD_PRIME)}`
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createPoseidonPlaintext, "createPoseidonPlaintext");
+function createPoseidonHash(value) {
+  const bigIntValue = toBigIntValue(value, "PoseidonHash");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "PoseidonHash",
+      reason: "Poseidon hashes must be non-negative"
+    });
+  }
+  if (bigIntValue >= chunkMDFSBU5W_cjs.BN254_FIELD_PRIME) {
+    throw new ConversionError(`Value exceeds BN254 field prime`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "PoseidonHash",
+      reason: `Poseidon hashes must be < ${String(chunkMDFSBU5W_cjs.BN254_FIELD_PRIME)}`
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createPoseidonHash, "createPoseidonHash");
+function createPoseidonKey(value) {
+  const bigIntValue = toBigIntValue(value, "PoseidonKey");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "PoseidonKey",
+      reason: "Poseidon keys must be non-negative"
+    });
+  }
+  if (bigIntValue >= chunkMDFSBU5W_cjs.BN254_FIELD_PRIME) {
+    throw new ConversionError(`Value exceeds BN254 field prime`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "PoseidonKey",
+      reason: `Poseidon keys must be < ${String(chunkMDFSBU5W_cjs.BN254_FIELD_PRIME)}`
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createPoseidonKey, "createPoseidonKey");
+function createPoseidonCiphertext(value) {
+  const bigIntValue = toBigIntValue(value, "PoseidonCiphertext");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "PoseidonCiphertext",
+      reason: "Poseidon ciphertexts must be non-negative"
+    });
+  }
+  if (bigIntValue >= chunkMDFSBU5W_cjs.BN254_FIELD_PRIME) {
+    throw new ConversionError(`Value exceeds BN254 field prime`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "PoseidonCiphertext",
+      reason: `Poseidon ciphertexts must be < ${String(chunkMDFSBU5W_cjs.BN254_FIELD_PRIME)}`
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createPoseidonCiphertext, "createPoseidonCiphertext");
+function createRcCiphertext(value) {
+  const bigIntValue = toBigIntValue(value, "RcCiphertext");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "RcCiphertext",
+      reason: "Rescue ciphertexts must be non-negative"
+    });
+  }
+  if (bigIntValue >= chunkMDFSBU5W_cjs.CURVE25519_FIELD_PRIME) {
+    throw new ConversionError(`Value exceeds Curve25519 field prime`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "RcCiphertext",
+      reason: "Rescue ciphertexts must be < 2^255 - 19"
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createRcCiphertext, "createRcCiphertext");
+function createRcPlaintext(value) {
+  const bigIntValue = toBigIntValue(value, "RcPlaintext");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "RcPlaintext",
+      reason: "Rescue plaintexts must be non-negative"
+    });
+  }
+  if (bigIntValue >= chunkMDFSBU5W_cjs.CURVE25519_FIELD_PRIME) {
+    throw new ConversionError(`Value exceeds Curve25519 field prime`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "RcPlaintext",
+      reason: "Rescue plaintexts must be < 2^255 - 19"
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createRcPlaintext, "createRcPlaintext");
+function createRcKey(value) {
+  const bigIntValue = toBigIntValue(value, "RcKey");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "RcKey",
+      reason: "Rescue keys must be non-negative"
+    });
+  }
+  if (bigIntValue >= chunkMDFSBU5W_cjs.CURVE25519_FIELD_PRIME) {
+    throw new ConversionError(`Value exceeds Curve25519 field prime`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "RcKey",
+      reason: "Rescue keys must be < 2^255 - 19"
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createRcKey, "createRcKey");
+function createRcCounter(value) {
+  const bigIntValue = toBigIntValue(value, "RcCounter");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "RcCounter",
+      reason: "Rescue counters must be non-negative"
+    });
+  }
+  if (bigIntValue >= chunkMDFSBU5W_cjs.CURVE25519_FIELD_PRIME) {
+    throw new ConversionError(`Value exceeds Curve25519 field prime`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "RcCounter",
+      reason: "Rescue counters must be < 2^255 - 19"
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createRcCounter, "createRcCounter");
+function createRcEncryptionNonce(value) {
+  const bigIntValue = toBigIntValue(value, "RcEncryptionNonce");
+  if (bigIntValue < 0n) {
+    throw new ConversionError(`Value is negative`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "RcEncryptionNonce",
+      reason: "Rescue encryption nonces must be non-negative"
+    });
+  }
+  if (bigIntValue > chunkMDFSBU5W_cjs.U128_MAX) {
+    throw new ConversionError(`Value exceeds U128 maximum`, {
+      sourceValue: value,
+      sourceType: getTypeName(value),
+      targetType: "RcEncryptionNonce",
+      reason: "Rescue encryption nonces must be <= 2^128 - 1"
+    });
+  }
+  return bigIntValue;
+}
+chunkPK6SKIKE_cjs.__name(createRcEncryptionNonce, "createRcEncryptionNonce");
+function createBytes(value) {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  if (value instanceof DataView) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index++) {
+      const byte = value[index];
+      if (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) {
+        throw new ConversionError(`Invalid byte value at index ${String(index)}: ${String(byte)}`, {
+          sourceValue: value,
+          sourceType: "number[]",
+          targetType: "Bytes",
+          reason: "All values must be integers in range [0, 255]"
+        });
+      }
+    }
+    return new Uint8Array(value);
+  }
+  throw new ConversionError(`Cannot convert to Bytes`, {
+    sourceValue: value,
+    sourceType: typeof value,
+    targetType: "Bytes",
+    reason: "Expected Uint8Array, ArrayBuffer, DataView, or number[]"
+  });
+}
+chunkPK6SKIKE_cjs.__name(createBytes, "createBytes");
+function createX25519Bytes(value) {
+  let bytes;
+  if (value instanceof Uint8Array) {
+    bytes = value;
+  } else if (value instanceof ArrayBuffer) {
+    bytes = new Uint8Array(value);
+  } else if (value instanceof DataView) {
+    bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  } else if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index++) {
+      const byte = value[index];
+      if (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) {
+        throw new ConversionError(`Invalid byte value at index ${String(index)}: ${String(byte)}`, {
+          sourceValue: value,
+          sourceType: "number[]",
+          targetType: "X25519Bytes",
+          reason: "All values must be integers in range [0, 255]"
+        });
+      }
+    }
+    bytes = new Uint8Array(value);
+  } else {
+    throw new ConversionError(`Cannot convert to X25519Bytes`, {
+      sourceValue: value,
+      sourceType: typeof value,
+      targetType: "X25519Bytes",
+      reason: "Expected Uint8Array, ArrayBuffer, DataView, or number[]"
+    });
+  }
+  if (bytes.length > chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH) {
+    throw new ConversionError(
+      `Value exceeds X25519 byte length (${String(bytes.length)} > ${String(chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH)})`,
+      {
+        sourceValue: value,
+        sourceType: getTypeName(value),
+        targetType: "X25519Bytes",
+        reason: `X25519 values must be at most ${String(chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH)} bytes`
+      }
+    );
+  }
+  if (bytes.length < chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH) {
+    const padded = new Uint8Array(chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH);
+    padded.set(bytes, 0);
+    return padded;
+  }
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createX25519Bytes, "createX25519Bytes");
+function createX25519PrivateKey(value) {
+  let bytes;
+  if (value instanceof Uint8Array) {
+    bytes = value;
+  } else if (value instanceof ArrayBuffer) {
+    bytes = new Uint8Array(value);
+  } else if (value instanceof DataView) {
+    bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  } else if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index++) {
+      const byte = value[index];
+      if (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) {
+        throw new ConversionError(`Invalid byte value at index ${String(index)}: ${String(byte)}`, {
+          sourceValue: value,
+          sourceType: "number[]",
+          targetType: "X25519PrivateKey",
+          reason: "All values must be integers in range [0, 255]"
+        });
+      }
+    }
+    bytes = new Uint8Array(value);
+  } else {
+    throw new ConversionError(`Cannot convert to X25519PrivateKey`, {
+      sourceValue: value,
+      sourceType: typeof value,
+      targetType: "X25519PrivateKey",
+      reason: "Expected Uint8Array, ArrayBuffer, DataView, or number[]"
+    });
+  }
+  if (bytes.length > chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH) {
+    throw new ConversionError(
+      `Value exceeds X25519 byte length (${String(bytes.length)} > ${String(chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH)})`,
+      {
+        sourceValue: value,
+        sourceType: getTypeName(value),
+        targetType: "X25519PrivateKey",
+        reason: `X25519 private keys must be at most ${String(chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH)} bytes`
+      }
+    );
+  }
+  if (bytes.length < chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH) {
+    const padded = new Uint8Array(chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH);
+    padded.set(bytes, 0);
+    return padded;
+  }
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createX25519PrivateKey, "createX25519PrivateKey");
+function createX25519PublicKey(value) {
+  let bytes;
+  if (value instanceof Uint8Array) {
+    bytes = value;
+  } else if (value instanceof ArrayBuffer) {
+    bytes = new Uint8Array(value);
+  } else if (value instanceof DataView) {
+    bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  } else if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index++) {
+      const byte = value[index];
+      if (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) {
+        throw new ConversionError(`Invalid byte value at index ${String(index)}: ${String(byte)}`, {
+          sourceValue: value,
+          sourceType: "number[]",
+          targetType: "X25519PublicKey",
+          reason: "All values must be integers in range [0, 255]"
+        });
+      }
+    }
+    bytes = new Uint8Array(value);
+  } else {
+    throw new ConversionError(`Cannot convert to X25519PublicKey`, {
+      sourceValue: value,
+      sourceType: typeof value,
+      targetType: "X25519PublicKey",
+      reason: "Expected Uint8Array, ArrayBuffer, DataView, or number[]"
+    });
+  }
+  if (bytes.length > chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH) {
+    throw new ConversionError(
+      `Value exceeds X25519 byte length (${String(bytes.length)} > ${String(chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH)})`,
+      {
+        sourceValue: value,
+        sourceType: getTypeName(value),
+        targetType: "X25519PublicKey",
+        reason: `X25519 public keys must be at most ${String(chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH)} bytes`
+      }
+    );
+  }
+  if (bytes.length < chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH) {
+    const padded = new Uint8Array(chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH);
+    padded.set(bytes, 0);
+    return padded;
+  }
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createX25519PublicKey, "createX25519PublicKey");
+function createSharedSecret(value) {
+  let bytes;
+  if (value instanceof Uint8Array) {
+    bytes = value;
+  } else if (value instanceof ArrayBuffer) {
+    bytes = new Uint8Array(value);
+  } else if (value instanceof DataView) {
+    bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  } else if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index++) {
+      const byte = value[index];
+      if (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) {
+        throw new ConversionError(`Invalid byte value at index ${String(index)}: ${String(byte)}`, {
+          sourceValue: value,
+          sourceType: "number[]",
+          targetType: "SharedSecret",
+          reason: "All values must be integers in range [0, 255]"
+        });
+      }
+    }
+    bytes = new Uint8Array(value);
+  } else {
+    throw new ConversionError(`Cannot convert to SharedSecret`, {
+      sourceValue: value,
+      sourceType: typeof value,
+      targetType: "SharedSecret",
+      reason: "Expected Uint8Array, ArrayBuffer, DataView, or number[]"
+    });
+  }
+  if (bytes.length > chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH) {
+    throw new ConversionError(
+      `Value exceeds SharedSecret byte length (${String(bytes.length)} > ${String(chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH)})`,
+      {
+        sourceValue: value,
+        sourceType: getTypeName(value),
+        targetType: "SharedSecret",
+        reason: `Shared secrets must be at most ${String(chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH)} bytes`
+      }
+    );
+  }
+  if (bytes.length < chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH) {
+    const padded = new Uint8Array(chunkMDFSBU5W_cjs.X25519_BYTE_LENGTH);
+    padded.set(bytes, 0);
+    return padded;
+  }
+  return bytes;
+}
+chunkPK6SKIKE_cjs.__name(createSharedSecret, "createSharedSecret");
+
+// src/common/converters/mathematics.ts
+function convertU8ToU16(value) {
+  chunkMDFSBU5W_cjs.assertU8(value);
+  chunkMDFSBU5W_cjs.assertU16(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU8ToU16, "convertU8ToU16");
+function convertU8ToU32(value) {
+  chunkMDFSBU5W_cjs.assertU8(value);
+  chunkMDFSBU5W_cjs.assertU32(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU8ToU32, "convertU8ToU32");
+function convertU8ToU64(value) {
+  chunkMDFSBU5W_cjs.assertU8(value);
+  chunkMDFSBU5W_cjs.assertU64(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU8ToU64, "convertU8ToU64");
+function convertU8ToU128(value) {
+  chunkMDFSBU5W_cjs.assertU8(value);
+  chunkMDFSBU5W_cjs.assertU128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU8ToU128, "convertU8ToU128");
+function convertU8ToU256(value) {
+  chunkMDFSBU5W_cjs.assertU8(value);
+  chunkMDFSBU5W_cjs.assertU256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU8ToU256, "convertU8ToU256");
+function convertU8ToU512(value) {
+  chunkMDFSBU5W_cjs.assertU8(value);
+  chunkMDFSBU5W_cjs.assertU512(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU8ToU512, "convertU8ToU512");
+function convertU8ToU1024(value) {
+  chunkMDFSBU5W_cjs.assertU8(value);
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU8ToU1024, "convertU8ToU1024");
+function convertU16ToU32(value) {
+  chunkMDFSBU5W_cjs.assertU16(value);
+  chunkMDFSBU5W_cjs.assertU32(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU16ToU32, "convertU16ToU32");
+function convertU16ToU64(value) {
+  chunkMDFSBU5W_cjs.assertU16(value);
+  chunkMDFSBU5W_cjs.assertU64(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU16ToU64, "convertU16ToU64");
+function convertU16ToU128(value) {
+  chunkMDFSBU5W_cjs.assertU16(value);
+  chunkMDFSBU5W_cjs.assertU128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU16ToU128, "convertU16ToU128");
+function convertU16ToU256(value) {
+  chunkMDFSBU5W_cjs.assertU16(value);
+  chunkMDFSBU5W_cjs.assertU256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU16ToU256, "convertU16ToU256");
+function convertU16ToU512(value) {
+  chunkMDFSBU5W_cjs.assertU16(value);
+  chunkMDFSBU5W_cjs.assertU512(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU16ToU512, "convertU16ToU512");
+function convertU16ToU1024(value) {
+  chunkMDFSBU5W_cjs.assertU16(value);
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU16ToU1024, "convertU16ToU1024");
+function convertU32ToU64(value) {
+  chunkMDFSBU5W_cjs.assertU32(value);
+  chunkMDFSBU5W_cjs.assertU64(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU32ToU64, "convertU32ToU64");
+function convertU32ToU128(value) {
+  chunkMDFSBU5W_cjs.assertU32(value);
+  chunkMDFSBU5W_cjs.assertU128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU32ToU128, "convertU32ToU128");
+function convertU32ToU256(value) {
+  chunkMDFSBU5W_cjs.assertU32(value);
+  chunkMDFSBU5W_cjs.assertU256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU32ToU256, "convertU32ToU256");
+function convertU32ToU512(value) {
+  chunkMDFSBU5W_cjs.assertU32(value);
+  chunkMDFSBU5W_cjs.assertU512(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU32ToU512, "convertU32ToU512");
+function convertU32ToU1024(value) {
+  chunkMDFSBU5W_cjs.assertU32(value);
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU32ToU1024, "convertU32ToU1024");
+function convertU64ToU128(value) {
+  chunkMDFSBU5W_cjs.assertU64(value);
+  chunkMDFSBU5W_cjs.assertU128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU64ToU128, "convertU64ToU128");
+function convertU64ToU256(value) {
+  chunkMDFSBU5W_cjs.assertU64(value);
+  chunkMDFSBU5W_cjs.assertU256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU64ToU256, "convertU64ToU256");
+function convertU64ToU512(value) {
+  chunkMDFSBU5W_cjs.assertU64(value);
+  chunkMDFSBU5W_cjs.assertU512(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU64ToU512, "convertU64ToU512");
+function convertU64ToU1024(value) {
+  chunkMDFSBU5W_cjs.assertU64(value);
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU64ToU1024, "convertU64ToU1024");
+function convertU128ToU256(value) {
+  chunkMDFSBU5W_cjs.assertU128(value);
+  chunkMDFSBU5W_cjs.assertU256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU128ToU256, "convertU128ToU256");
+function convertU128ToU512(value) {
+  chunkMDFSBU5W_cjs.assertU128(value);
+  chunkMDFSBU5W_cjs.assertU512(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU128ToU512, "convertU128ToU512");
+function convertU128ToU1024(value) {
+  chunkMDFSBU5W_cjs.assertU128(value);
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU128ToU1024, "convertU128ToU1024");
+function convertU256ToU512(value) {
+  chunkMDFSBU5W_cjs.assertU256(value);
+  chunkMDFSBU5W_cjs.assertU512(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU256ToU512, "convertU256ToU512");
+function convertU256ToU1024(value) {
+  chunkMDFSBU5W_cjs.assertU256(value);
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU256ToU1024, "convertU256ToU1024");
+function convertU512ToU1024(value) {
+  chunkMDFSBU5W_cjs.assertU512(value);
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU512ToU1024, "convertU512ToU1024");
+function convertU16ToU8(value) {
+  chunkMDFSBU5W_cjs.assertU16(value);
+  if (value > chunkMDFSBU5W_cjs.U8_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds U8 maximum of ${String(chunkMDFSBU5W_cjs.U8_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U16",
+      targetType: "U8",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U8_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU8(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU16ToU8, "convertU16ToU8");
+function convertU32ToU8(value) {
+  chunkMDFSBU5W_cjs.assertU32(value);
+  if (value > chunkMDFSBU5W_cjs.U8_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds U8 maximum of ${String(chunkMDFSBU5W_cjs.U8_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U32",
+      targetType: "U8",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U8_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU8(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU32ToU8, "convertU32ToU8");
+function convertU32ToU16(value) {
+  chunkMDFSBU5W_cjs.assertU32(value);
+  if (value > chunkMDFSBU5W_cjs.U16_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds U16 maximum of ${String(chunkMDFSBU5W_cjs.U16_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U32",
+      targetType: "U16",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U16_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU16(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU32ToU16, "convertU32ToU16");
+function convertU64ToU8(value) {
+  chunkMDFSBU5W_cjs.assertU64(value);
+  if (value > chunkMDFSBU5W_cjs.U8_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds U8 maximum of ${String(chunkMDFSBU5W_cjs.U8_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U64",
+      targetType: "U8",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U8_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU8(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU64ToU8, "convertU64ToU8");
+function convertU64ToU16(value) {
+  chunkMDFSBU5W_cjs.assertU64(value);
+  if (value > chunkMDFSBU5W_cjs.U16_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds U16 maximum of ${String(chunkMDFSBU5W_cjs.U16_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U64",
+      targetType: "U16",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U16_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU16(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU64ToU16, "convertU64ToU16");
+function convertU64ToU32(value) {
+  chunkMDFSBU5W_cjs.assertU64(value);
+  if (value > chunkMDFSBU5W_cjs.U32_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds U32 maximum of ${String(chunkMDFSBU5W_cjs.U32_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U64",
+      targetType: "U32",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U32_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU32(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU64ToU32, "convertU64ToU32");
+function convertU128ToU8(value) {
+  chunkMDFSBU5W_cjs.assertU128(value);
+  if (value > chunkMDFSBU5W_cjs.U8_MAX) {
+    throw new ConversionError(`Value exceeds U8 maximum of ${String(chunkMDFSBU5W_cjs.U8_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U128",
+      targetType: "U8",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U8_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU8(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU128ToU8, "convertU128ToU8");
+function convertU128ToU16(value) {
+  chunkMDFSBU5W_cjs.assertU128(value);
+  if (value > chunkMDFSBU5W_cjs.U16_MAX) {
+    throw new ConversionError(`Value exceeds U16 maximum of ${String(chunkMDFSBU5W_cjs.U16_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U128",
+      targetType: "U16",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U16_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU16(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU128ToU16, "convertU128ToU16");
+function convertU128ToU32(value) {
+  chunkMDFSBU5W_cjs.assertU128(value);
+  if (value > chunkMDFSBU5W_cjs.U32_MAX) {
+    throw new ConversionError(`Value exceeds U32 maximum of ${String(chunkMDFSBU5W_cjs.U32_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U128",
+      targetType: "U32",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U32_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU32(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU128ToU32, "convertU128ToU32");
+function convertU128ToU64(value) {
+  chunkMDFSBU5W_cjs.assertU128(value);
+  if (value > chunkMDFSBU5W_cjs.U64_MAX) {
+    throw new ConversionError(`Value exceeds U64 maximum`, {
+      sourceValue: value,
+      sourceType: "U128",
+      targetType: "U64",
+      reason: `Value must be <= 2^64 - 1`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU64(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU128ToU64, "convertU128ToU64");
+function convertU256ToU8(value) {
+  chunkMDFSBU5W_cjs.assertU256(value);
+  if (value > chunkMDFSBU5W_cjs.U8_MAX) {
+    throw new ConversionError(`Value exceeds U8 maximum of ${String(chunkMDFSBU5W_cjs.U8_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U256",
+      targetType: "U8",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U8_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU8(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU256ToU8, "convertU256ToU8");
+function convertU256ToU16(value) {
+  chunkMDFSBU5W_cjs.assertU256(value);
+  if (value > chunkMDFSBU5W_cjs.U16_MAX) {
+    throw new ConversionError(`Value exceeds U16 maximum of ${String(chunkMDFSBU5W_cjs.U16_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U256",
+      targetType: "U16",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U16_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU16(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU256ToU16, "convertU256ToU16");
+function convertU256ToU32(value) {
+  chunkMDFSBU5W_cjs.assertU256(value);
+  if (value > chunkMDFSBU5W_cjs.U32_MAX) {
+    throw new ConversionError(`Value exceeds U32 maximum of ${String(chunkMDFSBU5W_cjs.U32_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U256",
+      targetType: "U32",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U32_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU32(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU256ToU32, "convertU256ToU32");
+function convertU256ToU64(value) {
+  chunkMDFSBU5W_cjs.assertU256(value);
+  if (value > chunkMDFSBU5W_cjs.U64_MAX) {
+    throw new ConversionError(`Value exceeds U64 maximum`, {
+      sourceValue: value,
+      sourceType: "U256",
+      targetType: "U64",
+      reason: `Value must be <= 2^64 - 1`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU64(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU256ToU64, "convertU256ToU64");
+function convertU256ToU128(value) {
+  chunkMDFSBU5W_cjs.assertU256(value);
+  if (value > chunkMDFSBU5W_cjs.U128_MAX) {
+    throw new ConversionError(`Value exceeds U128 maximum`, {
+      sourceValue: value,
+      sourceType: "U256",
+      targetType: "U128",
+      reason: `Value must be <= 2^128 - 1`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU256ToU128, "convertU256ToU128");
+function convertU512ToU8(value) {
+  chunkMDFSBU5W_cjs.assertU512(value);
+  if (value > chunkMDFSBU5W_cjs.U8_MAX) {
+    throw new ConversionError(`Value exceeds U8 maximum of ${String(chunkMDFSBU5W_cjs.U8_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U512",
+      targetType: "U8",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U8_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU8(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU512ToU8, "convertU512ToU8");
+function convertU512ToU16(value) {
+  chunkMDFSBU5W_cjs.assertU512(value);
+  if (value > chunkMDFSBU5W_cjs.U16_MAX) {
+    throw new ConversionError(`Value exceeds U16 maximum of ${String(chunkMDFSBU5W_cjs.U16_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U512",
+      targetType: "U16",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U16_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU16(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU512ToU16, "convertU512ToU16");
+function convertU512ToU32(value) {
+  chunkMDFSBU5W_cjs.assertU512(value);
+  if (value > chunkMDFSBU5W_cjs.U32_MAX) {
+    throw new ConversionError(`Value exceeds U32 maximum of ${String(chunkMDFSBU5W_cjs.U32_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U512",
+      targetType: "U32",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U32_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU32(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU512ToU32, "convertU512ToU32");
+function convertU512ToU64(value) {
+  chunkMDFSBU5W_cjs.assertU512(value);
+  if (value > chunkMDFSBU5W_cjs.U64_MAX) {
+    throw new ConversionError(`Value exceeds U64 maximum`, {
+      sourceValue: value,
+      sourceType: "U512",
+      targetType: "U64",
+      reason: `Value must be <= 2^64 - 1`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU64(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU512ToU64, "convertU512ToU64");
+function convertU512ToU128(value) {
+  chunkMDFSBU5W_cjs.assertU512(value);
+  if (value > chunkMDFSBU5W_cjs.U128_MAX) {
+    throw new ConversionError(`Value exceeds U128 maximum`, {
+      sourceValue: value,
+      sourceType: "U512",
+      targetType: "U128",
+      reason: `Value must be <= 2^128 - 1`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU512ToU128, "convertU512ToU128");
+function convertU512ToU256(value) {
+  chunkMDFSBU5W_cjs.assertU512(value);
+  if (value > chunkMDFSBU5W_cjs.U256_MAX) {
+    throw new ConversionError(`Value exceeds U256 maximum`, {
+      sourceValue: value,
+      sourceType: "U512",
+      targetType: "U256",
+      reason: `Value must be <= 2^256 - 1`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU512ToU256, "convertU512ToU256");
+function convertU1024ToU8(value) {
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  if (value > chunkMDFSBU5W_cjs.U8_MAX) {
+    throw new ConversionError(`Value exceeds U8 maximum of ${String(chunkMDFSBU5W_cjs.U8_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U1024",
+      targetType: "U8",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U8_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU8(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU1024ToU8, "convertU1024ToU8");
+function convertU1024ToU16(value) {
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  if (value > chunkMDFSBU5W_cjs.U16_MAX) {
+    throw new ConversionError(`Value exceeds U16 maximum of ${String(chunkMDFSBU5W_cjs.U16_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U1024",
+      targetType: "U16",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U16_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU16(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU1024ToU16, "convertU1024ToU16");
+function convertU1024ToU32(value) {
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  if (value > chunkMDFSBU5W_cjs.U32_MAX) {
+    throw new ConversionError(`Value exceeds U32 maximum of ${String(chunkMDFSBU5W_cjs.U32_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U1024",
+      targetType: "U32",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.U32_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU32(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU1024ToU32, "convertU1024ToU32");
+function convertU1024ToU64(value) {
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  if (value > chunkMDFSBU5W_cjs.U64_MAX) {
+    throw new ConversionError(`Value exceeds U64 maximum`, {
+      sourceValue: value,
+      sourceType: "U1024",
+      targetType: "U64",
+      reason: `Value must be <= 2^64 - 1`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU64(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU1024ToU64, "convertU1024ToU64");
+function convertU1024ToU128(value) {
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  if (value > chunkMDFSBU5W_cjs.U128_MAX) {
+    throw new ConversionError(`Value exceeds U128 maximum`, {
+      sourceValue: value,
+      sourceType: "U1024",
+      targetType: "U128",
+      reason: `Value must be <= 2^128 - 1`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU1024ToU128, "convertU1024ToU128");
+function convertU1024ToU256(value) {
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  if (value > chunkMDFSBU5W_cjs.U256_MAX) {
+    throw new ConversionError(`Value exceeds U256 maximum`, {
+      sourceValue: value,
+      sourceType: "U1024",
+      targetType: "U256",
+      reason: `Value must be <= 2^256 - 1`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU1024ToU256, "convertU1024ToU256");
+function convertU1024ToU512(value) {
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  if (value > chunkMDFSBU5W_cjs.U512_MAX) {
+    throw new ConversionError(`Value exceeds U512 maximum`, {
+      sourceValue: value,
+      sourceType: "U1024",
+      targetType: "U512",
+      reason: `Value must be <= 2^512 - 1`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU512(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU1024ToU512, "convertU1024ToU512");
+function convertI8ToI16(value) {
+  chunkMDFSBU5W_cjs.assertI8(value);
+  chunkMDFSBU5W_cjs.assertI16(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI8ToI16, "convertI8ToI16");
+function convertI8ToI32(value) {
+  chunkMDFSBU5W_cjs.assertI8(value);
+  chunkMDFSBU5W_cjs.assertI32(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI8ToI32, "convertI8ToI32");
+function convertI8ToI64(value) {
+  chunkMDFSBU5W_cjs.assertI8(value);
+  chunkMDFSBU5W_cjs.assertI64(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI8ToI64, "convertI8ToI64");
+function convertI8ToI128(value) {
+  chunkMDFSBU5W_cjs.assertI8(value);
+  chunkMDFSBU5W_cjs.assertI128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI8ToI128, "convertI8ToI128");
+function convertI8ToI256(value) {
+  chunkMDFSBU5W_cjs.assertI8(value);
+  chunkMDFSBU5W_cjs.assertI256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI8ToI256, "convertI8ToI256");
+function convertI8ToI512(value) {
+  chunkMDFSBU5W_cjs.assertI8(value);
+  chunkMDFSBU5W_cjs.assertI512(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI8ToI512, "convertI8ToI512");
+function convertI8ToI1024(value) {
+  chunkMDFSBU5W_cjs.assertI8(value);
+  chunkMDFSBU5W_cjs.assertI1024(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI8ToI1024, "convertI8ToI1024");
+function convertI16ToI32(value) {
+  chunkMDFSBU5W_cjs.assertI16(value);
+  chunkMDFSBU5W_cjs.assertI32(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI16ToI32, "convertI16ToI32");
+function convertI16ToI64(value) {
+  chunkMDFSBU5W_cjs.assertI16(value);
+  chunkMDFSBU5W_cjs.assertI64(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI16ToI64, "convertI16ToI64");
+function convertI16ToI128(value) {
+  chunkMDFSBU5W_cjs.assertI16(value);
+  chunkMDFSBU5W_cjs.assertI128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI16ToI128, "convertI16ToI128");
+function convertI16ToI256(value) {
+  chunkMDFSBU5W_cjs.assertI16(value);
+  chunkMDFSBU5W_cjs.assertI256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI16ToI256, "convertI16ToI256");
+function convertI16ToI512(value) {
+  chunkMDFSBU5W_cjs.assertI16(value);
+  chunkMDFSBU5W_cjs.assertI512(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI16ToI512, "convertI16ToI512");
+function convertI16ToI1024(value) {
+  chunkMDFSBU5W_cjs.assertI16(value);
+  chunkMDFSBU5W_cjs.assertI1024(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI16ToI1024, "convertI16ToI1024");
+function convertI32ToI64(value) {
+  chunkMDFSBU5W_cjs.assertI32(value);
+  chunkMDFSBU5W_cjs.assertI64(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI32ToI64, "convertI32ToI64");
+function convertI32ToI128(value) {
+  chunkMDFSBU5W_cjs.assertI32(value);
+  chunkMDFSBU5W_cjs.assertI128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI32ToI128, "convertI32ToI128");
+function convertI32ToI256(value) {
+  chunkMDFSBU5W_cjs.assertI32(value);
+  chunkMDFSBU5W_cjs.assertI256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI32ToI256, "convertI32ToI256");
+function convertI32ToI512(value) {
+  chunkMDFSBU5W_cjs.assertI32(value);
+  chunkMDFSBU5W_cjs.assertI512(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI32ToI512, "convertI32ToI512");
+function convertI32ToI1024(value) {
+  chunkMDFSBU5W_cjs.assertI32(value);
+  chunkMDFSBU5W_cjs.assertI1024(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI32ToI1024, "convertI32ToI1024");
+function convertI64ToI128(value) {
+  chunkMDFSBU5W_cjs.assertI64(value);
+  chunkMDFSBU5W_cjs.assertI128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI64ToI128, "convertI64ToI128");
+function convertI64ToI256(value) {
+  chunkMDFSBU5W_cjs.assertI64(value);
+  chunkMDFSBU5W_cjs.assertI256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI64ToI256, "convertI64ToI256");
+function convertI64ToI512(value) {
+  chunkMDFSBU5W_cjs.assertI64(value);
+  chunkMDFSBU5W_cjs.assertI512(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI64ToI512, "convertI64ToI512");
+function convertI64ToI1024(value) {
+  chunkMDFSBU5W_cjs.assertI64(value);
+  chunkMDFSBU5W_cjs.assertI1024(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI64ToI1024, "convertI64ToI1024");
+function convertI128ToI256(value) {
+  chunkMDFSBU5W_cjs.assertI128(value);
+  chunkMDFSBU5W_cjs.assertI256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI128ToI256, "convertI128ToI256");
+function convertI128ToI512(value) {
+  chunkMDFSBU5W_cjs.assertI128(value);
+  chunkMDFSBU5W_cjs.assertI512(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI128ToI512, "convertI128ToI512");
+function convertI128ToI1024(value) {
+  chunkMDFSBU5W_cjs.assertI128(value);
+  chunkMDFSBU5W_cjs.assertI1024(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI128ToI1024, "convertI128ToI1024");
+function convertI256ToI512(value) {
+  chunkMDFSBU5W_cjs.assertI256(value);
+  chunkMDFSBU5W_cjs.assertI512(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI256ToI512, "convertI256ToI512");
+function convertI256ToI1024(value) {
+  chunkMDFSBU5W_cjs.assertI256(value);
+  chunkMDFSBU5W_cjs.assertI1024(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI256ToI1024, "convertI256ToI1024");
+function convertI512ToI1024(value) {
+  chunkMDFSBU5W_cjs.assertI512(value);
+  chunkMDFSBU5W_cjs.assertI1024(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI512ToI1024, "convertI512ToI1024");
+function convertI16ToI8(value) {
+  chunkMDFSBU5W_cjs.assertI16(value);
+  if (value < chunkMDFSBU5W_cjs.I8_MIN || value > chunkMDFSBU5W_cjs.I8_MAX) {
+    throw new ConversionError(
+      `Value ${String(value)} is out of range for I8 [${String(chunkMDFSBU5W_cjs.I8_MIN)}, ${String(chunkMDFSBU5W_cjs.I8_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I16",
+        targetType: "I8",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I8_MIN)}, ${String(chunkMDFSBU5W_cjs.I8_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI8(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI16ToI8, "convertI16ToI8");
+function convertI32ToI8(value) {
+  chunkMDFSBU5W_cjs.assertI32(value);
+  if (value < chunkMDFSBU5W_cjs.I8_MIN || value > chunkMDFSBU5W_cjs.I8_MAX) {
+    throw new ConversionError(
+      `Value ${String(value)} is out of range for I8 [${String(chunkMDFSBU5W_cjs.I8_MIN)}, ${String(chunkMDFSBU5W_cjs.I8_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I32",
+        targetType: "I8",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I8_MIN)}, ${String(chunkMDFSBU5W_cjs.I8_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI8(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI32ToI8, "convertI32ToI8");
+function convertI32ToI16(value) {
+  chunkMDFSBU5W_cjs.assertI32(value);
+  if (value < chunkMDFSBU5W_cjs.I16_MIN || value > chunkMDFSBU5W_cjs.I16_MAX) {
+    throw new ConversionError(
+      `Value ${String(value)} is out of range for I16 [${String(chunkMDFSBU5W_cjs.I16_MIN)}, ${String(chunkMDFSBU5W_cjs.I16_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I32",
+        targetType: "I16",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I16_MIN)}, ${String(chunkMDFSBU5W_cjs.I16_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI16(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI32ToI16, "convertI32ToI16");
+function convertI64ToI8(value) {
+  chunkMDFSBU5W_cjs.assertI64(value);
+  if (value < chunkMDFSBU5W_cjs.I8_MIN || value > chunkMDFSBU5W_cjs.I8_MAX) {
+    throw new ConversionError(
+      `Value ${String(value)} is out of range for I8 [${String(chunkMDFSBU5W_cjs.I8_MIN)}, ${String(chunkMDFSBU5W_cjs.I8_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I64",
+        targetType: "I8",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I8_MIN)}, ${String(chunkMDFSBU5W_cjs.I8_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI8(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI64ToI8, "convertI64ToI8");
+function convertI64ToI16(value) {
+  chunkMDFSBU5W_cjs.assertI64(value);
+  if (value < chunkMDFSBU5W_cjs.I16_MIN || value > chunkMDFSBU5W_cjs.I16_MAX) {
+    throw new ConversionError(
+      `Value ${String(value)} is out of range for I16 [${String(chunkMDFSBU5W_cjs.I16_MIN)}, ${String(chunkMDFSBU5W_cjs.I16_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I64",
+        targetType: "I16",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I16_MIN)}, ${String(chunkMDFSBU5W_cjs.I16_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI16(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI64ToI16, "convertI64ToI16");
+function convertI64ToI32(value) {
+  chunkMDFSBU5W_cjs.assertI64(value);
+  if (value < chunkMDFSBU5W_cjs.I32_MIN || value > chunkMDFSBU5W_cjs.I32_MAX) {
+    throw new ConversionError(
+      `Value ${String(value)} is out of range for I32 [${String(chunkMDFSBU5W_cjs.I32_MIN)}, ${String(chunkMDFSBU5W_cjs.I32_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I64",
+        targetType: "I32",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I32_MIN)}, ${String(chunkMDFSBU5W_cjs.I32_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI32(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI64ToI32, "convertI64ToI32");
+function convertI128ToI8(value) {
+  chunkMDFSBU5W_cjs.assertI128(value);
+  if (value < chunkMDFSBU5W_cjs.I8_MIN || value > chunkMDFSBU5W_cjs.I8_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I8 [${String(chunkMDFSBU5W_cjs.I8_MIN)}, ${String(chunkMDFSBU5W_cjs.I8_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I128",
+        targetType: "I8",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I8_MIN)}, ${String(chunkMDFSBU5W_cjs.I8_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI8(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI128ToI8, "convertI128ToI8");
+function convertI128ToI16(value) {
+  chunkMDFSBU5W_cjs.assertI128(value);
+  if (value < chunkMDFSBU5W_cjs.I16_MIN || value > chunkMDFSBU5W_cjs.I16_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I16 [${String(chunkMDFSBU5W_cjs.I16_MIN)}, ${String(chunkMDFSBU5W_cjs.I16_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I128",
+        targetType: "I16",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I16_MIN)}, ${String(chunkMDFSBU5W_cjs.I16_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI16(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI128ToI16, "convertI128ToI16");
+function convertI128ToI32(value) {
+  chunkMDFSBU5W_cjs.assertI128(value);
+  if (value < chunkMDFSBU5W_cjs.I32_MIN || value > chunkMDFSBU5W_cjs.I32_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I32 [${String(chunkMDFSBU5W_cjs.I32_MIN)}, ${String(chunkMDFSBU5W_cjs.I32_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I128",
+        targetType: "I32",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I32_MIN)}, ${String(chunkMDFSBU5W_cjs.I32_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI32(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI128ToI32, "convertI128ToI32");
+function convertI128ToI64(value) {
+  chunkMDFSBU5W_cjs.assertI128(value);
+  if (value < chunkMDFSBU5W_cjs.I64_MIN || value > chunkMDFSBU5W_cjs.I64_MAX) {
+    throw new ConversionError(`Value is out of range for I64`, {
+      sourceValue: value,
+      sourceType: "I128",
+      targetType: "I64",
+      reason: `Value must be in range [-2^63, 2^63 - 1]`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI64(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI128ToI64, "convertI128ToI64");
+function convertI256ToI8(value) {
+  chunkMDFSBU5W_cjs.assertI256(value);
+  if (value < chunkMDFSBU5W_cjs.I8_MIN || value > chunkMDFSBU5W_cjs.I8_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I8 [${String(chunkMDFSBU5W_cjs.I8_MIN)}, ${String(chunkMDFSBU5W_cjs.I8_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I256",
+        targetType: "I8",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I8_MIN)}, ${String(chunkMDFSBU5W_cjs.I8_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI8(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI256ToI8, "convertI256ToI8");
+function convertI256ToI16(value) {
+  chunkMDFSBU5W_cjs.assertI256(value);
+  if (value < chunkMDFSBU5W_cjs.I16_MIN || value > chunkMDFSBU5W_cjs.I16_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I16 [${String(chunkMDFSBU5W_cjs.I16_MIN)}, ${String(chunkMDFSBU5W_cjs.I16_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I256",
+        targetType: "I16",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I16_MIN)}, ${String(chunkMDFSBU5W_cjs.I16_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI16(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI256ToI16, "convertI256ToI16");
+function convertI256ToI32(value) {
+  chunkMDFSBU5W_cjs.assertI256(value);
+  if (value < chunkMDFSBU5W_cjs.I32_MIN || value > chunkMDFSBU5W_cjs.I32_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I32 [${String(chunkMDFSBU5W_cjs.I32_MIN)}, ${String(chunkMDFSBU5W_cjs.I32_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I256",
+        targetType: "I32",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I32_MIN)}, ${String(chunkMDFSBU5W_cjs.I32_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI32(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI256ToI32, "convertI256ToI32");
+function convertI256ToI64(value) {
+  chunkMDFSBU5W_cjs.assertI256(value);
+  if (value < chunkMDFSBU5W_cjs.I64_MIN || value > chunkMDFSBU5W_cjs.I64_MAX) {
+    throw new ConversionError(`Value is out of range for I64`, {
+      sourceValue: value,
+      sourceType: "I256",
+      targetType: "I64",
+      reason: `Value must be in range [-2^63, 2^63 - 1]`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI64(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI256ToI64, "convertI256ToI64");
+function convertI256ToI128(value) {
+  chunkMDFSBU5W_cjs.assertI256(value);
+  if (value < chunkMDFSBU5W_cjs.I128_MIN || value > chunkMDFSBU5W_cjs.I128_MAX) {
+    throw new ConversionError(`Value is out of range for I128`, {
+      sourceValue: value,
+      sourceType: "I256",
+      targetType: "I128",
+      reason: `Value must be in range [-2^127, 2^127 - 1]`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI256ToI128, "convertI256ToI128");
+function convertI512ToI8(value) {
+  chunkMDFSBU5W_cjs.assertI512(value);
+  if (value < chunkMDFSBU5W_cjs.I8_MIN || value > chunkMDFSBU5W_cjs.I8_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I8 [${String(chunkMDFSBU5W_cjs.I8_MIN)}, ${String(chunkMDFSBU5W_cjs.I8_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I512",
+        targetType: "I8",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I8_MIN)}, ${String(chunkMDFSBU5W_cjs.I8_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI8(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI512ToI8, "convertI512ToI8");
+function convertI512ToI16(value) {
+  chunkMDFSBU5W_cjs.assertI512(value);
+  if (value < chunkMDFSBU5W_cjs.I16_MIN || value > chunkMDFSBU5W_cjs.I16_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I16 [${String(chunkMDFSBU5W_cjs.I16_MIN)}, ${String(chunkMDFSBU5W_cjs.I16_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I512",
+        targetType: "I16",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I16_MIN)}, ${String(chunkMDFSBU5W_cjs.I16_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI16(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI512ToI16, "convertI512ToI16");
+function convertI512ToI32(value) {
+  chunkMDFSBU5W_cjs.assertI512(value);
+  if (value < chunkMDFSBU5W_cjs.I32_MIN || value > chunkMDFSBU5W_cjs.I32_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I32 [${String(chunkMDFSBU5W_cjs.I32_MIN)}, ${String(chunkMDFSBU5W_cjs.I32_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I512",
+        targetType: "I32",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I32_MIN)}, ${String(chunkMDFSBU5W_cjs.I32_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI32(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI512ToI32, "convertI512ToI32");
+function convertI512ToI64(value) {
+  chunkMDFSBU5W_cjs.assertI512(value);
+  if (value < chunkMDFSBU5W_cjs.I64_MIN || value > chunkMDFSBU5W_cjs.I64_MAX) {
+    throw new ConversionError(`Value is out of range for I64`, {
+      sourceValue: value,
+      sourceType: "I512",
+      targetType: "I64",
+      reason: `Value must be in range [-2^63, 2^63 - 1]`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI64(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI512ToI64, "convertI512ToI64");
+function convertI512ToI128(value) {
+  chunkMDFSBU5W_cjs.assertI512(value);
+  if (value < chunkMDFSBU5W_cjs.I128_MIN || value > chunkMDFSBU5W_cjs.I128_MAX) {
+    throw new ConversionError(`Value is out of range for I128`, {
+      sourceValue: value,
+      sourceType: "I512",
+      targetType: "I128",
+      reason: `Value must be in range [-2^127, 2^127 - 1]`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI512ToI128, "convertI512ToI128");
+function convertI512ToI256(value) {
+  chunkMDFSBU5W_cjs.assertI512(value);
+  if (value < chunkMDFSBU5W_cjs.I256_MIN || value > chunkMDFSBU5W_cjs.I256_MAX) {
+    throw new ConversionError(`Value is out of range for I256`, {
+      sourceValue: value,
+      sourceType: "I512",
+      targetType: "I256",
+      reason: `Value must be in range [-2^255, 2^255 - 1]`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI512ToI256, "convertI512ToI256");
+function convertI1024ToI8(value) {
+  chunkMDFSBU5W_cjs.assertI1024(value);
+  if (value < chunkMDFSBU5W_cjs.I8_MIN || value > chunkMDFSBU5W_cjs.I8_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I8 [${String(chunkMDFSBU5W_cjs.I8_MIN)}, ${String(chunkMDFSBU5W_cjs.I8_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I1024",
+        targetType: "I8",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I8_MIN)}, ${String(chunkMDFSBU5W_cjs.I8_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI8(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI1024ToI8, "convertI1024ToI8");
+function convertI1024ToI16(value) {
+  chunkMDFSBU5W_cjs.assertI1024(value);
+  if (value < chunkMDFSBU5W_cjs.I16_MIN || value > chunkMDFSBU5W_cjs.I16_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I16 [${String(chunkMDFSBU5W_cjs.I16_MIN)}, ${String(chunkMDFSBU5W_cjs.I16_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I1024",
+        targetType: "I16",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I16_MIN)}, ${String(chunkMDFSBU5W_cjs.I16_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI16(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI1024ToI16, "convertI1024ToI16");
+function convertI1024ToI32(value) {
+  chunkMDFSBU5W_cjs.assertI1024(value);
+  if (value < chunkMDFSBU5W_cjs.I32_MIN || value > chunkMDFSBU5W_cjs.I32_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I32 [${String(chunkMDFSBU5W_cjs.I32_MIN)}, ${String(chunkMDFSBU5W_cjs.I32_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I1024",
+        targetType: "I32",
+        reason: `Value must be in range [${String(chunkMDFSBU5W_cjs.I32_MIN)}, ${String(chunkMDFSBU5W_cjs.I32_MAX)}]`
+      }
+    );
+  }
+  chunkMDFSBU5W_cjs.assertI32(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI1024ToI32, "convertI1024ToI32");
+function convertI1024ToI64(value) {
+  chunkMDFSBU5W_cjs.assertI1024(value);
+  if (value < chunkMDFSBU5W_cjs.I64_MIN || value > chunkMDFSBU5W_cjs.I64_MAX) {
+    throw new ConversionError(`Value is out of range for I64`, {
+      sourceValue: value,
+      sourceType: "I1024",
+      targetType: "I64",
+      reason: `Value must be in range [-2^63, 2^63 - 1]`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI64(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI1024ToI64, "convertI1024ToI64");
+function convertI1024ToI128(value) {
+  chunkMDFSBU5W_cjs.assertI1024(value);
+  if (value < chunkMDFSBU5W_cjs.I128_MIN || value > chunkMDFSBU5W_cjs.I128_MAX) {
+    throw new ConversionError(`Value is out of range for I128`, {
+      sourceValue: value,
+      sourceType: "I1024",
+      targetType: "I128",
+      reason: `Value must be in range [-2^127, 2^127 - 1]`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI1024ToI128, "convertI1024ToI128");
+function convertI1024ToI256(value) {
+  chunkMDFSBU5W_cjs.assertI1024(value);
+  if (value < chunkMDFSBU5W_cjs.I256_MIN || value > chunkMDFSBU5W_cjs.I256_MAX) {
+    throw new ConversionError(`Value is out of range for I256`, {
+      sourceValue: value,
+      sourceType: "I1024",
+      targetType: "I256",
+      reason: `Value must be in range [-2^255, 2^255 - 1]`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI1024ToI256, "convertI1024ToI256");
+function convertI1024ToI512(value) {
+  chunkMDFSBU5W_cjs.assertI1024(value);
+  if (value < chunkMDFSBU5W_cjs.I512_MIN || value > chunkMDFSBU5W_cjs.I512_MAX) {
+    throw new ConversionError(`Value is out of range for I512`, {
+      sourceValue: value,
+      sourceType: "I1024",
+      targetType: "I512",
+      reason: `Value must be in range [-2^511, 2^511 - 1]`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI512(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI1024ToI512, "convertI1024ToI512");
+function convertI8ToU8(value) {
+  chunkMDFSBU5W_cjs.assertI8(value);
+  if (value < 0n) {
+    throw new ConversionError(`Cannot convert negative value ${String(value)} to unsigned type`, {
+      sourceValue: value,
+      sourceType: "I8",
+      targetType: "U8",
+      reason: "Value must be non-negative"
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU8(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI8ToU8, "convertI8ToU8");
+function convertI16ToU16(value) {
+  chunkMDFSBU5W_cjs.assertI16(value);
+  if (value < 0n) {
+    throw new ConversionError(`Cannot convert negative value ${String(value)} to unsigned type`, {
+      sourceValue: value,
+      sourceType: "I16",
+      targetType: "U16",
+      reason: "Value must be non-negative"
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU16(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI16ToU16, "convertI16ToU16");
+function convertI32ToU32(value) {
+  chunkMDFSBU5W_cjs.assertI32(value);
+  if (value < 0n) {
+    throw new ConversionError(`Cannot convert negative value ${String(value)} to unsigned type`, {
+      sourceValue: value,
+      sourceType: "I32",
+      targetType: "U32",
+      reason: "Value must be non-negative"
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU32(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI32ToU32, "convertI32ToU32");
+function convertI64ToU64(value) {
+  chunkMDFSBU5W_cjs.assertI64(value);
+  if (value < 0n) {
+    throw new ConversionError(`Cannot convert negative value to unsigned type`, {
+      sourceValue: value,
+      sourceType: "I64",
+      targetType: "U64",
+      reason: "Value must be non-negative"
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU64(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI64ToU64, "convertI64ToU64");
+function convertI128ToU128(value) {
+  chunkMDFSBU5W_cjs.assertI128(value);
+  if (value < 0n) {
+    throw new ConversionError(`Cannot convert negative value to unsigned type`, {
+      sourceValue: value,
+      sourceType: "I128",
+      targetType: "U128",
+      reason: "Value must be non-negative"
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI128ToU128, "convertI128ToU128");
+function convertI256ToU256(value) {
+  chunkMDFSBU5W_cjs.assertI256(value);
+  if (value < 0n) {
+    throw new ConversionError(`Cannot convert negative value to unsigned type`, {
+      sourceValue: value,
+      sourceType: "I256",
+      targetType: "U256",
+      reason: "Value must be non-negative"
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI256ToU256, "convertI256ToU256");
+function convertI512ToU512(value) {
+  chunkMDFSBU5W_cjs.assertI512(value);
+  if (value < 0n) {
+    throw new ConversionError(`Cannot convert negative value to unsigned type`, {
+      sourceValue: value,
+      sourceType: "I512",
+      targetType: "U512",
+      reason: "Value must be non-negative"
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU512(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI512ToU512, "convertI512ToU512");
+function convertI1024ToU1024(value) {
+  chunkMDFSBU5W_cjs.assertI1024(value);
+  if (value < 0n) {
+    throw new ConversionError(`Cannot convert negative value to unsigned type`, {
+      sourceValue: value,
+      sourceType: "I1024",
+      targetType: "U1024",
+      reason: "Value must be non-negative"
+    });
+  }
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertI1024ToU1024, "convertI1024ToU1024");
+function convertU8ToI8(value) {
+  chunkMDFSBU5W_cjs.assertU8(value);
+  if (value > chunkMDFSBU5W_cjs.I8_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds I8 maximum of ${String(chunkMDFSBU5W_cjs.I8_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U8",
+      targetType: "I8",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.I8_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI8(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU8ToI8, "convertU8ToI8");
+function convertU16ToI16(value) {
+  chunkMDFSBU5W_cjs.assertU16(value);
+  if (value > chunkMDFSBU5W_cjs.I16_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds I16 maximum of ${String(chunkMDFSBU5W_cjs.I16_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U16",
+      targetType: "I16",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.I16_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI16(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU16ToI16, "convertU16ToI16");
+function convertU32ToI32(value) {
+  chunkMDFSBU5W_cjs.assertU32(value);
+  if (value > chunkMDFSBU5W_cjs.I32_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds I32 maximum of ${String(chunkMDFSBU5W_cjs.I32_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U32",
+      targetType: "I32",
+      reason: `Value must be <= ${String(chunkMDFSBU5W_cjs.I32_MAX)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI32(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU32ToI32, "convertU32ToI32");
+function convertU64ToI64(value) {
+  chunkMDFSBU5W_cjs.assertU64(value);
+  if (value > chunkMDFSBU5W_cjs.I64_MAX) {
+    throw new ConversionError(`Value exceeds I64 maximum`, {
+      sourceValue: value,
+      sourceType: "U64",
+      targetType: "I64",
+      reason: `Value must be <= 2^63 - 1`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI64(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU64ToI64, "convertU64ToI64");
+function convertU128ToI128(value) {
+  chunkMDFSBU5W_cjs.assertU128(value);
+  if (value > chunkMDFSBU5W_cjs.I128_MAX) {
+    throw new ConversionError(`Value exceeds I128 maximum`, {
+      sourceValue: value,
+      sourceType: "U128",
+      targetType: "I128",
+      reason: `Value must be <= 2^127 - 1`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU128ToI128, "convertU128ToI128");
+function convertU256ToI256(value) {
+  chunkMDFSBU5W_cjs.assertU256(value);
+  if (value > chunkMDFSBU5W_cjs.I256_MAX) {
+    throw new ConversionError(`Value exceeds I256 maximum`, {
+      sourceValue: value,
+      sourceType: "U256",
+      targetType: "I256",
+      reason: `Value must be <= 2^255 - 1`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU256ToI256, "convertU256ToI256");
+function convertU512ToI512(value) {
+  chunkMDFSBU5W_cjs.assertU512(value);
+  if (value > chunkMDFSBU5W_cjs.I512_MAX) {
+    throw new ConversionError(`Value exceeds I512 maximum`, {
+      sourceValue: value,
+      sourceType: "U512",
+      targetType: "I512",
+      reason: `Value must be <= 2^511 - 1`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI512(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU512ToI512, "convertU512ToI512");
+function convertU1024ToI1024(value) {
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  if (value > chunkMDFSBU5W_cjs.I1024_MAX) {
+    throw new ConversionError(`Value exceeds I1024 maximum`, {
+      sourceValue: value,
+      sourceType: "U1024",
+      targetType: "I1024",
+      reason: `Value must be <= 2^1023 - 1`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertI1024(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU1024ToI1024, "convertU1024ToI1024");
+function convertU8LeBytesToU8BeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU8LeBytes(value);
+  const result = new Uint8Array(value);
+  chunkMDFSBU5W_cjs.assertU8BeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(convertU8LeBytesToU8BeBytes, "convertU8LeBytesToU8BeBytes");
+function convertU8BeBytesToU8LeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU8BeBytes(value);
+  const result = new Uint8Array(value);
+  chunkMDFSBU5W_cjs.assertU8LeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(convertU8BeBytesToU8LeBytes, "convertU8BeBytesToU8LeBytes");
+function convertU16LeBytesToU16BeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU16LeBytes(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U16_BYTE_LENGTH);
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U16_BYTE_LENGTH; index++) {
+    result[index] = value[chunkMDFSBU5W_cjs.U16_BYTE_LENGTH - 1 - index];
+  }
+  chunkMDFSBU5W_cjs.assertU16BeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(convertU16LeBytesToU16BeBytes, "convertU16LeBytesToU16BeBytes");
+function convertU16BeBytesToU16LeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU16BeBytes(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U16_BYTE_LENGTH);
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U16_BYTE_LENGTH; index++) {
+    result[index] = value[chunkMDFSBU5W_cjs.U16_BYTE_LENGTH - 1 - index];
+  }
+  chunkMDFSBU5W_cjs.assertU16LeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(convertU16BeBytesToU16LeBytes, "convertU16BeBytesToU16LeBytes");
+function convertU32LeBytesToU32BeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU32LeBytes(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U32_BYTE_LENGTH);
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U32_BYTE_LENGTH; index++) {
+    result[index] = value[chunkMDFSBU5W_cjs.U32_BYTE_LENGTH - 1 - index];
+  }
+  chunkMDFSBU5W_cjs.assertU32BeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(convertU32LeBytesToU32BeBytes, "convertU32LeBytesToU32BeBytes");
+function convertU32BeBytesToU32LeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU32BeBytes(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U32_BYTE_LENGTH);
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U32_BYTE_LENGTH; index++) {
+    result[index] = value[chunkMDFSBU5W_cjs.U32_BYTE_LENGTH - 1 - index];
+  }
+  chunkMDFSBU5W_cjs.assertU32LeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(convertU32BeBytesToU32LeBytes, "convertU32BeBytesToU32LeBytes");
+function convertU64LeBytesToU64BeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU64LeBytes(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U64_BYTE_LENGTH);
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U64_BYTE_LENGTH; index++) {
+    result[index] = value[chunkMDFSBU5W_cjs.U64_BYTE_LENGTH - 1 - index];
+  }
+  chunkMDFSBU5W_cjs.assertU64BeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(convertU64LeBytesToU64BeBytes, "convertU64LeBytesToU64BeBytes");
+function convertU64BeBytesToU64LeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU64BeBytes(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U64_BYTE_LENGTH);
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U64_BYTE_LENGTH; index++) {
+    result[index] = value[chunkMDFSBU5W_cjs.U64_BYTE_LENGTH - 1 - index];
+  }
+  chunkMDFSBU5W_cjs.assertU64LeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(convertU64BeBytesToU64LeBytes, "convertU64BeBytesToU64LeBytes");
+function convertU128LeBytesToU128BeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU128LeBytes(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U128_BYTE_LENGTH);
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U128_BYTE_LENGTH; index++) {
+    result[index] = value[chunkMDFSBU5W_cjs.U128_BYTE_LENGTH - 1 - index];
+  }
+  chunkMDFSBU5W_cjs.assertU128BeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(convertU128LeBytesToU128BeBytes, "convertU128LeBytesToU128BeBytes");
+function convertU128BeBytesToU128LeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU128BeBytes(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U128_BYTE_LENGTH);
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U128_BYTE_LENGTH; index++) {
+    result[index] = value[chunkMDFSBU5W_cjs.U128_BYTE_LENGTH - 1 - index];
+  }
+  chunkMDFSBU5W_cjs.assertU128LeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(convertU128BeBytesToU128LeBytes, "convertU128BeBytesToU128LeBytes");
+function convertU256LeBytesToU256BeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU256LeBytes(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U256_BYTE_LENGTH);
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U256_BYTE_LENGTH; index++) {
+    result[index] = value[chunkMDFSBU5W_cjs.U256_BYTE_LENGTH - 1 - index];
+  }
+  chunkMDFSBU5W_cjs.assertU256BeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(convertU256LeBytesToU256BeBytes, "convertU256LeBytesToU256BeBytes");
+function convertU256BeBytesToU256LeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU256BeBytes(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U256_BYTE_LENGTH);
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U256_BYTE_LENGTH; index++) {
+    result[index] = value[chunkMDFSBU5W_cjs.U256_BYTE_LENGTH - 1 - index];
+  }
+  chunkMDFSBU5W_cjs.assertU256LeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(convertU256BeBytesToU256LeBytes, "convertU256BeBytesToU256LeBytes");
+function convertU512LeBytesToU512BeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU512LeBytes(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U512_BYTE_LENGTH);
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U512_BYTE_LENGTH; index++) {
+    result[index] = value[chunkMDFSBU5W_cjs.U512_BYTE_LENGTH - 1 - index];
+  }
+  chunkMDFSBU5W_cjs.assertU512BeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(convertU512LeBytesToU512BeBytes, "convertU512LeBytesToU512BeBytes");
+function convertU512BeBytesToU512LeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU512BeBytes(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U512_BYTE_LENGTH);
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U512_BYTE_LENGTH; index++) {
+    result[index] = value[chunkMDFSBU5W_cjs.U512_BYTE_LENGTH - 1 - index];
+  }
+  chunkMDFSBU5W_cjs.assertU512LeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(convertU512BeBytesToU512LeBytes, "convertU512BeBytesToU512LeBytes");
+function convertU1024LeBytesToU1024BeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU1024LeBytes(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U1024_BYTE_LENGTH);
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U1024_BYTE_LENGTH; index++) {
+    result[index] = value[chunkMDFSBU5W_cjs.U1024_BYTE_LENGTH - 1 - index];
+  }
+  chunkMDFSBU5W_cjs.assertU1024BeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(convertU1024LeBytesToU1024BeBytes, "convertU1024LeBytesToU1024BeBytes");
+function convertU1024BeBytesToU1024LeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU1024BeBytes(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U1024_BYTE_LENGTH);
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U1024_BYTE_LENGTH; index++) {
+    result[index] = value[chunkMDFSBU5W_cjs.U1024_BYTE_LENGTH - 1 - index];
+  }
+  chunkMDFSBU5W_cjs.assertU1024LeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(convertU1024BeBytesToU1024LeBytes, "convertU1024BeBytesToU1024LeBytes");
+function encodeU8ToU8LeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU8(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U8_BYTE_LENGTH);
+  result[0] = Number(value);
+  chunkMDFSBU5W_cjs.assertU8LeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(encodeU8ToU8LeBytes, "encodeU8ToU8LeBytes");
+function encodeU8ToU8BeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU8(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U8_BYTE_LENGTH);
+  result[0] = Number(value);
+  chunkMDFSBU5W_cjs.assertU8BeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(encodeU8ToU8BeBytes, "encodeU8ToU8BeBytes");
+function encodeU16ToU16LeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU16(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U16_BYTE_LENGTH);
+  let temporary = value;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U16_BYTE_LENGTH; index++) {
+    result[index] = Number(temporary & 0xffn);
+    temporary >>= 8n;
+  }
+  chunkMDFSBU5W_cjs.assertU16LeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(encodeU16ToU16LeBytes, "encodeU16ToU16LeBytes");
+function encodeU16ToU16BeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU16(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U16_BYTE_LENGTH);
+  let temporary = value;
+  for (let index = chunkMDFSBU5W_cjs.U16_BYTE_LENGTH - 1; index >= 0; index--) {
+    result[index] = Number(temporary & 0xffn);
+    temporary >>= 8n;
+  }
+  chunkMDFSBU5W_cjs.assertU16BeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(encodeU16ToU16BeBytes, "encodeU16ToU16BeBytes");
+function encodeU32ToU32LeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU32(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U32_BYTE_LENGTH);
+  let temporary = value;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U32_BYTE_LENGTH; index++) {
+    result[index] = Number(temporary & 0xffn);
+    temporary >>= 8n;
+  }
+  chunkMDFSBU5W_cjs.assertU32LeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(encodeU32ToU32LeBytes, "encodeU32ToU32LeBytes");
+function encodeU32ToU32BeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU32(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U32_BYTE_LENGTH);
+  let temporary = value;
+  for (let index = chunkMDFSBU5W_cjs.U32_BYTE_LENGTH - 1; index >= 0; index--) {
+    result[index] = Number(temporary & 0xffn);
+    temporary >>= 8n;
+  }
+  chunkMDFSBU5W_cjs.assertU32BeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(encodeU32ToU32BeBytes, "encodeU32ToU32BeBytes");
+function encodeU64ToU64LeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU64(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U64_BYTE_LENGTH);
+  let temporary = value;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U64_BYTE_LENGTH; index++) {
+    result[index] = Number(temporary & 0xffn);
+    temporary >>= 8n;
+  }
+  chunkMDFSBU5W_cjs.assertU64LeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(encodeU64ToU64LeBytes, "encodeU64ToU64LeBytes");
+function encodeU64ToU64BeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU64(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U64_BYTE_LENGTH);
+  let temporary = value;
+  for (let index = chunkMDFSBU5W_cjs.U64_BYTE_LENGTH - 1; index >= 0; index--) {
+    result[index] = Number(temporary & 0xffn);
+    temporary >>= 8n;
+  }
+  chunkMDFSBU5W_cjs.assertU64BeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(encodeU64ToU64BeBytes, "encodeU64ToU64BeBytes");
+function encodeU128ToU128LeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU128(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U128_BYTE_LENGTH);
+  let temporary = value;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U128_BYTE_LENGTH; index++) {
+    result[index] = Number(temporary & 0xffn);
+    temporary >>= 8n;
+  }
+  chunkMDFSBU5W_cjs.assertU128LeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(encodeU128ToU128LeBytes, "encodeU128ToU128LeBytes");
+function encodeU128ToU128BeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU128(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U128_BYTE_LENGTH);
+  let temporary = value;
+  for (let index = chunkMDFSBU5W_cjs.U128_BYTE_LENGTH - 1; index >= 0; index--) {
+    result[index] = Number(temporary & 0xffn);
+    temporary >>= 8n;
+  }
+  chunkMDFSBU5W_cjs.assertU128BeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(encodeU128ToU128BeBytes, "encodeU128ToU128BeBytes");
+function encodeU256ToU256LeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU256(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U256_BYTE_LENGTH);
+  let temporary = value;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U256_BYTE_LENGTH; index++) {
+    result[index] = Number(temporary & 0xffn);
+    temporary >>= 8n;
+  }
+  chunkMDFSBU5W_cjs.assertU256LeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(encodeU256ToU256LeBytes, "encodeU256ToU256LeBytes");
+function encodeU256ToU256BeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU256(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U256_BYTE_LENGTH);
+  let temporary = value;
+  for (let index = chunkMDFSBU5W_cjs.U256_BYTE_LENGTH - 1; index >= 0; index--) {
+    result[index] = Number(temporary & 0xffn);
+    temporary >>= 8n;
+  }
+  chunkMDFSBU5W_cjs.assertU256BeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(encodeU256ToU256BeBytes, "encodeU256ToU256BeBytes");
+function encodeU512ToU512LeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU512(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U512_BYTE_LENGTH);
+  let temporary = value;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U512_BYTE_LENGTH; index++) {
+    result[index] = Number(temporary & 0xffn);
+    temporary >>= 8n;
+  }
+  chunkMDFSBU5W_cjs.assertU512LeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(encodeU512ToU512LeBytes, "encodeU512ToU512LeBytes");
+function encodeU512ToU512BeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU512(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U512_BYTE_LENGTH);
+  let temporary = value;
+  for (let index = chunkMDFSBU5W_cjs.U512_BYTE_LENGTH - 1; index >= 0; index--) {
+    result[index] = Number(temporary & 0xffn);
+    temporary >>= 8n;
+  }
+  chunkMDFSBU5W_cjs.assertU512BeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(encodeU512ToU512BeBytes, "encodeU512ToU512BeBytes");
+function encodeU1024ToU1024LeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U1024_BYTE_LENGTH);
+  let temporary = value;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U1024_BYTE_LENGTH; index++) {
+    result[index] = Number(temporary & 0xffn);
+    temporary >>= 8n;
+  }
+  chunkMDFSBU5W_cjs.assertU1024LeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(encodeU1024ToU1024LeBytes, "encodeU1024ToU1024LeBytes");
+function encodeU1024ToU1024BeBytes(value) {
+  chunkMDFSBU5W_cjs.assertU1024(value);
+  const result = new Uint8Array(chunkMDFSBU5W_cjs.U1024_BYTE_LENGTH);
+  let temporary = value;
+  for (let index = chunkMDFSBU5W_cjs.U1024_BYTE_LENGTH - 1; index >= 0; index--) {
+    result[index] = Number(temporary & 0xffn);
+    temporary >>= 8n;
+  }
+  chunkMDFSBU5W_cjs.assertU1024BeBytes(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(encodeU1024ToU1024BeBytes, "encodeU1024ToU1024BeBytes");
+function decodeU8LeBytesToU8(value) {
+  chunkMDFSBU5W_cjs.assertU8LeBytes(value);
+  const result = BigInt(value[0]);
+  chunkMDFSBU5W_cjs.assertU8(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(decodeU8LeBytesToU8, "decodeU8LeBytesToU8");
+function decodeU8BeBytesToU8(value) {
+  chunkMDFSBU5W_cjs.assertU8BeBytes(value);
+  const result = BigInt(value[0]);
+  chunkMDFSBU5W_cjs.assertU8(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(decodeU8BeBytesToU8, "decodeU8BeBytesToU8");
+function decodeU16LeBytesToU16(value) {
+  chunkMDFSBU5W_cjs.assertU16LeBytes(value);
+  let result = 0n;
+  for (let index = chunkMDFSBU5W_cjs.U16_BYTE_LENGTH - 1; index >= 0; index--) {
+    result = result << 8n | BigInt(value[index]);
+  }
+  chunkMDFSBU5W_cjs.assertU16(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(decodeU16LeBytesToU16, "decodeU16LeBytesToU16");
+function decodeU16BeBytesToU16(value) {
+  chunkMDFSBU5W_cjs.assertU16BeBytes(value);
+  let result = 0n;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U16_BYTE_LENGTH; index++) {
+    result = result << 8n | BigInt(value[index]);
+  }
+  chunkMDFSBU5W_cjs.assertU16(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(decodeU16BeBytesToU16, "decodeU16BeBytesToU16");
+function decodeU32LeBytesToU32(value) {
+  chunkMDFSBU5W_cjs.assertU32LeBytes(value);
+  let result = 0n;
+  for (let index = chunkMDFSBU5W_cjs.U32_BYTE_LENGTH - 1; index >= 0; index--) {
+    result = result << 8n | BigInt(value[index]);
+  }
+  chunkMDFSBU5W_cjs.assertU32(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(decodeU32LeBytesToU32, "decodeU32LeBytesToU32");
+function decodeU32BeBytesToU32(value) {
+  chunkMDFSBU5W_cjs.assertU32BeBytes(value);
+  let result = 0n;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U32_BYTE_LENGTH; index++) {
+    result = result << 8n | BigInt(value[index]);
+  }
+  chunkMDFSBU5W_cjs.assertU32(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(decodeU32BeBytesToU32, "decodeU32BeBytesToU32");
+function decodeU64LeBytesToU64(value) {
+  chunkMDFSBU5W_cjs.assertU64LeBytes(value);
+  let result = 0n;
+  for (let index = chunkMDFSBU5W_cjs.U64_BYTE_LENGTH - 1; index >= 0; index--) {
+    result = result << 8n | BigInt(value[index]);
+  }
+  chunkMDFSBU5W_cjs.assertU64(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(decodeU64LeBytesToU64, "decodeU64LeBytesToU64");
+function decodeU64BeBytesToU64(value) {
+  chunkMDFSBU5W_cjs.assertU64BeBytes(value);
+  let result = 0n;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U64_BYTE_LENGTH; index++) {
+    result = result << 8n | BigInt(value[index]);
+  }
+  chunkMDFSBU5W_cjs.assertU64(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(decodeU64BeBytesToU64, "decodeU64BeBytesToU64");
+function decodeU128LeBytesToU128(value) {
+  chunkMDFSBU5W_cjs.assertU128LeBytes(value);
+  let result = 0n;
+  for (let index = chunkMDFSBU5W_cjs.U128_BYTE_LENGTH - 1; index >= 0; index--) {
+    result = result << 8n | BigInt(value[index]);
+  }
+  chunkMDFSBU5W_cjs.assertU128(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(decodeU128LeBytesToU128, "decodeU128LeBytesToU128");
+function decodeU128BeBytesToU128(value) {
+  chunkMDFSBU5W_cjs.assertU128BeBytes(value);
+  let result = 0n;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U128_BYTE_LENGTH; index++) {
+    result = result << 8n | BigInt(value[index]);
+  }
+  chunkMDFSBU5W_cjs.assertU128(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(decodeU128BeBytesToU128, "decodeU128BeBytesToU128");
+function decodeU256LeBytesToU256(value) {
+  chunkMDFSBU5W_cjs.assertU256LeBytes(value);
+  let result = 0n;
+  for (let index = chunkMDFSBU5W_cjs.U256_BYTE_LENGTH - 1; index >= 0; index--) {
+    result = result << 8n | BigInt(value[index]);
+  }
+  chunkMDFSBU5W_cjs.assertU256(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(decodeU256LeBytesToU256, "decodeU256LeBytesToU256");
+function decodeU256BeBytesToU256(value) {
+  chunkMDFSBU5W_cjs.assertU256BeBytes(value);
+  let result = 0n;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U256_BYTE_LENGTH; index++) {
+    result = result << 8n | BigInt(value[index]);
+  }
+  chunkMDFSBU5W_cjs.assertU256(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(decodeU256BeBytesToU256, "decodeU256BeBytesToU256");
+function decodeU512LeBytesToU512(value) {
+  chunkMDFSBU5W_cjs.assertU512LeBytes(value);
+  let result = 0n;
+  for (let index = chunkMDFSBU5W_cjs.U512_BYTE_LENGTH - 1; index >= 0; index--) {
+    result = result << 8n | BigInt(value[index]);
+  }
+  chunkMDFSBU5W_cjs.assertU512(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(decodeU512LeBytesToU512, "decodeU512LeBytesToU512");
+function decodeU512BeBytesToU512(value) {
+  chunkMDFSBU5W_cjs.assertU512BeBytes(value);
+  let result = 0n;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U512_BYTE_LENGTH; index++) {
+    result = result << 8n | BigInt(value[index]);
+  }
+  chunkMDFSBU5W_cjs.assertU512(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(decodeU512BeBytesToU512, "decodeU512BeBytesToU512");
+function decodeU1024LeBytesToU1024(value) {
+  chunkMDFSBU5W_cjs.assertU1024LeBytes(value);
+  let result = 0n;
+  for (let index = chunkMDFSBU5W_cjs.U1024_BYTE_LENGTH - 1; index >= 0; index--) {
+    result = result << 8n | BigInt(value[index]);
+  }
+  chunkMDFSBU5W_cjs.assertU1024(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(decodeU1024LeBytesToU1024, "decodeU1024LeBytesToU1024");
+function decodeU1024BeBytesToU1024(value) {
+  chunkMDFSBU5W_cjs.assertU1024BeBytes(value);
+  let result = 0n;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U1024_BYTE_LENGTH; index++) {
+    result = result << 8n | BigInt(value[index]);
+  }
+  chunkMDFSBU5W_cjs.assertU1024(result);
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(decodeU1024BeBytesToU1024, "decodeU1024BeBytesToU1024");
+
+// src/common/converters/cryptography.ts
+function convertU256ToBn254FieldElement(value) {
+  chunkMDFSBU5W_cjs.assertU256(value);
+  if (value >= chunkMDFSBU5W_cjs.BN254_FIELD_PRIME) {
+    throw new ConversionError(`Value exceeds BN254 field prime`, {
+      sourceValue: value,
+      sourceType: "U256",
+      targetType: "Bn254FieldElement",
+      reason: `Value must be < ${String(chunkMDFSBU5W_cjs.BN254_FIELD_PRIME)}`
+    });
+  }
+  chunkMDFSBU5W_cjs.assertBn254FieldElement(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU256ToBn254FieldElement, "convertU256ToBn254FieldElement");
+function convertBn254FieldElementToU256(value) {
+  chunkMDFSBU5W_cjs.assertBn254FieldElement(value);
+  chunkMDFSBU5W_cjs.assertU256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertBn254FieldElementToU256, "convertBn254FieldElementToU256");
+function convertU256ToCurve25519FieldElement(value) {
+  chunkMDFSBU5W_cjs.assertU256(value);
+  if (value >= chunkMDFSBU5W_cjs.CURVE25519_FIELD_PRIME) {
+    throw new ConversionError(`Value exceeds Curve25519 field prime`, {
+      sourceValue: value,
+      sourceType: "U256",
+      targetType: "Curve25519FieldElement",
+      reason: "Value must be < 2^255 - 19"
+    });
+  }
+  chunkMDFSBU5W_cjs.assertCurve25519FieldElement(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU256ToCurve25519FieldElement, "convertU256ToCurve25519FieldElement");
+function convertCurve25519FieldElementToU256(value) {
+  chunkMDFSBU5W_cjs.assertCurve25519FieldElement(value);
+  chunkMDFSBU5W_cjs.assertU256(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertCurve25519FieldElementToU256, "convertCurve25519FieldElementToU256");
+function convertBn254FieldElementToCurve25519FieldElement(value) {
+  chunkMDFSBU5W_cjs.assertBn254FieldElement(value);
+  if (value >= chunkMDFSBU5W_cjs.CURVE25519_FIELD_PRIME) {
+    throw new ConversionError(`BN254 field element exceeds Curve25519 field prime`, {
+      sourceValue: value,
+      sourceType: "Bn254FieldElement",
+      targetType: "Curve25519FieldElement",
+      reason: "Value must be < 2^255 - 19"
+    });
+  }
+  chunkMDFSBU5W_cjs.assertCurve25519FieldElement(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertBn254FieldElementToCurve25519FieldElement, "convertBn254FieldElementToCurve25519FieldElement");
+function convertCurve25519FieldElementToBn254FieldElement(value) {
+  chunkMDFSBU5W_cjs.assertCurve25519FieldElement(value);
+  chunkMDFSBU5W_cjs.assertBn254FieldElement(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertCurve25519FieldElementToBn254FieldElement, "convertCurve25519FieldElementToBn254FieldElement");
+function convertBn254FieldElementToPoseidonPlaintext(value) {
+  chunkMDFSBU5W_cjs.assertBn254FieldElement(value);
+  chunkMDFSBU5W_cjs.assertPoseidonPlaintext(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertBn254FieldElementToPoseidonPlaintext, "convertBn254FieldElementToPoseidonPlaintext");
+function convertBn254FieldElementToPoseidonHash(value) {
+  chunkMDFSBU5W_cjs.assertBn254FieldElement(value);
+  chunkMDFSBU5W_cjs.assertPoseidonHash(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertBn254FieldElementToPoseidonHash, "convertBn254FieldElementToPoseidonHash");
+function convertBn254FieldElementToPoseidonKey(value) {
+  chunkMDFSBU5W_cjs.assertBn254FieldElement(value);
+  chunkMDFSBU5W_cjs.assertPoseidonKey(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertBn254FieldElementToPoseidonKey, "convertBn254FieldElementToPoseidonKey");
+function convertBn254FieldElementToPoseidonCiphertext(value) {
+  chunkMDFSBU5W_cjs.assertBn254FieldElement(value);
+  chunkMDFSBU5W_cjs.assertPoseidonCiphertext(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertBn254FieldElementToPoseidonCiphertext, "convertBn254FieldElementToPoseidonCiphertext");
+function convertPoseidonPlaintextToBn254FieldElement(value) {
+  chunkMDFSBU5W_cjs.assertPoseidonPlaintext(value);
+  chunkMDFSBU5W_cjs.assertBn254FieldElement(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertPoseidonPlaintextToBn254FieldElement, "convertPoseidonPlaintextToBn254FieldElement");
+function convertPoseidonHashToBn254FieldElement(value) {
+  chunkMDFSBU5W_cjs.assertPoseidonHash(value);
+  chunkMDFSBU5W_cjs.assertBn254FieldElement(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertPoseidonHashToBn254FieldElement, "convertPoseidonHashToBn254FieldElement");
+function convertPoseidonKeyToBn254FieldElement(value) {
+  chunkMDFSBU5W_cjs.assertPoseidonKey(value);
+  chunkMDFSBU5W_cjs.assertBn254FieldElement(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertPoseidonKeyToBn254FieldElement, "convertPoseidonKeyToBn254FieldElement");
+function convertPoseidonCiphertextToBn254FieldElement(value) {
+  chunkMDFSBU5W_cjs.assertPoseidonCiphertext(value);
+  chunkMDFSBU5W_cjs.assertBn254FieldElement(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertPoseidonCiphertextToBn254FieldElement, "convertPoseidonCiphertextToBn254FieldElement");
+function convertCurve25519FieldElementToRcPlaintext(value) {
+  chunkMDFSBU5W_cjs.assertCurve25519FieldElement(value);
+  chunkMDFSBU5W_cjs.assertRcPlaintext(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertCurve25519FieldElementToRcPlaintext, "convertCurve25519FieldElementToRcPlaintext");
+function convertCurve25519FieldElementToRcCiphertext(value) {
+  chunkMDFSBU5W_cjs.assertCurve25519FieldElement(value);
+  chunkMDFSBU5W_cjs.assertRcCiphertext(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertCurve25519FieldElementToRcCiphertext, "convertCurve25519FieldElementToRcCiphertext");
+function convertCurve25519FieldElementToRcKey(value) {
+  chunkMDFSBU5W_cjs.assertCurve25519FieldElement(value);
+  chunkMDFSBU5W_cjs.assertRcKey(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertCurve25519FieldElementToRcKey, "convertCurve25519FieldElementToRcKey");
+function convertCurve25519FieldElementToRcCounter(value) {
+  chunkMDFSBU5W_cjs.assertCurve25519FieldElement(value);
+  chunkMDFSBU5W_cjs.assertRcCounter(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertCurve25519FieldElementToRcCounter, "convertCurve25519FieldElementToRcCounter");
+function convertRcPlaintextToCurve25519FieldElement(value) {
+  chunkMDFSBU5W_cjs.assertRcPlaintext(value);
+  chunkMDFSBU5W_cjs.assertCurve25519FieldElement(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertRcPlaintextToCurve25519FieldElement, "convertRcPlaintextToCurve25519FieldElement");
+function convertRcCiphertextToCurve25519FieldElement(value) {
+  chunkMDFSBU5W_cjs.assertRcCiphertext(value);
+  chunkMDFSBU5W_cjs.assertCurve25519FieldElement(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertRcCiphertextToCurve25519FieldElement, "convertRcCiphertextToCurve25519FieldElement");
+function convertRcKeyToCurve25519FieldElement(value) {
+  chunkMDFSBU5W_cjs.assertRcKey(value);
+  chunkMDFSBU5W_cjs.assertCurve25519FieldElement(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertRcKeyToCurve25519FieldElement, "convertRcKeyToCurve25519FieldElement");
+function convertRcCounterToCurve25519FieldElement(value) {
+  chunkMDFSBU5W_cjs.assertRcCounter(value);
+  chunkMDFSBU5W_cjs.assertCurve25519FieldElement(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertRcCounterToCurve25519FieldElement, "convertRcCounterToCurve25519FieldElement");
+function convertU128ToRcEncryptionNonce(value) {
+  chunkMDFSBU5W_cjs.assertU128(value);
+  chunkMDFSBU5W_cjs.assertRcEncryptionNonce(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertU128ToRcEncryptionNonce, "convertU128ToRcEncryptionNonce");
+function convertRcEncryptionNonceToU128(value) {
+  chunkMDFSBU5W_cjs.assertRcEncryptionNonce(value);
+  chunkMDFSBU5W_cjs.assertU128(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertRcEncryptionNonceToU128, "convertRcEncryptionNonceToU128");
+function convertX25519BytesToX25519PrivateKey(value) {
+  chunkMDFSBU5W_cjs.assertX25519Bytes(value);
+  chunkMDFSBU5W_cjs.assertX25519PrivateKey(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertX25519BytesToX25519PrivateKey, "convertX25519BytesToX25519PrivateKey");
+function convertX25519BytesToX25519PublicKey(value) {
+  chunkMDFSBU5W_cjs.assertX25519Bytes(value);
+  chunkMDFSBU5W_cjs.assertX25519PublicKey(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertX25519BytesToX25519PublicKey, "convertX25519BytesToX25519PublicKey");
+function convertX25519BytesToSharedSecret(value) {
+  chunkMDFSBU5W_cjs.assertX25519Bytes(value);
+  chunkMDFSBU5W_cjs.assertSharedSecret(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertX25519BytesToSharedSecret, "convertX25519BytesToSharedSecret");
+function convertX25519PrivateKeyToX25519Bytes(value) {
+  chunkMDFSBU5W_cjs.assertX25519PrivateKey(value);
+  chunkMDFSBU5W_cjs.assertX25519Bytes(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertX25519PrivateKeyToX25519Bytes, "convertX25519PrivateKeyToX25519Bytes");
+function convertX25519PublicKeyToX25519Bytes(value) {
+  chunkMDFSBU5W_cjs.assertX25519PublicKey(value);
+  chunkMDFSBU5W_cjs.assertX25519Bytes(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertX25519PublicKeyToX25519Bytes, "convertX25519PublicKeyToX25519Bytes");
+function convertSharedSecretToX25519Bytes(value) {
+  chunkMDFSBU5W_cjs.assertSharedSecret(value);
+  chunkMDFSBU5W_cjs.assertX25519Bytes(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(convertSharedSecretToX25519Bytes, "convertSharedSecretToX25519Bytes");
+function splitU256IntoTwoU128s(value) {
+  chunkMDFSBU5W_cjs.assertU256(value);
+  const U128_MAX2 = (1n << 128n) - 1n;
+  const lowValue = value & U128_MAX2;
+  chunkMDFSBU5W_cjs.assertU128(lowValue);
+  const highValue = value >> 128n;
+  chunkMDFSBU5W_cjs.assertU128(highValue);
+  return { low: lowValue, high: highValue };
+}
+chunkPK6SKIKE_cjs.__name(splitU256IntoTwoU128s, "splitU256IntoTwoU128s");
+function splitX25519PublicKeyIntoTwoU128s(key) {
+  chunkMDFSBU5W_cjs.assertX25519PublicKey(key);
+  let low = 0n;
+  for (let index = chunkMDFSBU5W_cjs.U128_BYTE_LENGTH - 1; index >= 0; index--) {
+    low = low << 8n | BigInt(key[index]);
+  }
+  let high = 0n;
+  for (let index = chunkMDFSBU5W_cjs.U256_BYTE_LENGTH - 1; index >= chunkMDFSBU5W_cjs.U128_BYTE_LENGTH; index--) {
+    high = high << 8n | BigInt(key[index]);
+  }
+  chunkMDFSBU5W_cjs.assertU128(low);
+  chunkMDFSBU5W_cjs.assertU128(high);
+  return { low, high };
+}
+chunkPK6SKIKE_cjs.__name(splitX25519PublicKeyIntoTwoU128s, "splitX25519PublicKeyIntoTwoU128s");
+function convertU256ToBase85Limbs(value) {
+  chunkMDFSBU5W_cjs.assertU256(value);
+  const BASE85_MASK = (1n << 85n) - 1n;
+  const lowValue = value & BASE85_MASK;
+  chunkMDFSBU5W_cjs.assertBase85Limb(lowValue);
+  const middleValue = value >> 85n & BASE85_MASK;
+  chunkMDFSBU5W_cjs.assertBase85Limb(middleValue);
+  const highValue = value >> 170n;
+  chunkMDFSBU5W_cjs.assertBase85Limb(highValue);
+  return {
+    low: lowValue,
+    middle: middleValue,
+    high: highValue
+  };
+}
+chunkPK6SKIKE_cjs.__name(convertU256ToBase85Limbs, "convertU256ToBase85Limbs");
+
+// src/common/math-utils.ts
+function generateRandomU128() {
+  const bytes = new Uint8Array(chunkMDFSBU5W_cjs.U128_BYTE_LENGTH);
+  crypto.getRandomValues(bytes);
+  let result = 0n;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U128_BYTE_LENGTH; index++) {
+    result |= BigInt(bytes[index]) << BigInt(index * 8);
+  }
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(generateRandomU128, "generateRandomU128");
+function generateRandomU64() {
+  const bytes = new Uint8Array(chunkMDFSBU5W_cjs.U64_BYTE_LENGTH);
+  crypto.getRandomValues(bytes);
+  let result = 0n;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U64_BYTE_LENGTH; index++) {
+    result |= BigInt(bytes[index]) << BigInt(index * 8);
+  }
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(generateRandomU64, "generateRandomU64");
+function generateRandomU256() {
+  const bytes = new Uint8Array(chunkMDFSBU5W_cjs.U256_BYTE_LENGTH);
+  crypto.getRandomValues(bytes);
+  let result = 0n;
+  for (let index = 0; index < chunkMDFSBU5W_cjs.U256_BYTE_LENGTH; index++) {
+    result |= BigInt(bytes[index]) << BigInt(index * 8);
+  }
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(generateRandomU256, "generateRandomU256");
+function bigintToBinaryArrayLSB(value, length) {
+  const result = [];
+  let remaining = value;
+  for (let index = 0; index < length; index++) {
+    result.push(Number(remaining & 1n));
+    remaining >>= 1n;
+  }
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(bigintToBinaryArrayLSB, "bigintToBinaryArrayLSB");
+
+// src/common/arcium.ts
+function generateRandomNonce() {
+  const nonce = generateRandomU128();
+  chunkMDFSBU5W_cjs.assertRcEncryptionNonce(nonce);
+  return nonce;
+}
+chunkPK6SKIKE_cjs.__name(generateRandomNonce, "generateRandomNonce");
+function getRandomComputationOffset() {
+  return generateRandomU64();
+}
+chunkPK6SKIKE_cjs.__name(getRandomComputationOffset, "getRandomComputationOffset");
+var cachedAddressEncoder = null;
+function getEncoder() {
+  cachedAddressEncoder ??= kit.getAddressEncoder();
+  return cachedAddressEncoder;
+}
+chunkPK6SKIKE_cjs.__name(getEncoder, "getEncoder");
+function splitAddressToLowHigh(address2) {
+  const encoder = getEncoder();
+  const addressBytes = encoder.encode(address2);
+  const lowBytes = createU128LeBytes(addressBytes.slice(0, 16));
+  const low = decodeU128LeBytesToU128(lowBytes);
+  const highBytes = createU128LeBytes(addressBytes.slice(16, 32));
+  const high = decodeU128LeBytesToU128(highBytes);
+  return { low, high };
+}
+chunkPK6SKIKE_cjs.__name(splitAddressToLowHigh, "splitAddressToLowHigh");
+function structSeed(name) {
+  return sha2_js.sha256(new TextEncoder().encode(name));
+}
+chunkPK6SKIKE_cjs.__name(structSeed, "structSeed");
+var MIXER_TREE_SEED = structSeed("MixerTree");
+var CONF_UTXO_BURNER_SEED = structSeed("ConfidentialUtxoBurner");
+var PUB_UTXO_BURNER_SEED = structSeed("PublicUtxoBurner");
+var TREAP_SEED = structSeed("Treap");
+async function getMixerTreeAddress(index, umbraProgram) {
+  const [pda] = await kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [MIXER_TREE_SEED, encodeU128ToU128LeBytes(index)]
+  });
+  return pda;
+}
+chunkPK6SKIKE_cjs.__name(getMixerTreeAddress, "getMixerTreeAddress");
+async function getActiveMixerTreeAddress(umbraProgram) {
+  return getMixerTreeAddress(0n, umbraProgram);
+}
+chunkPK6SKIKE_cjs.__name(getActiveMixerTreeAddress, "getActiveMixerTreeAddress");
+async function getConfUtxoBurnerPda(relayerAddress, ephemeralAddress, burnerAccountOffset, umbraProgram) {
+  const addressEncoder = kit.getAddressEncoder();
+  const [pda] = await kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [
+      CONF_UTXO_BURNER_SEED,
+      addressEncoder.encode(relayerAddress),
+      addressEncoder.encode(ephemeralAddress),
+      codama.getAccountOffsetEncoder().encode({
+        first: BigInt(burnerAccountOffset)
+      })
+    ]
+  });
+  return pda;
+}
+chunkPK6SKIKE_cjs.__name(getConfUtxoBurnerPda, "getConfUtxoBurnerPda");
+async function getPubUtxoBurnerPda(relayerAddress, ephemeralAddress, burnerAccountOffset, umbraProgram) {
+  const addressEncoder = kit.getAddressEncoder();
+  const [pda] = await kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [
+      PUB_UTXO_BURNER_SEED,
+      addressEncoder.encode(relayerAddress),
+      addressEncoder.encode(ephemeralAddress),
+      codama.getAccountOffsetEncoder().encode({
+        first: BigInt(burnerAccountOffset)
+      })
+    ]
+  });
+  return pda;
+}
+chunkPK6SKIKE_cjs.__name(getPubUtxoBurnerPda, "getPubUtxoBurnerPda");
+async function getTreapPdas(mixerTreeIndex, umbraProgram) {
+  const treapSeedBytes = TREAP_SEED;
+  const indexBytes = encodeU128ToU128LeBytes(mixerTreeIndex);
+  const derivePda = /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(async (variant) => {
+    const [pda] = await kit.getProgramDerivedAddress({
+      programAddress: umbraProgram,
+      seeds: [treapSeedBytes, indexBytes, new Uint8Array([variant])]
+    });
+    return pda;
+  }, "derivePda");
+  const [treap0, treap1, treap2, treap3, treap4] = await Promise.all([
+    derivePda(0),
+    derivePda(1),
+    derivePda(2),
+    derivePda(3),
+    derivePda(4)
+  ]);
+  return { treap0, treap1, treap2, treap3, treap4 };
+}
+chunkPK6SKIKE_cjs.__name(getTreapPdas, "getTreapPdas");
+
+// src/common/pda/user.ts
+var ARCIUM_ENCRYPTED_USER_ACCOUNT_SEED = structSeed("ArciumEncryptedUserAccount");
+var ARCIUM_ENCRYPTED_TOKEN_ACCOUNT_SEED = structSeed("ArciumEncryptedTokenAccount");
+async function getArciumEncryptedUserAccountPda(userPubkey, umbraProgram) {
+  const addressEncoder = kit.getAddressEncoder();
+  const [pda] = await kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [ARCIUM_ENCRYPTED_USER_ACCOUNT_SEED, addressEncoder.encode(userPubkey)]
+  });
+  return pda;
+}
+chunkPK6SKIKE_cjs.__name(getArciumEncryptedUserAccountPda, "getArciumEncryptedUserAccountPda");
+async function getArciumEncryptedTokenAccountPda(userPubkey, mintPubkey, umbraProgram) {
+  const addressEncoder = kit.getAddressEncoder();
+  const [pda] = await kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [
+      ARCIUM_ENCRYPTED_TOKEN_ACCOUNT_SEED,
+      addressEncoder.encode(userPubkey),
+      addressEncoder.encode(mintPubkey)
+    ]
+  });
+  return pda;
+}
+chunkPK6SKIKE_cjs.__name(getArciumEncryptedTokenAccountPda, "getArciumEncryptedTokenAccountPda");
+function getCompDefOffset(instructionName) {
+  const hash = sha2_js.sha256(new TextEncoder().encode(instructionName));
+  const byte0 = hash[0];
+  const byte1 = hash[1];
+  const byte2 = hash[2];
+  const byte3 = hash[3];
+  const offset = byte0 | byte1 << 8 | byte2 << 16 | byte3 << 24;
+  return offset >>> 0;
+}
+chunkPK6SKIKE_cjs.__name(getCompDefOffset, "getCompDefOffset");
+async function getMxeAccountAddress(umbraProgram, arciumProgram) {
+  const [address2] = await kit.getProgramDerivedAddress({
+    programAddress: arciumProgram,
+    seeds: [
+      new TextEncoder().encode(chunkMVKTV3FT_cjs.ARCIUM_MXE_ACCOUNT_SEED),
+      kit.getAddressEncoder().encode(umbraProgram)
+    ]
+  });
+  return address2;
+}
+chunkPK6SKIKE_cjs.__name(getMxeAccountAddress, "getMxeAccountAddress");
+async function getMempoolAccountAddress(arciumProgram, clusterOffset) {
+  chunkMDFSBU5W_cjs.assertU32(BigInt(clusterOffset));
+  const [address2] = await kit.getProgramDerivedAddress({
+    programAddress: arciumProgram,
+    seeds: [
+      new TextEncoder().encode(chunkMVKTV3FT_cjs.ARCIUM_MEMPOOL_SEED),
+      encodeU32ToU32LeBytes(BigInt(clusterOffset))
+    ]
+  });
+  return address2;
+}
+chunkPK6SKIKE_cjs.__name(getMempoolAccountAddress, "getMempoolAccountAddress");
+async function getExecutingPoolAccountAddress(arciumProgram, clusterOffset) {
+  chunkMDFSBU5W_cjs.assertU32(BigInt(clusterOffset));
+  const [address2] = await kit.getProgramDerivedAddress({
+    programAddress: arciumProgram,
+    seeds: [
+      new TextEncoder().encode(chunkMVKTV3FT_cjs.ARCIUM_EXEC_POOL_SEED),
+      encodeU32ToU32LeBytes(BigInt(clusterOffset))
+    ]
+  });
+  return address2;
+}
+chunkPK6SKIKE_cjs.__name(getExecutingPoolAccountAddress, "getExecutingPoolAccountAddress");
+async function getComputationAccountAddress(arciumProgram, clusterOffset, computationOffset) {
+  chunkMDFSBU5W_cjs.assertU32(BigInt(clusterOffset));
+  chunkMDFSBU5W_cjs.assertU64(computationOffset);
+  const [address2] = await kit.getProgramDerivedAddress({
+    programAddress: arciumProgram,
+    seeds: [
+      new TextEncoder().encode(chunkMVKTV3FT_cjs.ARCIUM_COMPUTATION_SEED),
+      encodeU32ToU32LeBytes(BigInt(clusterOffset)),
+      encodeU64ToU64LeBytes(computationOffset)
+    ]
+  });
+  return address2;
+}
+chunkPK6SKIKE_cjs.__name(getComputationAccountAddress, "getComputationAccountAddress");
+async function getCompDefAccountAddress(umbraProgram, arciumProgram, compDefOffset) {
+  chunkMDFSBU5W_cjs.assertU32(BigInt(compDefOffset));
+  const [address2] = await kit.getProgramDerivedAddress({
+    programAddress: arciumProgram,
+    seeds: [
+      new TextEncoder().encode(chunkMVKTV3FT_cjs.ARCIUM_COMP_DEF_SEED),
+      kit.getAddressEncoder().encode(umbraProgram),
+      encodeU32ToU32LeBytes(BigInt(compDefOffset))
+    ]
+  });
+  return address2;
+}
+chunkPK6SKIKE_cjs.__name(getCompDefAccountAddress, "getCompDefAccountAddress");
+async function getClusterAccountAddress(arciumProgram, clusterOffset) {
+  chunkMDFSBU5W_cjs.assertU32(BigInt(clusterOffset));
+  const [address2] = await kit.getProgramDerivedAddress({
+    programAddress: arciumProgram,
+    seeds: [
+      new TextEncoder().encode(chunkMVKTV3FT_cjs.ARCIUM_CLUSTER_SEED),
+      encodeU32ToU32LeBytes(BigInt(clusterOffset))
+    ]
+  });
+  return address2;
+}
+chunkPK6SKIKE_cjs.__name(getClusterAccountAddress, "getClusterAccountAddress");
+async function getArciumAccountAddresses(umbraProgram, arciumProgram, clusterOffset, computationOffset, instructionName) {
+  const compDefOffset = getCompDefOffset(instructionName);
+  const [
+    mxeAccount,
+    mempoolAccount,
+    executingPoolAccount,
+    computationAccount,
+    compDefAccount,
+    // eslint-disable-line unicorn/prevent-abbreviations
+    clusterAccount
+  ] = await Promise.all([
+    getMxeAccountAddress(umbraProgram, arciumProgram),
+    getMempoolAccountAddress(arciumProgram, clusterOffset),
+    getExecutingPoolAccountAddress(arciumProgram, clusterOffset),
+    getComputationAccountAddress(arciumProgram, clusterOffset, computationOffset),
+    getCompDefAccountAddress(umbraProgram, arciumProgram, compDefOffset),
+    getClusterAccountAddress(arciumProgram, clusterOffset)
+  ]);
+  return {
+    mxeAccount,
+    mempoolAccount,
+    executingPoolAccount,
+    computationAccount,
+    compDefAccount,
+    clusterAccount
+  };
+}
+chunkPK6SKIKE_cjs.__name(getArciumAccountAddresses, "getArciumAccountAddresses");
+var ARCIUM_COMPLIANCE_GRANT_SEED = new Uint8Array([
+  112,
+  51,
+  91,
+  80,
+  182,
+  130,
+  183,
+  114,
+  130,
+  126,
+  192,
+  174,
+  103,
+  176,
+  96,
+  111,
+  39,
+  197,
+  11,
+  178,
+  95,
+  176,
+  244,
+  219,
+  178,
+  162,
+  167,
+  166,
+  191,
+  89,
+  196,
+  197
+]);
+var USER_GRANT_VARIANT_SEED = new Uint8Array([
+  184,
+  137,
+  63,
+  24,
+  18,
+  54,
+  138,
+  200,
+  151,
+  217,
+  219,
+  241,
+  119,
+  150,
+  66,
+  8,
+  27,
+  105,
+  131,
+  187,
+  58,
+  182,
+  24,
+  203,
+  146,
+  119,
+  188,
+  210,
+  197,
+  104,
+  238,
+  33
+]);
+var NETWORK_MXE_GRANT_VARIANT_SEED = new Uint8Array([
+  142,
+  219,
+  209,
+  143,
+  158,
+  68,
+  71,
+  58,
+  193,
+  244,
+  116,
+  159,
+  48,
+  68,
+  160,
+  95,
+  175,
+  131,
+  151,
+  209,
+  81,
+  213,
+  51,
+  159,
+  98,
+  98,
+  138,
+  109,
+  254,
+  69,
+  221,
+  95
+]);
+var NETWORK_SHARED_GRANT_VARIANT_SEED = new Uint8Array([
+  172,
+  245,
+  86,
+  61,
+  89,
+  235,
+  170,
+  92,
+  253,
+  117,
+  241,
+  14,
+  2,
+  33,
+  164,
+  107,
+  22,
+  131,
+  100,
+  113,
+  39,
+  173,
+  185,
+  55,
+  254,
+  100,
+  108,
+  218,
+  180,
+  105,
+  75,
+  184
+]);
+async function getUserGrantedComplianceGrantPda(granterX25519, nonce, receiverX25519, umbraProgram) {
+  const [pda] = await kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [
+      ARCIUM_COMPLIANCE_GRANT_SEED,
+      USER_GRANT_VARIANT_SEED,
+      codama.getArciumX25519PublicKeyEncoder().encode({ first: granterX25519 }),
+      codama.getArciumX25519NonceEncoder().encode({ first: nonce }),
+      codama.getArciumX25519PublicKeyEncoder().encode({ first: receiverX25519 })
+    ]
+  });
+  return pda;
+}
+chunkPK6SKIKE_cjs.__name(getUserGrantedComplianceGrantPda, "getUserGrantedComplianceGrantPda");
+async function getNetworkMxeComplianceGrantPda(nonce, receiverX25519, umbraProgram) {
+  const [pda] = await kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [
+      ARCIUM_COMPLIANCE_GRANT_SEED,
+      NETWORK_MXE_GRANT_VARIANT_SEED,
+      codama.getArciumX25519NonceEncoder().encode({ first: nonce }),
+      codama.getArciumX25519PublicKeyEncoder().encode({ first: receiverX25519 })
+    ]
+  });
+  return pda;
+}
+chunkPK6SKIKE_cjs.__name(getNetworkMxeComplianceGrantPda, "getNetworkMxeComplianceGrantPda");
+async function getNetworkSharedComplianceGrantPda(granterX25519, nonce, receiverX25519, umbraProgram) {
+  const [pda] = await kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [
+      ARCIUM_COMPLIANCE_GRANT_SEED,
+      NETWORK_SHARED_GRANT_VARIANT_SEED,
+      codama.getArciumX25519PublicKeyEncoder().encode({ first: granterX25519 }),
+      codama.getArciumX25519NonceEncoder().encode({ first: nonce }),
+      codama.getArciumX25519PublicKeyEncoder().encode({ first: receiverX25519 })
+    ]
+  });
+  return pda;
+}
+chunkPK6SKIKE_cjs.__name(getNetworkSharedComplianceGrantPda, "getNetworkSharedComplianceGrantPda");
+var PROGRAM_INFORMATION_SEED = structSeed("ProgramInformation");
+async function getProgramInformationPda(umbraProgram) {
+  const [pda] = await kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [PROGRAM_INFORMATION_SEED]
+  });
+  return pda;
+}
+chunkPK6SKIKE_cjs.__name(getProgramInformationPda, "getProgramInformationPda");
+var POOL_SEED = structSeed("Pool");
+async function getPoolPda(mintAddress, umbraProgram) {
+  const [pda] = await kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [POOL_SEED, kit.getAddressEncoder().encode(mintAddress)]
+  });
+  return pda;
+}
+chunkPK6SKIKE_cjs.__name(getPoolPda, "getPoolPda");
+var RELAYER_ACCOUNT_SEED = structSeed("RelayerAccount");
+async function getRelayerAccountPda(relayerAddress, mintAddress, umbraProgram) {
+  const addressEncoder = kit.getAddressEncoder();
+  const [pda] = await kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [
+      RELAYER_ACCOUNT_SEED,
+      addressEncoder.encode(relayerAddress),
+      addressEncoder.encode(mintAddress)
+    ]
+  });
+  return pda;
+}
+chunkPK6SKIKE_cjs.__name(getRelayerAccountPda, "getRelayerAccountPda");
+var UNIFIED_FEES_POOL_SEED = structSeed("UnifiedFeesPool");
+var DOMAIN_PROTOCOL_FEES = structSeed("ProtocolFees");
+var DOMAIN_PROTOCOL_RELAYER_FEES = structSeed("ProtocolRelayerFees");
+var PROTOCOL_FEES_CONFIGURATION_SEED = structSeed("ProtocolFeesConfiguration");
+async function getProtocolOnlyUnifiedFeesPoolPda(instructionSeed, mintAddress, offset, umbraProgram) {
+  const addressEncoder = kit.getAddressEncoder();
+  return kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [
+      UNIFIED_FEES_POOL_SEED,
+      DOMAIN_PROTOCOL_FEES,
+      encodeU128ToU128LeBytes(instructionSeed),
+      addressEncoder.encode(mintAddress),
+      codama.getAccountOffsetEncoder().encode({ first: BigInt(offset) })
+    ]
+  });
+}
+chunkPK6SKIKE_cjs.__name(getProtocolOnlyUnifiedFeesPoolPda, "getProtocolOnlyUnifiedFeesPoolPda");
+async function getRelayerUnifiedFeesPoolPda(instructionSeed, relayerAddress, mintAddress, offset, umbraProgram) {
+  const addressEncoder = kit.getAddressEncoder();
+  return kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [
+      UNIFIED_FEES_POOL_SEED,
+      DOMAIN_PROTOCOL_RELAYER_FEES,
+      encodeU128ToU128LeBytes(instructionSeed),
+      addressEncoder.encode(relayerAddress),
+      addressEncoder.encode(mintAddress),
+      codama.getAccountOffsetEncoder().encode({ first: BigInt(offset) })
+    ]
+  });
+}
+chunkPK6SKIKE_cjs.__name(getRelayerUnifiedFeesPoolPda, "getRelayerUnifiedFeesPoolPda");
+async function getProtocolFeesConfigurationPda(instructionSeed, mintAddress, offset, umbraProgram) {
+  const addressEncoder = kit.getAddressEncoder();
+  return kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [
+      PROTOCOL_FEES_CONFIGURATION_SEED,
+      encodeU128ToU128LeBytes(instructionSeed),
+      addressEncoder.encode(mintAddress),
+      codama.getAccountOffsetEncoder().encode({ first: BigInt(offset) })
+    ]
+  });
+}
+chunkPK6SKIKE_cjs.__name(getProtocolFeesConfigurationPda, "getProtocolFeesConfigurationPda");
+var ZK_VERIFYING_KEY_SEED = structSeed("ZkVerifyingKey");
+var CONFIDENTIAL_CLAIM_PROOF_ACCOUNT_SEED = structSeed("ConfidentialClaimProofAccount");
+var CONFIDENTIAL_UTXO_PROOF_ACCOUNT_SEED = structSeed("ConfidentialUtxoProofAccount");
+var PUBLIC_CLAIM_PROOF_ACCOUNT_SEED = structSeed("PublicClaimProofAccount");
+var PUBLIC_CLAIM_MXE_MPC_CALLBACK_DATA_SEED = structSeed("PublicClaimMxeMpcCallbackData");
+async function getZkVerifyingKeyPda(instructionSeed, umbraProgram) {
+  const [pda] = await kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [ZK_VERIFYING_KEY_SEED, encodeU128ToU128LeBytes(instructionSeed)]
+  });
+  return pda;
+}
+chunkPK6SKIKE_cjs.__name(getZkVerifyingKeyPda, "getZkVerifyingKeyPda");
+async function getConfidentialClaimProofAccountPda(payerAddress, offset, umbraProgram) {
+  const [pda] = await kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [
+      CONFIDENTIAL_CLAIM_PROOF_ACCOUNT_SEED,
+      kit.getAddressEncoder().encode(payerAddress),
+      codama.getAccountOffsetEncoder().encode({ first: BigInt(offset) })
+    ]
+  });
+  return pda;
+}
+chunkPK6SKIKE_cjs.__name(getConfidentialClaimProofAccountPda, "getConfidentialClaimProofAccountPda");
+async function getConfidentialUtxoProofAccountPda(depositorAddress, offset, umbraProgram) {
+  const [pda] = await kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [
+      CONFIDENTIAL_UTXO_PROOF_ACCOUNT_SEED,
+      kit.getAddressEncoder().encode(depositorAddress),
+      codama.getAccountOffsetEncoder().encode({ first: BigInt(offset) })
+    ]
+  });
+  return pda;
+}
+chunkPK6SKIKE_cjs.__name(getConfidentialUtxoProofAccountPda, "getConfidentialUtxoProofAccountPda");
+async function getPublicClaimProofAccountPda(relayerAddress, offset, umbraProgram) {
+  const [pda] = await kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [
+      PUBLIC_CLAIM_PROOF_ACCOUNT_SEED,
+      kit.getAddressEncoder().encode(relayerAddress),
+      codama.getAccountOffsetEncoder().encode({ first: BigInt(offset) })
+    ]
+  });
+  return pda;
+}
+chunkPK6SKIKE_cjs.__name(getPublicClaimProofAccountPda, "getPublicClaimProofAccountPda");
+async function getPublicClaimMxeMpcCallbackDataPda(relayerAddress, offset, umbraProgram) {
+  return kit.getProgramDerivedAddress({
+    programAddress: umbraProgram,
+    seeds: [
+      PUBLIC_CLAIM_MXE_MPC_CALLBACK_DATA_SEED,
+      kit.getAddressEncoder().encode(relayerAddress),
+      codama.getAccountOffsetEncoder().encode({ first: BigInt(offset) })
+    ]
+  });
+}
+chunkPK6SKIKE_cjs.__name(getPublicClaimMxeMpcCallbackDataPda, "getPublicClaimMxeMpcCallbackDataPda");
+
+// src/common/temporal/index.ts
+function extractUtcComponents(date) {
+  const yearValue = BigInt(date.getUTCFullYear());
+  const monthValue = BigInt(date.getUTCMonth() + 1);
+  const dayValue = BigInt(date.getUTCDate());
+  const hourValue = BigInt(date.getUTCHours());
+  const minuteValue = BigInt(date.getUTCMinutes());
+  const secondValue = BigInt(date.getUTCSeconds());
+  chunkMDFSBU5W_cjs.assertYear(yearValue);
+  chunkMDFSBU5W_cjs.assertMonth(monthValue);
+  chunkMDFSBU5W_cjs.assertDay(dayValue);
+  chunkMDFSBU5W_cjs.assertHour(hourValue);
+  chunkMDFSBU5W_cjs.assertMinute(minuteValue);
+  chunkMDFSBU5W_cjs.assertSecond(secondValue);
+  return {
+    year: yearValue,
+    month: monthValue,
+    day: dayValue,
+    hour: hourValue,
+    minute: minuteValue,
+    second: secondValue
+  };
+}
+chunkPK6SKIKE_cjs.__name(extractUtcComponents, "extractUtcComponents");
+function getUtcNow() {
+  return extractUtcComponents(/* @__PURE__ */ new Date());
+}
+chunkPK6SKIKE_cjs.__name(getUtcNow, "getUtcNow");
+function getUtcNowFunction(deps) {
+  const dateProvider = deps?.dateProvider ?? (() => /* @__PURE__ */ new Date());
+  return () => extractUtcComponents(dateProvider());
+}
+chunkPK6SKIKE_cjs.__name(getUtcNowFunction, "getUtcNowFunction");
+function getExtractUtcComponentsFunction(deps) {
+  return extractUtcComponents;
+}
+chunkPK6SKIKE_cjs.__name(getExtractUtcComponentsFunction, "getExtractUtcComponentsFunction");
+var defaultGetUtcNow = getUtcNowFunction();
+var defaultExtractUtcComponents = getExtractUtcComponentsFunction();
+var EXTENSION_TYPE_TRANSFER_FEE_CONFIG = 1;
+var MINT_SIZE = 82;
+var ACCOUNT_TYPE_OFFSET = MINT_SIZE;
+var EXTENSIONS_OFFSET = ACCOUNT_TYPE_OFFSET + 1;
+var TRANSFER_FEE_CONFIG_SIZE = 108;
+function extractTransferFeeConfig(mintData) {
+  if (mintData === void 0 || mintData.length === 0) {
+    return null;
+  }
+  if (mintData.length <= EXTENSIONS_OFFSET) {
+    return null;
+  }
+  const accountType = mintData[ACCOUNT_TYPE_OFFSET];
+  if (accountType !== 1) {
+    return null;
+  }
+  let offset = EXTENSIONS_OFFSET;
+  while (offset + 4 <= mintData.length) {
+    const extensionType = (mintData[offset] ?? 0) | (mintData[offset + 1] ?? 0) << 8;
+    offset += 2;
+    const extensionLength = (mintData[offset] ?? 0) | (mintData[offset + 1] ?? 0) << 8;
+    offset += 2;
+    if (extensionLength === 0 || extensionLength > 1e4) {
+      break;
+    }
+    if (offset + extensionLength > mintData.length) {
+      break;
+    }
+    if (extensionType === EXTENSION_TYPE_TRANSFER_FEE_CONFIG) {
+      return parseTransferFeeConfig(mintData.slice(offset, offset + extensionLength));
+    }
+    offset += extensionLength;
+  }
+  return null;
+}
+chunkPK6SKIKE_cjs.__name(extractTransferFeeConfig, "extractTransferFeeConfig");
+function parseTransferFeeConfig(data) {
+  if (data.length < TRANSFER_FEE_CONFIG_SIZE) {
+    return null;
+  }
+  let offset = 0;
+  const transferFeeConfigAuthority = parseOptionalPubkey(data, offset);
+  offset += 36;
+  const withdrawWithheldAuthority = parseOptionalPubkey(data, offset);
+  offset += 36;
+  const withheldAmount = readU64LE(data, offset);
+  offset += 8;
+  const olderTransferFee = parseTransferFeeSchedule(data, offset);
+  offset += 18;
+  const newerTransferFee = parseTransferFeeSchedule(data, offset);
+  if (olderTransferFee.transferFeeBasisPoints > 1e4 || newerTransferFee.transferFeeBasisPoints > 1e4) {
+    return null;
+  }
+  return {
+    transferFeeConfigAuthority,
+    withdrawWithheldAuthority,
+    withheldAmount,
+    olderTransferFee,
+    newerTransferFee
+  };
+}
+chunkPK6SKIKE_cjs.__name(parseTransferFeeConfig, "parseTransferFeeConfig");
+function parseOptionalPubkey(data, offset) {
+  const discriminator = (data[offset] ?? 0) | (data[offset + 1] ?? 0) << 8 | (data[offset + 2] ?? 0) << 16 | (data[offset + 3] ?? 0) << 24;
+  if (discriminator === 0) {
+    return null;
+  }
+  const pubkeyBytes = data.slice(offset + 4, offset + 36);
+  return pubkeyBytesToAddress(pubkeyBytes);
+}
+chunkPK6SKIKE_cjs.__name(parseOptionalPubkey, "parseOptionalPubkey");
+function pubkeyBytesToAddress(bytes) {
+  const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+  let numericValue = 0n;
+  for (const byte of bytes) {
+    numericValue = numericValue * 256n + BigInt(byte);
+  }
+  let encoded = "";
+  while (numericValue > 0n) {
+    const remainder = Number(numericValue % 58n);
+    numericValue = numericValue / 58n;
+    encoded = (ALPHABET[remainder] ?? "") + encoded;
+  }
+  for (const byte of bytes) {
+    if (byte === 0) {
+      encoded = `1${encoded}`;
+    } else {
+      break;
+    }
+  }
+  return kit.address(encoded);
+}
+chunkPK6SKIKE_cjs.__name(pubkeyBytesToAddress, "pubkeyBytesToAddress");
+function parseTransferFeeSchedule(data, offset) {
+  const epoch = readU64LE(data, offset);
+  const maximumFee = readU64LE(data, offset + 8);
+  const transferFeeBasisPoints = (data[offset + 16] ?? 0) | (data[offset + 17] ?? 0) << 8;
+  return {
+    epoch,
+    maximumFee,
+    transferFeeBasisPoints
+  };
+}
+chunkPK6SKIKE_cjs.__name(parseTransferFeeSchedule, "parseTransferFeeSchedule");
+function readU64LE(data, offset) {
+  let result = 0n;
+  for (let index = 7; index >= 0; index--) {
+    result = result << 8n | BigInt(data[offset + index] ?? 0);
+  }
+  return result;
+}
+chunkPK6SKIKE_cjs.__name(readU64LE, "readU64LE");
+function calculateTransferFee(feeConfig, currentEpoch, amount) {
+  if (amount <= 0n) {
+    return 0n;
+  }
+  const schedule = currentEpoch >= feeConfig.newerTransferFee.epoch ? feeConfig.newerTransferFee : feeConfig.olderTransferFee;
+  if (schedule.transferFeeBasisPoints === 0) {
+    return 0n;
+  }
+  const fee = ceilDiv(amount * BigInt(schedule.transferFeeBasisPoints), 10000n);
+  return fee < schedule.maximumFee ? fee : schedule.maximumFee;
+}
+chunkPK6SKIKE_cjs.__name(calculateTransferFee, "calculateTransferFee");
+function ceilDiv(numerator, denominator) {
+  if (denominator === 0n) {
+    throw new Error("Division by zero");
+  }
+  return (numerator + denominator - 1n) / denominator;
+}
+chunkPK6SKIKE_cjs.__name(ceilDiv, "ceilDiv");
+function calculateNetAmountAfterFee(feeConfig, currentEpoch, grossAmount) {
+  const fee = calculateTransferFee(feeConfig, currentEpoch, grossAmount);
+  return grossAmount - fee;
+}
+chunkPK6SKIKE_cjs.__name(calculateNetAmountAfterFee, "calculateNetAmountAfterFee");
+
+// src/common/type-helpers.ts
+function asU64(value, name) {
+  chunkMDFSBU5W_cjs.assertU64(value, name);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(asU64, "asU64");
+function asU128(value, name) {
+  chunkMDFSBU5W_cjs.assertU128(value, name);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(asU128, "asU128");
+function asU256(value, name) {
+  chunkMDFSBU5W_cjs.assertU256(value, name);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(asU256, "asU256");
+function asBn254FieldElement(value, name) {
+  chunkMDFSBU5W_cjs.assertBn254FieldElement(value, name);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(asBn254FieldElement, "asBn254FieldElement");
+function asCurve25519FieldElement(value, name) {
+  chunkMDFSBU5W_cjs.assertCurve25519FieldElement(value, name);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(asCurve25519FieldElement, "asCurve25519FieldElement");
+function asPoseidonKey(value) {
+  chunkMDFSBU5W_cjs.assertPoseidonKey(value);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(asPoseidonKey, "asPoseidonKey");
+function asRcPlaintext(value, name) {
+  chunkMDFSBU5W_cjs.assertRcPlaintext(value, name);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(asRcPlaintext, "asRcPlaintext");
+function asRcCiphertext(value, name) {
+  chunkMDFSBU5W_cjs.assertRcCiphertext(value, name);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(asRcCiphertext, "asRcCiphertext");
+function asRcKey(value, name) {
+  chunkMDFSBU5W_cjs.assertRcKey(value, name);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(asRcKey, "asRcKey");
+function asRcEncryptionNonce(value, name) {
+  chunkMDFSBU5W_cjs.assertRcEncryptionNonce(value, name);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(asRcEncryptionNonce, "asRcEncryptionNonce");
+function asBase85Limb(value, name) {
+  chunkMDFSBU5W_cjs.assertBase85Limb(value, name);
+  return value;
+}
+chunkPK6SKIKE_cjs.__name(asBase85Limb, "asBase85Limb");
+function getByteAt(bytes, index, name = "array") {
+  if (index < 0 || index >= bytes.length) {
+    throw new Error(
+      `${name}: Index ${String(index)} out of bounds for Uint8Array of length ${String(bytes.length)}`
+    );
+  }
+  const byte = bytes[index];
+  if (byte === void 0) {
+    throw new Error(
+      `${name}: Byte at index ${String(index)} is undefined (array length: ${String(bytes.length)})`
+    );
+  }
+  return byte;
+}
+chunkPK6SKIKE_cjs.__name(getByteAt, "getByteAt");
+
+exports.ConversionError = ConversionError;
+exports.POOL_SEED = POOL_SEED;
+exports.asBase85Limb = asBase85Limb;
+exports.asBn254FieldElement = asBn254FieldElement;
+exports.asCurve25519FieldElement = asCurve25519FieldElement;
+exports.asPoseidonKey = asPoseidonKey;
+exports.asRcCiphertext = asRcCiphertext;
+exports.asRcEncryptionNonce = asRcEncryptionNonce;
+exports.asRcKey = asRcKey;
+exports.asRcPlaintext = asRcPlaintext;
+exports.asU128 = asU128;
+exports.asU256 = asU256;
+exports.asU64 = asU64;
+exports.bigintToBinaryArrayLSB = bigintToBinaryArrayLSB;
+exports.calculateNetAmountAfterFee = calculateNetAmountAfterFee;
+exports.calculateTransferFee = calculateTransferFee;
+exports.convertBn254FieldElementToCurve25519FieldElement = convertBn254FieldElementToCurve25519FieldElement;
+exports.convertBn254FieldElementToPoseidonCiphertext = convertBn254FieldElementToPoseidonCiphertext;
+exports.convertBn254FieldElementToPoseidonHash = convertBn254FieldElementToPoseidonHash;
+exports.convertBn254FieldElementToPoseidonKey = convertBn254FieldElementToPoseidonKey;
+exports.convertBn254FieldElementToPoseidonPlaintext = convertBn254FieldElementToPoseidonPlaintext;
+exports.convertBn254FieldElementToU256 = convertBn254FieldElementToU256;
+exports.convertCurve25519FieldElementToBn254FieldElement = convertCurve25519FieldElementToBn254FieldElement;
+exports.convertCurve25519FieldElementToRcCiphertext = convertCurve25519FieldElementToRcCiphertext;
+exports.convertCurve25519FieldElementToRcCounter = convertCurve25519FieldElementToRcCounter;
+exports.convertCurve25519FieldElementToRcKey = convertCurve25519FieldElementToRcKey;
+exports.convertCurve25519FieldElementToRcPlaintext = convertCurve25519FieldElementToRcPlaintext;
+exports.convertCurve25519FieldElementToU256 = convertCurve25519FieldElementToU256;
+exports.convertI1024ToI128 = convertI1024ToI128;
+exports.convertI1024ToI16 = convertI1024ToI16;
+exports.convertI1024ToI256 = convertI1024ToI256;
+exports.convertI1024ToI32 = convertI1024ToI32;
+exports.convertI1024ToI512 = convertI1024ToI512;
+exports.convertI1024ToI64 = convertI1024ToI64;
+exports.convertI1024ToI8 = convertI1024ToI8;
+exports.convertI1024ToU1024 = convertI1024ToU1024;
+exports.convertI128ToI1024 = convertI128ToI1024;
+exports.convertI128ToI16 = convertI128ToI16;
+exports.convertI128ToI256 = convertI128ToI256;
+exports.convertI128ToI32 = convertI128ToI32;
+exports.convertI128ToI512 = convertI128ToI512;
+exports.convertI128ToI64 = convertI128ToI64;
+exports.convertI128ToI8 = convertI128ToI8;
+exports.convertI128ToU128 = convertI128ToU128;
+exports.convertI16ToI1024 = convertI16ToI1024;
+exports.convertI16ToI128 = convertI16ToI128;
+exports.convertI16ToI256 = convertI16ToI256;
+exports.convertI16ToI32 = convertI16ToI32;
+exports.convertI16ToI512 = convertI16ToI512;
+exports.convertI16ToI64 = convertI16ToI64;
+exports.convertI16ToI8 = convertI16ToI8;
+exports.convertI16ToU16 = convertI16ToU16;
+exports.convertI256ToI1024 = convertI256ToI1024;
+exports.convertI256ToI128 = convertI256ToI128;
+exports.convertI256ToI16 = convertI256ToI16;
+exports.convertI256ToI32 = convertI256ToI32;
+exports.convertI256ToI512 = convertI256ToI512;
+exports.convertI256ToI64 = convertI256ToI64;
+exports.convertI256ToI8 = convertI256ToI8;
+exports.convertI256ToU256 = convertI256ToU256;
+exports.convertI32ToI1024 = convertI32ToI1024;
+exports.convertI32ToI128 = convertI32ToI128;
+exports.convertI32ToI16 = convertI32ToI16;
+exports.convertI32ToI256 = convertI32ToI256;
+exports.convertI32ToI512 = convertI32ToI512;
+exports.convertI32ToI64 = convertI32ToI64;
+exports.convertI32ToI8 = convertI32ToI8;
+exports.convertI32ToU32 = convertI32ToU32;
+exports.convertI512ToI1024 = convertI512ToI1024;
+exports.convertI512ToI128 = convertI512ToI128;
+exports.convertI512ToI16 = convertI512ToI16;
+exports.convertI512ToI256 = convertI512ToI256;
+exports.convertI512ToI32 = convertI512ToI32;
+exports.convertI512ToI64 = convertI512ToI64;
+exports.convertI512ToI8 = convertI512ToI8;
+exports.convertI512ToU512 = convertI512ToU512;
+exports.convertI64ToI1024 = convertI64ToI1024;
+exports.convertI64ToI128 = convertI64ToI128;
+exports.convertI64ToI16 = convertI64ToI16;
+exports.convertI64ToI256 = convertI64ToI256;
+exports.convertI64ToI32 = convertI64ToI32;
+exports.convertI64ToI512 = convertI64ToI512;
+exports.convertI64ToI8 = convertI64ToI8;
+exports.convertI64ToU64 = convertI64ToU64;
+exports.convertI8ToI1024 = convertI8ToI1024;
+exports.convertI8ToI128 = convertI8ToI128;
+exports.convertI8ToI16 = convertI8ToI16;
+exports.convertI8ToI256 = convertI8ToI256;
+exports.convertI8ToI32 = convertI8ToI32;
+exports.convertI8ToI512 = convertI8ToI512;
+exports.convertI8ToI64 = convertI8ToI64;
+exports.convertI8ToU8 = convertI8ToU8;
+exports.convertPoseidonCiphertextToBn254FieldElement = convertPoseidonCiphertextToBn254FieldElement;
+exports.convertPoseidonHashToBn254FieldElement = convertPoseidonHashToBn254FieldElement;
+exports.convertPoseidonKeyToBn254FieldElement = convertPoseidonKeyToBn254FieldElement;
+exports.convertPoseidonPlaintextToBn254FieldElement = convertPoseidonPlaintextToBn254FieldElement;
+exports.convertRcCiphertextToCurve25519FieldElement = convertRcCiphertextToCurve25519FieldElement;
+exports.convertRcCounterToCurve25519FieldElement = convertRcCounterToCurve25519FieldElement;
+exports.convertRcEncryptionNonceToU128 = convertRcEncryptionNonceToU128;
+exports.convertRcKeyToCurve25519FieldElement = convertRcKeyToCurve25519FieldElement;
+exports.convertRcPlaintextToCurve25519FieldElement = convertRcPlaintextToCurve25519FieldElement;
+exports.convertSharedSecretToX25519Bytes = convertSharedSecretToX25519Bytes;
+exports.convertU1024BeBytesToU1024LeBytes = convertU1024BeBytesToU1024LeBytes;
+exports.convertU1024LeBytesToU1024BeBytes = convertU1024LeBytesToU1024BeBytes;
+exports.convertU1024ToI1024 = convertU1024ToI1024;
+exports.convertU1024ToU128 = convertU1024ToU128;
+exports.convertU1024ToU16 = convertU1024ToU16;
+exports.convertU1024ToU256 = convertU1024ToU256;
+exports.convertU1024ToU32 = convertU1024ToU32;
+exports.convertU1024ToU512 = convertU1024ToU512;
+exports.convertU1024ToU64 = convertU1024ToU64;
+exports.convertU1024ToU8 = convertU1024ToU8;
+exports.convertU128BeBytesToU128LeBytes = convertU128BeBytesToU128LeBytes;
+exports.convertU128LeBytesToU128BeBytes = convertU128LeBytesToU128BeBytes;
+exports.convertU128ToI128 = convertU128ToI128;
+exports.convertU128ToRcEncryptionNonce = convertU128ToRcEncryptionNonce;
+exports.convertU128ToU1024 = convertU128ToU1024;
+exports.convertU128ToU16 = convertU128ToU16;
+exports.convertU128ToU256 = convertU128ToU256;
+exports.convertU128ToU32 = convertU128ToU32;
+exports.convertU128ToU512 = convertU128ToU512;
+exports.convertU128ToU64 = convertU128ToU64;
+exports.convertU128ToU8 = convertU128ToU8;
+exports.convertU16BeBytesToU16LeBytes = convertU16BeBytesToU16LeBytes;
+exports.convertU16LeBytesToU16BeBytes = convertU16LeBytesToU16BeBytes;
+exports.convertU16ToI16 = convertU16ToI16;
+exports.convertU16ToU1024 = convertU16ToU1024;
+exports.convertU16ToU128 = convertU16ToU128;
+exports.convertU16ToU256 = convertU16ToU256;
+exports.convertU16ToU32 = convertU16ToU32;
+exports.convertU16ToU512 = convertU16ToU512;
+exports.convertU16ToU64 = convertU16ToU64;
+exports.convertU16ToU8 = convertU16ToU8;
+exports.convertU256BeBytesToU256LeBytes = convertU256BeBytesToU256LeBytes;
+exports.convertU256LeBytesToU256BeBytes = convertU256LeBytesToU256BeBytes;
+exports.convertU256ToBase85Limbs = convertU256ToBase85Limbs;
+exports.convertU256ToBn254FieldElement = convertU256ToBn254FieldElement;
+exports.convertU256ToCurve25519FieldElement = convertU256ToCurve25519FieldElement;
+exports.convertU256ToI256 = convertU256ToI256;
+exports.convertU256ToU1024 = convertU256ToU1024;
+exports.convertU256ToU128 = convertU256ToU128;
+exports.convertU256ToU16 = convertU256ToU16;
+exports.convertU256ToU32 = convertU256ToU32;
+exports.convertU256ToU512 = convertU256ToU512;
+exports.convertU256ToU64 = convertU256ToU64;
+exports.convertU256ToU8 = convertU256ToU8;
+exports.convertU32BeBytesToU32LeBytes = convertU32BeBytesToU32LeBytes;
+exports.convertU32LeBytesToU32BeBytes = convertU32LeBytesToU32BeBytes;
+exports.convertU32ToI32 = convertU32ToI32;
+exports.convertU32ToU1024 = convertU32ToU1024;
+exports.convertU32ToU128 = convertU32ToU128;
+exports.convertU32ToU16 = convertU32ToU16;
+exports.convertU32ToU256 = convertU32ToU256;
+exports.convertU32ToU512 = convertU32ToU512;
+exports.convertU32ToU64 = convertU32ToU64;
+exports.convertU32ToU8 = convertU32ToU8;
+exports.convertU512BeBytesToU512LeBytes = convertU512BeBytesToU512LeBytes;
+exports.convertU512LeBytesToU512BeBytes = convertU512LeBytesToU512BeBytes;
+exports.convertU512ToI512 = convertU512ToI512;
+exports.convertU512ToU1024 = convertU512ToU1024;
+exports.convertU512ToU128 = convertU512ToU128;
+exports.convertU512ToU16 = convertU512ToU16;
+exports.convertU512ToU256 = convertU512ToU256;
+exports.convertU512ToU32 = convertU512ToU32;
+exports.convertU512ToU64 = convertU512ToU64;
+exports.convertU512ToU8 = convertU512ToU8;
+exports.convertU64BeBytesToU64LeBytes = convertU64BeBytesToU64LeBytes;
+exports.convertU64LeBytesToU64BeBytes = convertU64LeBytesToU64BeBytes;
+exports.convertU64ToI64 = convertU64ToI64;
+exports.convertU64ToU1024 = convertU64ToU1024;
+exports.convertU64ToU128 = convertU64ToU128;
+exports.convertU64ToU16 = convertU64ToU16;
+exports.convertU64ToU256 = convertU64ToU256;
+exports.convertU64ToU32 = convertU64ToU32;
+exports.convertU64ToU512 = convertU64ToU512;
+exports.convertU64ToU8 = convertU64ToU8;
+exports.convertU8BeBytesToU8LeBytes = convertU8BeBytesToU8LeBytes;
+exports.convertU8LeBytesToU8BeBytes = convertU8LeBytesToU8BeBytes;
+exports.convertU8ToI8 = convertU8ToI8;
+exports.convertU8ToU1024 = convertU8ToU1024;
+exports.convertU8ToU128 = convertU8ToU128;
+exports.convertU8ToU16 = convertU8ToU16;
+exports.convertU8ToU256 = convertU8ToU256;
+exports.convertU8ToU32 = convertU8ToU32;
+exports.convertU8ToU512 = convertU8ToU512;
+exports.convertU8ToU64 = convertU8ToU64;
+exports.convertX25519BytesToSharedSecret = convertX25519BytesToSharedSecret;
+exports.convertX25519BytesToX25519PrivateKey = convertX25519BytesToX25519PrivateKey;
+exports.convertX25519BytesToX25519PublicKey = convertX25519BytesToX25519PublicKey;
+exports.convertX25519PrivateKeyToX25519Bytes = convertX25519PrivateKeyToX25519Bytes;
+exports.convertX25519PublicKeyToX25519Bytes = convertX25519PublicKeyToX25519Bytes;
+exports.createBeBytes = createBeBytes;
+exports.createBn254FieldElement = createBn254FieldElement;
+exports.createBytes = createBytes;
+exports.createCurve25519FieldElement = createCurve25519FieldElement;
+exports.createI1024 = createI1024;
+exports.createI128 = createI128;
+exports.createI16 = createI16;
+exports.createI256 = createI256;
+exports.createI32 = createI32;
+exports.createI512 = createI512;
+exports.createI64 = createI64;
+exports.createI8 = createI8;
+exports.createLeBytes = createLeBytes;
+exports.createPoseidonCiphertext = createPoseidonCiphertext;
+exports.createPoseidonHash = createPoseidonHash;
+exports.createPoseidonKey = createPoseidonKey;
+exports.createPoseidonPlaintext = createPoseidonPlaintext;
+exports.createRcCiphertext = createRcCiphertext;
+exports.createRcCounter = createRcCounter;
+exports.createRcEncryptionNonce = createRcEncryptionNonce;
+exports.createRcKey = createRcKey;
+exports.createRcPlaintext = createRcPlaintext;
+exports.createSharedSecret = createSharedSecret;
+exports.createSignedInteger = createSignedInteger;
+exports.createU1024 = createU1024;
+exports.createU1024BeBytes = createU1024BeBytes;
+exports.createU1024LeBytes = createU1024LeBytes;
+exports.createU128 = createU128;
+exports.createU128BeBytes = createU128BeBytes;
+exports.createU128LeBytes = createU128LeBytes;
+exports.createU16 = createU16;
+exports.createU16BeBytes = createU16BeBytes;
+exports.createU16LeBytes = createU16LeBytes;
+exports.createU256 = createU256;
+exports.createU256BeBytes = createU256BeBytes;
+exports.createU256LeBytes = createU256LeBytes;
+exports.createU32 = createU32;
+exports.createU32BeBytes = createU32BeBytes;
+exports.createU32LeBytes = createU32LeBytes;
+exports.createU512 = createU512;
+exports.createU512BeBytes = createU512BeBytes;
+exports.createU512LeBytes = createU512LeBytes;
+exports.createU64 = createU64;
+exports.createU64BeBytes = createU64BeBytes;
+exports.createU64LeBytes = createU64LeBytes;
+exports.createU8 = createU8;
+exports.createU8BeBytes = createU8BeBytes;
+exports.createU8LeBytes = createU8LeBytes;
+exports.createUnsignedInteger = createUnsignedInteger;
+exports.createX25519Bytes = createX25519Bytes;
+exports.createX25519PrivateKey = createX25519PrivateKey;
+exports.createX25519PublicKey = createX25519PublicKey;
+exports.decodeU1024BeBytesToU1024 = decodeU1024BeBytesToU1024;
+exports.decodeU1024LeBytesToU1024 = decodeU1024LeBytesToU1024;
+exports.decodeU128BeBytesToU128 = decodeU128BeBytesToU128;
+exports.decodeU128LeBytesToU128 = decodeU128LeBytesToU128;
+exports.decodeU16BeBytesToU16 = decodeU16BeBytesToU16;
+exports.decodeU16LeBytesToU16 = decodeU16LeBytesToU16;
+exports.decodeU256BeBytesToU256 = decodeU256BeBytesToU256;
+exports.decodeU256LeBytesToU256 = decodeU256LeBytesToU256;
+exports.decodeU32BeBytesToU32 = decodeU32BeBytesToU32;
+exports.decodeU32LeBytesToU32 = decodeU32LeBytesToU32;
+exports.decodeU512BeBytesToU512 = decodeU512BeBytesToU512;
+exports.decodeU512LeBytesToU512 = decodeU512LeBytesToU512;
+exports.decodeU64BeBytesToU64 = decodeU64BeBytesToU64;
+exports.decodeU64LeBytesToU64 = decodeU64LeBytesToU64;
+exports.decodeU8BeBytesToU8 = decodeU8BeBytesToU8;
+exports.decodeU8LeBytesToU8 = decodeU8LeBytesToU8;
+exports.defaultExtractUtcComponents = defaultExtractUtcComponents;
+exports.defaultGetUtcNow = defaultGetUtcNow;
+exports.encodeU1024ToU1024BeBytes = encodeU1024ToU1024BeBytes;
+exports.encodeU1024ToU1024LeBytes = encodeU1024ToU1024LeBytes;
+exports.encodeU128ToU128BeBytes = encodeU128ToU128BeBytes;
+exports.encodeU128ToU128LeBytes = encodeU128ToU128LeBytes;
+exports.encodeU16ToU16BeBytes = encodeU16ToU16BeBytes;
+exports.encodeU16ToU16LeBytes = encodeU16ToU16LeBytes;
+exports.encodeU256ToU256BeBytes = encodeU256ToU256BeBytes;
+exports.encodeU256ToU256LeBytes = encodeU256ToU256LeBytes;
+exports.encodeU32ToU32BeBytes = encodeU32ToU32BeBytes;
+exports.encodeU32ToU32LeBytes = encodeU32ToU32LeBytes;
+exports.encodeU512ToU512BeBytes = encodeU512ToU512BeBytes;
+exports.encodeU512ToU512LeBytes = encodeU512ToU512LeBytes;
+exports.encodeU64ToU64BeBytes = encodeU64ToU64BeBytes;
+exports.encodeU64ToU64LeBytes = encodeU64ToU64LeBytes;
+exports.encodeU8ToU8BeBytes = encodeU8ToU8BeBytes;
+exports.encodeU8ToU8LeBytes = encodeU8ToU8LeBytes;
+exports.extractTransferFeeConfig = extractTransferFeeConfig;
+exports.extractUtcComponents = extractUtcComponents;
+exports.generateRandomNonce = generateRandomNonce;
+exports.generateRandomU128 = generateRandomU128;
+exports.generateRandomU256 = generateRandomU256;
+exports.generateRandomU64 = generateRandomU64;
+exports.getActiveMixerTreeAddress = getActiveMixerTreeAddress;
+exports.getArciumAccountAddresses = getArciumAccountAddresses;
+exports.getArciumEncryptedTokenAccountPda = getArciumEncryptedTokenAccountPda;
+exports.getArciumEncryptedUserAccountPda = getArciumEncryptedUserAccountPda;
+exports.getByteAt = getByteAt;
+exports.getClusterAccountAddress = getClusterAccountAddress;
+exports.getCompDefAccountAddress = getCompDefAccountAddress;
+exports.getCompDefOffset = getCompDefOffset;
+exports.getComputationAccountAddress = getComputationAccountAddress;
+exports.getConfUtxoBurnerPda = getConfUtxoBurnerPda;
+exports.getConfidentialClaimProofAccountPda = getConfidentialClaimProofAccountPda;
+exports.getConfidentialUtxoProofAccountPda = getConfidentialUtxoProofAccountPda;
+exports.getExecutingPoolAccountAddress = getExecutingPoolAccountAddress;
+exports.getExtractUtcComponentsFunction = getExtractUtcComponentsFunction;
+exports.getMempoolAccountAddress = getMempoolAccountAddress;
+exports.getMixerTreeAddress = getMixerTreeAddress;
+exports.getMxeAccountAddress = getMxeAccountAddress;
+exports.getNetworkMxeComplianceGrantPda = getNetworkMxeComplianceGrantPda;
+exports.getNetworkSharedComplianceGrantPda = getNetworkSharedComplianceGrantPda;
+exports.getPoolPda = getPoolPda;
+exports.getProgramInformationPda = getProgramInformationPda;
+exports.getProtocolFeesConfigurationPda = getProtocolFeesConfigurationPda;
+exports.getProtocolOnlyUnifiedFeesPoolPda = getProtocolOnlyUnifiedFeesPoolPda;
+exports.getPubUtxoBurnerPda = getPubUtxoBurnerPda;
+exports.getPublicClaimMxeMpcCallbackDataPda = getPublicClaimMxeMpcCallbackDataPda;
+exports.getPublicClaimProofAccountPda = getPublicClaimProofAccountPda;
+exports.getRandomComputationOffset = getRandomComputationOffset;
+exports.getRelayerAccountPda = getRelayerAccountPda;
+exports.getRelayerUnifiedFeesPoolPda = getRelayerUnifiedFeesPoolPda;
+exports.getTreapPdas = getTreapPdas;
+exports.getUserGrantedComplianceGrantPda = getUserGrantedComplianceGrantPda;
+exports.getUtcNow = getUtcNow;
+exports.getUtcNowFunction = getUtcNowFunction;
+exports.getZkVerifyingKeyPda = getZkVerifyingKeyPda;
+exports.splitAddressToLowHigh = splitAddressToLowHigh;
+exports.splitU256IntoTwoU128s = splitU256IntoTwoU128s;
+exports.splitX25519PublicKeyIntoTwoU128s = splitX25519PublicKeyIntoTwoU128s;
+exports.structSeed = structSeed;
+//# sourceMappingURL=chunk-GXKSUB2U.cjs.map
+//# sourceMappingURL=chunk-GXKSUB2U.cjs.map