@umbra-privacy/sdk 1.0.0 → 2.0.1

package/dist/chunk-UXMQI6B7.js

@@ -0,0 +1,2406 @@
+import { ConversionError, assertNumberInRange, createU128LeBytes } from './chunk-UOFYS6M3.js';
+import { encodeU256ToU256LeBytes, encodeU256ToU256BeBytes, decodeU256LeBytesToU256, decodeU256BeBytesToU256, encodeU128ToU128LeBytes, encodeU128ToU128BeBytes, decodeU128LeBytesToU128, decodeU128BeBytesToU128 } from './chunk-FQX6ZYGJ.js';
+import { UmbraError } from './chunk-4TZVXB5G.js';
+import { assertYear, assertMonth, assertDay, assertHour, assertMinute, assertSecond } from './chunk-DD2WCK4C.js';
+import { assertU256, BN254_FIELD_PRIME, assertBn254FieldElement, CURVE25519_FIELD_PRIME, assertCurve25519FieldElement, assertPoseidonPlaintext, assertPoseidonHash, assertPoseidonKey, assertPoseidonCiphertext, assertRcPlaintext, assertRcCiphertext, assertRcKey, assertRcCounter, assertU128, assertRcEncryptionNonce, assertX25519Bytes, assertX25519PrivateKey, assertX25519PublicKey, assertSharedSecret, U128_BYTE_LENGTH, assertBase85Limb, assertMasterViewingKey, assertYearlyViewingKey, assertMonthlyViewingKey, assertDailyViewingKey, assertMintViewingKey, assertU8, assertU16, assertU32, assertU64, assertU512, assertU1024, U8_MAX, U16_MAX, U32_MAX, U64_MAX, U128_MAX, U256_MAX, U512_MAX, assertI8, assertI16, assertI32, assertI64, assertI128, assertI256, assertI512, assertI1024, I8_MIN, I8_MAX, I16_MIN, I16_MAX, I32_MIN, I32_MAX, I64_MIN, I64_MAX, I128_MIN, I128_MAX, I256_MIN, I256_MAX, I512_MIN, I512_MAX, I1024_MAX, U64_BYTE_LENGTH, U256_BYTE_LENGTH, assertOptionalData32 } from './chunk-CFTW5WNG.js';
+import { __name } from './chunk-7QVYU63E.js';
+import { decodeMXEAccount } from '@umbra-privacy/arcium-codama';
+import { getAddressEncoder, address } from '@solana/kit';
+
+// src/common/converters/cryptography.ts
+function convertU256ToBn254FieldElement(value) {
+  assertU256(value);
+  if (value >= BN254_FIELD_PRIME) {
+    throw new ConversionError(`Value exceeds BN254 field prime`, {
+      sourceValue: value,
+      sourceType: "U256",
+      targetType: "Bn254FieldElement",
+      reason: `Value must be < ${String(BN254_FIELD_PRIME)}`
+    });
+  }
+  assertBn254FieldElement(value);
+  return value;
+}
+__name(convertU256ToBn254FieldElement, "convertU256ToBn254FieldElement");
+function convertBn254FieldElementToU256(value) {
+  assertBn254FieldElement(value);
+  assertU256(value);
+  return value;
+}
+__name(convertBn254FieldElementToU256, "convertBn254FieldElementToU256");
+function convertU256ToCurve25519FieldElement(value) {
+  assertU256(value);
+  if (value >= CURVE25519_FIELD_PRIME) {
+    throw new ConversionError(`Value exceeds Curve25519 field prime`, {
+      sourceValue: value,
+      sourceType: "U256",
+      targetType: "Curve25519FieldElement",
+      reason: "Value must be < 2^255 - 19"
+    });
+  }
+  assertCurve25519FieldElement(value);
+  return value;
+}
+__name(convertU256ToCurve25519FieldElement, "convertU256ToCurve25519FieldElement");
+function convertCurve25519FieldElementToU256(value) {
+  assertCurve25519FieldElement(value);
+  assertU256(value);
+  return value;
+}
+__name(convertCurve25519FieldElementToU256, "convertCurve25519FieldElementToU256");
+function convertBn254FieldElementToCurve25519FieldElement(value) {
+  assertBn254FieldElement(value);
+  if (value >= 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"
+    });
+  }
+  assertCurve25519FieldElement(value);
+  return value;
+}
+__name(convertBn254FieldElementToCurve25519FieldElement, "convertBn254FieldElementToCurve25519FieldElement");
+function convertCurve25519FieldElementToBn254FieldElement(value) {
+  assertCurve25519FieldElement(value);
+  assertBn254FieldElement(value);
+  return value;
+}
+__name(convertCurve25519FieldElementToBn254FieldElement, "convertCurve25519FieldElementToBn254FieldElement");
+function convertBn254FieldElementToPoseidonPlaintext(value) {
+  assertBn254FieldElement(value);
+  assertPoseidonPlaintext(value);
+  return value;
+}
+__name(convertBn254FieldElementToPoseidonPlaintext, "convertBn254FieldElementToPoseidonPlaintext");
+function convertBn254FieldElementToPoseidonHash(value) {
+  assertBn254FieldElement(value);
+  assertPoseidonHash(value);
+  return value;
+}
+__name(convertBn254FieldElementToPoseidonHash, "convertBn254FieldElementToPoseidonHash");
+function convertBn254FieldElementToPoseidonKey(value) {
+  assertBn254FieldElement(value);
+  assertPoseidonKey(value);
+  return value;
+}
+__name(convertBn254FieldElementToPoseidonKey, "convertBn254FieldElementToPoseidonKey");
+function convertBn254FieldElementToPoseidonCiphertext(value) {
+  assertBn254FieldElement(value);
+  assertPoseidonCiphertext(value);
+  return value;
+}
+__name(convertBn254FieldElementToPoseidonCiphertext, "convertBn254FieldElementToPoseidonCiphertext");
+function convertPoseidonPlaintextToBn254FieldElement(value) {
+  assertPoseidonPlaintext(value);
+  assertBn254FieldElement(value);
+  return value;
+}
+__name(convertPoseidonPlaintextToBn254FieldElement, "convertPoseidonPlaintextToBn254FieldElement");
+function convertPoseidonHashToBn254FieldElement(value) {
+  assertPoseidonHash(value);
+  assertBn254FieldElement(value);
+  return value;
+}
+__name(convertPoseidonHashToBn254FieldElement, "convertPoseidonHashToBn254FieldElement");
+function convertPoseidonKeyToBn254FieldElement(value) {
+  assertPoseidonKey(value);
+  assertBn254FieldElement(value);
+  return value;
+}
+__name(convertPoseidonKeyToBn254FieldElement, "convertPoseidonKeyToBn254FieldElement");
+function convertPoseidonCiphertextToBn254FieldElement(value) {
+  assertPoseidonCiphertext(value);
+  assertBn254FieldElement(value);
+  return value;
+}
+__name(convertPoseidonCiphertextToBn254FieldElement, "convertPoseidonCiphertextToBn254FieldElement");
+function convertCurve25519FieldElementToRcPlaintext(value) {
+  assertCurve25519FieldElement(value);
+  assertRcPlaintext(value);
+  return value;
+}
+__name(convertCurve25519FieldElementToRcPlaintext, "convertCurve25519FieldElementToRcPlaintext");
+function convertCurve25519FieldElementToRcCiphertext(value) {
+  assertCurve25519FieldElement(value);
+  assertRcCiphertext(value);
+  return value;
+}
+__name(convertCurve25519FieldElementToRcCiphertext, "convertCurve25519FieldElementToRcCiphertext");
+function convertCurve25519FieldElementToRcKey(value) {
+  assertCurve25519FieldElement(value);
+  assertRcKey(value);
+  return value;
+}
+__name(convertCurve25519FieldElementToRcKey, "convertCurve25519FieldElementToRcKey");
+function convertCurve25519FieldElementToRcCounter(value) {
+  assertCurve25519FieldElement(value);
+  assertRcCounter(value);
+  return value;
+}
+__name(convertCurve25519FieldElementToRcCounter, "convertCurve25519FieldElementToRcCounter");
+function convertRcPlaintextToCurve25519FieldElement(value) {
+  assertRcPlaintext(value);
+  assertCurve25519FieldElement(value);
+  return value;
+}
+__name(convertRcPlaintextToCurve25519FieldElement, "convertRcPlaintextToCurve25519FieldElement");
+function convertRcCiphertextToCurve25519FieldElement(value) {
+  assertRcCiphertext(value);
+  assertCurve25519FieldElement(value);
+  return value;
+}
+__name(convertRcCiphertextToCurve25519FieldElement, "convertRcCiphertextToCurve25519FieldElement");
+function convertRcKeyToCurve25519FieldElement(value) {
+  assertRcKey(value);
+  assertCurve25519FieldElement(value);
+  return value;
+}
+__name(convertRcKeyToCurve25519FieldElement, "convertRcKeyToCurve25519FieldElement");
+function convertRcCounterToCurve25519FieldElement(value) {
+  assertRcCounter(value);
+  assertCurve25519FieldElement(value);
+  return value;
+}
+__name(convertRcCounterToCurve25519FieldElement, "convertRcCounterToCurve25519FieldElement");
+function convertU128ToRcEncryptionNonce(value) {
+  assertU128(value);
+  assertRcEncryptionNonce(value);
+  return value;
+}
+__name(convertU128ToRcEncryptionNonce, "convertU128ToRcEncryptionNonce");
+function convertRcEncryptionNonceToU128(value) {
+  assertRcEncryptionNonce(value);
+  assertU128(value);
+  return value;
+}
+__name(convertRcEncryptionNonceToU128, "convertRcEncryptionNonceToU128");
+function convertX25519BytesToX25519PrivateKey(value) {
+  assertX25519Bytes(value);
+  assertX25519PrivateKey(value);
+  return value;
+}
+__name(convertX25519BytesToX25519PrivateKey, "convertX25519BytesToX25519PrivateKey");
+function convertX25519BytesToX25519PublicKey(value) {
+  assertX25519Bytes(value);
+  assertX25519PublicKey(value);
+  return value;
+}
+__name(convertX25519BytesToX25519PublicKey, "convertX25519BytesToX25519PublicKey");
+function convertX25519BytesToSharedSecret(value) {
+  assertX25519Bytes(value);
+  assertSharedSecret(value);
+  return value;
+}
+__name(convertX25519BytesToSharedSecret, "convertX25519BytesToSharedSecret");
+function convertX25519PrivateKeyToX25519Bytes(value) {
+  assertX25519PrivateKey(value);
+  assertX25519Bytes(value);
+  return value;
+}
+__name(convertX25519PrivateKeyToX25519Bytes, "convertX25519PrivateKeyToX25519Bytes");
+function convertX25519PublicKeyToX25519Bytes(value) {
+  assertX25519PublicKey(value);
+  assertX25519Bytes(value);
+  return value;
+}
+__name(convertX25519PublicKeyToX25519Bytes, "convertX25519PublicKeyToX25519Bytes");
+function convertSharedSecretToX25519Bytes(value) {
+  assertSharedSecret(value);
+  assertX25519Bytes(value);
+  return value;
+}
+__name(convertSharedSecretToX25519Bytes, "convertSharedSecretToX25519Bytes");
+function splitU256IntoTwoU128s(value) {
+  assertU256(value);
+  const U128_MAX4 = (1n << 128n) - 1n;
+  const lowValue = value & U128_MAX4;
+  assertU128(lowValue);
+  const highValue = value >> 128n;
+  assertU128(highValue);
+  return { low: lowValue, high: highValue };
+}
+__name(splitU256IntoTwoU128s, "splitU256IntoTwoU128s");
+function splitX25519PublicKeyIntoTwoU128s(key) {
+  assertX25519PublicKey(key);
+  let low = 0n;
+  for (let index = U128_BYTE_LENGTH - 1; index >= 0; index--) {
+    low = low << 8n | BigInt(key[index]);
+  }
+  let high = 0n;
+  for (let index = U256_BYTE_LENGTH - 1; index >= U128_BYTE_LENGTH; index--) {
+    high = high << 8n | BigInt(key[index]);
+  }
+  assertU128(low);
+  assertU128(high);
+  return { low, high };
+}
+__name(splitX25519PublicKeyIntoTwoU128s, "splitX25519PublicKeyIntoTwoU128s");
+function convertU256ToBase85Limbs(value) {
+  assertU256(value);
+  const BASE85_MASK = (1n << 85n) - 1n;
+  const lowValue = value & BASE85_MASK;
+  assertBase85Limb(lowValue);
+  const middleValue = value >> 85n & BASE85_MASK;
+  assertBase85Limb(middleValue);
+  const highValue = value >> 170n;
+  assertBase85Limb(highValue);
+  return {
+    low: lowValue,
+    middle: middleValue,
+    high: highValue
+  };
+}
+__name(convertU256ToBase85Limbs, "convertU256ToBase85Limbs");
+function encodeBn254FieldElementToLeBytes(value) {
+  return encodeU256ToU256LeBytes(convertBn254FieldElementToU256(value));
+}
+__name(encodeBn254FieldElementToLeBytes, "encodeBn254FieldElementToLeBytes");
+function encodeBn254FieldElementToBeBytes(value) {
+  return encodeU256ToU256BeBytes(convertBn254FieldElementToU256(value));
+}
+__name(encodeBn254FieldElementToBeBytes, "encodeBn254FieldElementToBeBytes");
+function decodeLeBytesToBn254FieldElement(bytes) {
+  return convertU256ToBn254FieldElement(decodeU256LeBytesToU256(bytes));
+}
+__name(decodeLeBytesToBn254FieldElement, "decodeLeBytesToBn254FieldElement");
+function decodeBeBytesToBn254FieldElement(bytes) {
+  return convertU256ToBn254FieldElement(decodeU256BeBytesToU256(bytes));
+}
+__name(decodeBeBytesToBn254FieldElement, "decodeBeBytesToBn254FieldElement");
+function encodeCurve25519FieldElementToLeBytes(value) {
+  return encodeU256ToU256LeBytes(convertCurve25519FieldElementToU256(value));
+}
+__name(encodeCurve25519FieldElementToLeBytes, "encodeCurve25519FieldElementToLeBytes");
+function encodeCurve25519FieldElementToBeBytes(value) {
+  return encodeU256ToU256BeBytes(convertCurve25519FieldElementToU256(value));
+}
+__name(encodeCurve25519FieldElementToBeBytes, "encodeCurve25519FieldElementToBeBytes");
+function decodeLeBytesToCurve25519FieldElement(bytes) {
+  return convertU256ToCurve25519FieldElement(decodeU256LeBytesToU256(bytes));
+}
+__name(decodeLeBytesToCurve25519FieldElement, "decodeLeBytesToCurve25519FieldElement");
+function decodeBeBytesToCurve25519FieldElement(bytes) {
+  return convertU256ToCurve25519FieldElement(decodeU256BeBytesToU256(bytes));
+}
+__name(decodeBeBytesToCurve25519FieldElement, "decodeBeBytesToCurve25519FieldElement");
+function encodeRcEncryptionNonceToLeBytes(value) {
+  return encodeU128ToU128LeBytes(convertRcEncryptionNonceToU128(value));
+}
+__name(encodeRcEncryptionNonceToLeBytes, "encodeRcEncryptionNonceToLeBytes");
+function encodeRcEncryptionNonceToBeBytes(value) {
+  return encodeU128ToU128BeBytes(convertRcEncryptionNonceToU128(value));
+}
+__name(encodeRcEncryptionNonceToBeBytes, "encodeRcEncryptionNonceToBeBytes");
+function decodeLeBytesToRcEncryptionNonce(bytes) {
+  return convertU128ToRcEncryptionNonce(decodeU128LeBytesToU128(bytes));
+}
+__name(decodeLeBytesToRcEncryptionNonce, "decodeLeBytesToRcEncryptionNonce");
+function decodeBeBytesToRcEncryptionNonce(bytes) {
+  return convertU128ToRcEncryptionNonce(decodeU128BeBytesToU128(bytes));
+}
+__name(decodeBeBytesToRcEncryptionNonce, "decodeBeBytesToRcEncryptionNonce");
+function convertPoseidonHashToU256(value) {
+  return convertBn254FieldElementToU256(convertPoseidonHashToBn254FieldElement(value));
+}
+__name(convertPoseidonHashToU256, "convertPoseidonHashToU256");
+function convertU256ToPoseidonHash(value) {
+  return convertBn254FieldElementToPoseidonHash(convertU256ToBn254FieldElement(value));
+}
+__name(convertU256ToPoseidonHash, "convertU256ToPoseidonHash");
+function convertPoseidonPlaintextToU256(value) {
+  return convertBn254FieldElementToU256(convertPoseidonPlaintextToBn254FieldElement(value));
+}
+__name(convertPoseidonPlaintextToU256, "convertPoseidonPlaintextToU256");
+function convertU256ToPoseidonPlaintext(value) {
+  return convertBn254FieldElementToPoseidonPlaintext(convertU256ToBn254FieldElement(value));
+}
+__name(convertU256ToPoseidonPlaintext, "convertU256ToPoseidonPlaintext");
+function convertPoseidonKeyToU256(value) {
+  return convertBn254FieldElementToU256(convertPoseidonKeyToBn254FieldElement(value));
+}
+__name(convertPoseidonKeyToU256, "convertPoseidonKeyToU256");
+function convertU256ToPoseidonKey(value) {
+  return convertBn254FieldElementToPoseidonKey(convertU256ToBn254FieldElement(value));
+}
+__name(convertU256ToPoseidonKey, "convertU256ToPoseidonKey");
+function convertPoseidonCiphertextToU256(value) {
+  return convertBn254FieldElementToU256(convertPoseidonCiphertextToBn254FieldElement(value));
+}
+__name(convertPoseidonCiphertextToU256, "convertPoseidonCiphertextToU256");
+function convertU256ToPoseidonCiphertext(value) {
+  return convertBn254FieldElementToPoseidonCiphertext(convertU256ToBn254FieldElement(value));
+}
+__name(convertU256ToPoseidonCiphertext, "convertU256ToPoseidonCiphertext");
+function convertRcPlaintextToU256(value) {
+  return convertCurve25519FieldElementToU256(convertRcPlaintextToCurve25519FieldElement(value));
+}
+__name(convertRcPlaintextToU256, "convertRcPlaintextToU256");
+function convertU256ToRcPlaintext(value) {
+  return convertCurve25519FieldElementToRcPlaintext(convertU256ToCurve25519FieldElement(value));
+}
+__name(convertU256ToRcPlaintext, "convertU256ToRcPlaintext");
+function convertRcCiphertextToU256(value) {
+  return convertCurve25519FieldElementToU256(convertRcCiphertextToCurve25519FieldElement(value));
+}
+__name(convertRcCiphertextToU256, "convertRcCiphertextToU256");
+function convertU256ToRcCiphertext(value) {
+  return convertCurve25519FieldElementToRcCiphertext(convertU256ToCurve25519FieldElement(value));
+}
+__name(convertU256ToRcCiphertext, "convertU256ToRcCiphertext");
+function convertRcKeyToU256(value) {
+  return convertCurve25519FieldElementToU256(convertRcKeyToCurve25519FieldElement(value));
+}
+__name(convertRcKeyToU256, "convertRcKeyToU256");
+function convertU256ToRcKey(value) {
+  return convertCurve25519FieldElementToRcKey(convertU256ToCurve25519FieldElement(value));
+}
+__name(convertU256ToRcKey, "convertU256ToRcKey");
+function convertRcCounterToU256(value) {
+  return convertCurve25519FieldElementToU256(convertRcCounterToCurve25519FieldElement(value));
+}
+__name(convertRcCounterToU256, "convertRcCounterToU256");
+function convertU256ToRcCounter(value) {
+  return convertCurve25519FieldElementToRcCounter(convertU256ToCurve25519FieldElement(value));
+}
+__name(convertU256ToRcCounter, "convertU256ToRcCounter");
+function convertBn254FieldElementToMasterViewingKey(value) {
+  assertBn254FieldElement(value);
+  assertMasterViewingKey(value);
+  return value;
+}
+__name(convertBn254FieldElementToMasterViewingKey, "convertBn254FieldElementToMasterViewingKey");
+function convertBn254FieldElementToYearlyViewingKey(value) {
+  assertBn254FieldElement(value);
+  assertYearlyViewingKey(value);
+  return value;
+}
+__name(convertBn254FieldElementToYearlyViewingKey, "convertBn254FieldElementToYearlyViewingKey");
+function convertBn254FieldElementToMonthlyViewingKey(value) {
+  assertBn254FieldElement(value);
+  assertMonthlyViewingKey(value);
+  return value;
+}
+__name(convertBn254FieldElementToMonthlyViewingKey, "convertBn254FieldElementToMonthlyViewingKey");
+function convertBn254FieldElementToDailyViewingKey(value) {
+  assertBn254FieldElement(value);
+  assertDailyViewingKey(value);
+  return value;
+}
+__name(convertBn254FieldElementToDailyViewingKey, "convertBn254FieldElementToDailyViewingKey");
+function convertBn254FieldElementToMintViewingKey(value) {
+  assertBn254FieldElement(value);
+  assertMintViewingKey(value);
+  return value;
+}
+__name(convertBn254FieldElementToMintViewingKey, "convertBn254FieldElementToMintViewingKey");
+
+// src/common/converters/unsigned-integers.ts
+function convertU8ToU16(value) {
+  assertU8(value);
+  assertU16(value);
+  return value;
+}
+__name(convertU8ToU16, "convertU8ToU16");
+function convertU8ToU32(value) {
+  assertU8(value);
+  assertU32(value);
+  return value;
+}
+__name(convertU8ToU32, "convertU8ToU32");
+function convertU8ToU64(value) {
+  assertU8(value);
+  assertU64(value);
+  return value;
+}
+__name(convertU8ToU64, "convertU8ToU64");
+function convertU8ToU128(value) {
+  assertU8(value);
+  assertU128(value);
+  return value;
+}
+__name(convertU8ToU128, "convertU8ToU128");
+function convertU8ToU256(value) {
+  assertU8(value);
+  assertU256(value);
+  return value;
+}
+__name(convertU8ToU256, "convertU8ToU256");
+function convertU8ToU512(value) {
+  assertU8(value);
+  assertU512(value);
+  return value;
+}
+__name(convertU8ToU512, "convertU8ToU512");
+function convertU8ToU1024(value) {
+  assertU8(value);
+  assertU1024(value);
+  return value;
+}
+__name(convertU8ToU1024, "convertU8ToU1024");
+function convertU16ToU32(value) {
+  assertU16(value);
+  assertU32(value);
+  return value;
+}
+__name(convertU16ToU32, "convertU16ToU32");
+function convertU16ToU64(value) {
+  assertU16(value);
+  assertU64(value);
+  return value;
+}
+__name(convertU16ToU64, "convertU16ToU64");
+function convertU16ToU128(value) {
+  assertU16(value);
+  assertU128(value);
+  return value;
+}
+__name(convertU16ToU128, "convertU16ToU128");
+function convertU16ToU256(value) {
+  assertU16(value);
+  assertU256(value);
+  return value;
+}
+__name(convertU16ToU256, "convertU16ToU256");
+function convertU16ToU512(value) {
+  assertU16(value);
+  assertU512(value);
+  return value;
+}
+__name(convertU16ToU512, "convertU16ToU512");
+function convertU16ToU1024(value) {
+  assertU16(value);
+  assertU1024(value);
+  return value;
+}
+__name(convertU16ToU1024, "convertU16ToU1024");
+function convertU32ToU64(value) {
+  assertU32(value);
+  assertU64(value);
+  return value;
+}
+__name(convertU32ToU64, "convertU32ToU64");
+function convertU32ToU128(value) {
+  assertU32(value);
+  assertU128(value);
+  return value;
+}
+__name(convertU32ToU128, "convertU32ToU128");
+function convertU32ToU256(value) {
+  assertU32(value);
+  assertU256(value);
+  return value;
+}
+__name(convertU32ToU256, "convertU32ToU256");
+function convertU32ToU512(value) {
+  assertU32(value);
+  assertU512(value);
+  return value;
+}
+__name(convertU32ToU512, "convertU32ToU512");
+function convertU32ToU1024(value) {
+  assertU32(value);
+  assertU1024(value);
+  return value;
+}
+__name(convertU32ToU1024, "convertU32ToU1024");
+function convertU64ToU128(value) {
+  assertU64(value);
+  assertU128(value);
+  return value;
+}
+__name(convertU64ToU128, "convertU64ToU128");
+function convertU64ToU256(value) {
+  assertU64(value);
+  assertU256(value);
+  return value;
+}
+__name(convertU64ToU256, "convertU64ToU256");
+function convertU64ToU512(value) {
+  assertU64(value);
+  assertU512(value);
+  return value;
+}
+__name(convertU64ToU512, "convertU64ToU512");
+function convertU64ToU1024(value) {
+  assertU64(value);
+  assertU1024(value);
+  return value;
+}
+__name(convertU64ToU1024, "convertU64ToU1024");
+function convertU128ToU256(value) {
+  assertU128(value);
+  assertU256(value);
+  return value;
+}
+__name(convertU128ToU256, "convertU128ToU256");
+function convertU128ToU512(value) {
+  assertU128(value);
+  assertU512(value);
+  return value;
+}
+__name(convertU128ToU512, "convertU128ToU512");
+function convertU128ToU1024(value) {
+  assertU128(value);
+  assertU1024(value);
+  return value;
+}
+__name(convertU128ToU1024, "convertU128ToU1024");
+function convertU256ToU512(value) {
+  assertU256(value);
+  assertU512(value);
+  return value;
+}
+__name(convertU256ToU512, "convertU256ToU512");
+function convertU256ToU1024(value) {
+  assertU256(value);
+  assertU1024(value);
+  return value;
+}
+__name(convertU256ToU1024, "convertU256ToU1024");
+function convertU512ToU1024(value) {
+  assertU512(value);
+  assertU1024(value);
+  return value;
+}
+__name(convertU512ToU1024, "convertU512ToU1024");
+function convertU16ToU8(value) {
+  assertU16(value);
+  if (value > U8_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds U8 maximum of ${String(U8_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U16",
+      targetType: "U8",
+      reason: `Value must be <= ${String(U8_MAX)}`
+    });
+  }
+  assertU8(value);
+  return value;
+}
+__name(convertU16ToU8, "convertU16ToU8");
+function convertU32ToU8(value) {
+  assertU32(value);
+  if (value > U8_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds U8 maximum of ${String(U8_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U32",
+      targetType: "U8",
+      reason: `Value must be <= ${String(U8_MAX)}`
+    });
+  }
+  assertU8(value);
+  return value;
+}
+__name(convertU32ToU8, "convertU32ToU8");
+function convertU32ToU16(value) {
+  assertU32(value);
+  if (value > U16_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds U16 maximum of ${String(U16_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U32",
+      targetType: "U16",
+      reason: `Value must be <= ${String(U16_MAX)}`
+    });
+  }
+  assertU16(value);
+  return value;
+}
+__name(convertU32ToU16, "convertU32ToU16");
+function convertU64ToU8(value) {
+  assertU64(value);
+  if (value > U8_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds U8 maximum of ${String(U8_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U64",
+      targetType: "U8",
+      reason: `Value must be <= ${String(U8_MAX)}`
+    });
+  }
+  assertU8(value);
+  return value;
+}
+__name(convertU64ToU8, "convertU64ToU8");
+function convertU64ToU16(value) {
+  assertU64(value);
+  if (value > U16_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds U16 maximum of ${String(U16_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U64",
+      targetType: "U16",
+      reason: `Value must be <= ${String(U16_MAX)}`
+    });
+  }
+  assertU16(value);
+  return value;
+}
+__name(convertU64ToU16, "convertU64ToU16");
+function convertU64ToU32(value) {
+  assertU64(value);
+  if (value > U32_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds U32 maximum of ${String(U32_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U64",
+      targetType: "U32",
+      reason: `Value must be <= ${String(U32_MAX)}`
+    });
+  }
+  assertU32(value);
+  return value;
+}
+__name(convertU64ToU32, "convertU64ToU32");
+function convertU128ToU8(value) {
+  assertU128(value);
+  if (value > U8_MAX) {
+    throw new ConversionError(`Value exceeds U8 maximum of ${String(U8_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U128",
+      targetType: "U8",
+      reason: `Value must be <= ${String(U8_MAX)}`
+    });
+  }
+  assertU8(value);
+  return value;
+}
+__name(convertU128ToU8, "convertU128ToU8");
+function convertU128ToU16(value) {
+  assertU128(value);
+  if (value > U16_MAX) {
+    throw new ConversionError(`Value exceeds U16 maximum of ${String(U16_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U128",
+      targetType: "U16",
+      reason: `Value must be <= ${String(U16_MAX)}`
+    });
+  }
+  assertU16(value);
+  return value;
+}
+__name(convertU128ToU16, "convertU128ToU16");
+function convertU128ToU32(value) {
+  assertU128(value);
+  if (value > U32_MAX) {
+    throw new ConversionError(`Value exceeds U32 maximum of ${String(U32_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U128",
+      targetType: "U32",
+      reason: `Value must be <= ${String(U32_MAX)}`
+    });
+  }
+  assertU32(value);
+  return value;
+}
+__name(convertU128ToU32, "convertU128ToU32");
+function convertU128ToU64(value) {
+  assertU128(value);
+  if (value > U64_MAX) {
+    throw new ConversionError(`Value exceeds U64 maximum`, {
+      sourceValue: value,
+      sourceType: "U128",
+      targetType: "U64",
+      reason: `Value must be <= 2^64 - 1`
+    });
+  }
+  assertU64(value);
+  return value;
+}
+__name(convertU128ToU64, "convertU128ToU64");
+function convertU256ToU8(value) {
+  assertU256(value);
+  if (value > U8_MAX) {
+    throw new ConversionError(`Value exceeds U8 maximum of ${String(U8_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U256",
+      targetType: "U8",
+      reason: `Value must be <= ${String(U8_MAX)}`
+    });
+  }
+  assertU8(value);
+  return value;
+}
+__name(convertU256ToU8, "convertU256ToU8");
+function convertU256ToU16(value) {
+  assertU256(value);
+  if (value > U16_MAX) {
+    throw new ConversionError(`Value exceeds U16 maximum of ${String(U16_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U256",
+      targetType: "U16",
+      reason: `Value must be <= ${String(U16_MAX)}`
+    });
+  }
+  assertU16(value);
+  return value;
+}
+__name(convertU256ToU16, "convertU256ToU16");
+function convertU256ToU32(value) {
+  assertU256(value);
+  if (value > U32_MAX) {
+    throw new ConversionError(`Value exceeds U32 maximum of ${String(U32_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U256",
+      targetType: "U32",
+      reason: `Value must be <= ${String(U32_MAX)}`
+    });
+  }
+  assertU32(value);
+  return value;
+}
+__name(convertU256ToU32, "convertU256ToU32");
+function convertU256ToU64(value) {
+  assertU256(value);
+  if (value > U64_MAX) {
+    throw new ConversionError(`Value exceeds U64 maximum`, {
+      sourceValue: value,
+      sourceType: "U256",
+      targetType: "U64",
+      reason: `Value must be <= 2^64 - 1`
+    });
+  }
+  assertU64(value);
+  return value;
+}
+__name(convertU256ToU64, "convertU256ToU64");
+function convertU256ToU128(value) {
+  assertU256(value);
+  if (value > U128_MAX) {
+    throw new ConversionError(`Value exceeds U128 maximum`, {
+      sourceValue: value,
+      sourceType: "U256",
+      targetType: "U128",
+      reason: `Value must be <= 2^128 - 1`
+    });
+  }
+  assertU128(value);
+  return value;
+}
+__name(convertU256ToU128, "convertU256ToU128");
+function convertU512ToU8(value) {
+  assertU512(value);
+  if (value > U8_MAX) {
+    throw new ConversionError(`Value exceeds U8 maximum of ${String(U8_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U512",
+      targetType: "U8",
+      reason: `Value must be <= ${String(U8_MAX)}`
+    });
+  }
+  assertU8(value);
+  return value;
+}
+__name(convertU512ToU8, "convertU512ToU8");
+function convertU512ToU16(value) {
+  assertU512(value);
+  if (value > U16_MAX) {
+    throw new ConversionError(`Value exceeds U16 maximum of ${String(U16_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U512",
+      targetType: "U16",
+      reason: `Value must be <= ${String(U16_MAX)}`
+    });
+  }
+  assertU16(value);
+  return value;
+}
+__name(convertU512ToU16, "convertU512ToU16");
+function convertU512ToU32(value) {
+  assertU512(value);
+  if (value > U32_MAX) {
+    throw new ConversionError(`Value exceeds U32 maximum of ${String(U32_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U512",
+      targetType: "U32",
+      reason: `Value must be <= ${String(U32_MAX)}`
+    });
+  }
+  assertU32(value);
+  return value;
+}
+__name(convertU512ToU32, "convertU512ToU32");
+function convertU512ToU64(value) {
+  assertU512(value);
+  if (value > U64_MAX) {
+    throw new ConversionError(`Value exceeds U64 maximum`, {
+      sourceValue: value,
+      sourceType: "U512",
+      targetType: "U64",
+      reason: `Value must be <= 2^64 - 1`
+    });
+  }
+  assertU64(value);
+  return value;
+}
+__name(convertU512ToU64, "convertU512ToU64");
+function convertU512ToU128(value) {
+  assertU512(value);
+  if (value > U128_MAX) {
+    throw new ConversionError(`Value exceeds U128 maximum`, {
+      sourceValue: value,
+      sourceType: "U512",
+      targetType: "U128",
+      reason: `Value must be <= 2^128 - 1`
+    });
+  }
+  assertU128(value);
+  return value;
+}
+__name(convertU512ToU128, "convertU512ToU128");
+function convertU512ToU256(value) {
+  assertU512(value);
+  if (value > U256_MAX) {
+    throw new ConversionError(`Value exceeds U256 maximum`, {
+      sourceValue: value,
+      sourceType: "U512",
+      targetType: "U256",
+      reason: `Value must be <= 2^256 - 1`
+    });
+  }
+  assertU256(value);
+  return value;
+}
+__name(convertU512ToU256, "convertU512ToU256");
+function convertU1024ToU8(value) {
+  assertU1024(value);
+  if (value > U8_MAX) {
+    throw new ConversionError(`Value exceeds U8 maximum of ${String(U8_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U1024",
+      targetType: "U8",
+      reason: `Value must be <= ${String(U8_MAX)}`
+    });
+  }
+  assertU8(value);
+  return value;
+}
+__name(convertU1024ToU8, "convertU1024ToU8");
+function convertU1024ToU16(value) {
+  assertU1024(value);
+  if (value > U16_MAX) {
+    throw new ConversionError(`Value exceeds U16 maximum of ${String(U16_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U1024",
+      targetType: "U16",
+      reason: `Value must be <= ${String(U16_MAX)}`
+    });
+  }
+  assertU16(value);
+  return value;
+}
+__name(convertU1024ToU16, "convertU1024ToU16");
+function convertU1024ToU32(value) {
+  assertU1024(value);
+  if (value > U32_MAX) {
+    throw new ConversionError(`Value exceeds U32 maximum of ${String(U32_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U1024",
+      targetType: "U32",
+      reason: `Value must be <= ${String(U32_MAX)}`
+    });
+  }
+  assertU32(value);
+  return value;
+}
+__name(convertU1024ToU32, "convertU1024ToU32");
+function convertU1024ToU64(value) {
+  assertU1024(value);
+  if (value > U64_MAX) {
+    throw new ConversionError(`Value exceeds U64 maximum`, {
+      sourceValue: value,
+      sourceType: "U1024",
+      targetType: "U64",
+      reason: `Value must be <= 2^64 - 1`
+    });
+  }
+  assertU64(value);
+  return value;
+}
+__name(convertU1024ToU64, "convertU1024ToU64");
+function convertU1024ToU128(value) {
+  assertU1024(value);
+  if (value > U128_MAX) {
+    throw new ConversionError(`Value exceeds U128 maximum`, {
+      sourceValue: value,
+      sourceType: "U1024",
+      targetType: "U128",
+      reason: `Value must be <= 2^128 - 1`
+    });
+  }
+  assertU128(value);
+  return value;
+}
+__name(convertU1024ToU128, "convertU1024ToU128");
+function convertU1024ToU256(value) {
+  assertU1024(value);
+  if (value > U256_MAX) {
+    throw new ConversionError(`Value exceeds U256 maximum`, {
+      sourceValue: value,
+      sourceType: "U1024",
+      targetType: "U256",
+      reason: `Value must be <= 2^256 - 1`
+    });
+  }
+  assertU256(value);
+  return value;
+}
+__name(convertU1024ToU256, "convertU1024ToU256");
+function convertU1024ToU512(value) {
+  assertU1024(value);
+  if (value > U512_MAX) {
+    throw new ConversionError(`Value exceeds U512 maximum`, {
+      sourceValue: value,
+      sourceType: "U1024",
+      targetType: "U512",
+      reason: `Value must be <= 2^512 - 1`
+    });
+  }
+  assertU512(value);
+  return value;
+}
+__name(convertU1024ToU512, "convertU1024ToU512");
+
+// src/common/converters/signed-integers.ts
+function convertI8ToI16(value) {
+  assertI8(value);
+  assertI16(value);
+  return value;
+}
+__name(convertI8ToI16, "convertI8ToI16");
+function convertI8ToI32(value) {
+  assertI8(value);
+  assertI32(value);
+  return value;
+}
+__name(convertI8ToI32, "convertI8ToI32");
+function convertI8ToI64(value) {
+  assertI8(value);
+  assertI64(value);
+  return value;
+}
+__name(convertI8ToI64, "convertI8ToI64");
+function convertI8ToI128(value) {
+  assertI8(value);
+  assertI128(value);
+  return value;
+}
+__name(convertI8ToI128, "convertI8ToI128");
+function convertI8ToI256(value) {
+  assertI8(value);
+  assertI256(value);
+  return value;
+}
+__name(convertI8ToI256, "convertI8ToI256");
+function convertI8ToI512(value) {
+  assertI8(value);
+  assertI512(value);
+  return value;
+}
+__name(convertI8ToI512, "convertI8ToI512");
+function convertI8ToI1024(value) {
+  assertI8(value);
+  assertI1024(value);
+  return value;
+}
+__name(convertI8ToI1024, "convertI8ToI1024");
+function convertI16ToI32(value) {
+  assertI16(value);
+  assertI32(value);
+  return value;
+}
+__name(convertI16ToI32, "convertI16ToI32");
+function convertI16ToI64(value) {
+  assertI16(value);
+  assertI64(value);
+  return value;
+}
+__name(convertI16ToI64, "convertI16ToI64");
+function convertI16ToI128(value) {
+  assertI16(value);
+  assertI128(value);
+  return value;
+}
+__name(convertI16ToI128, "convertI16ToI128");
+function convertI16ToI256(value) {
+  assertI16(value);
+  assertI256(value);
+  return value;
+}
+__name(convertI16ToI256, "convertI16ToI256");
+function convertI16ToI512(value) {
+  assertI16(value);
+  assertI512(value);
+  return value;
+}
+__name(convertI16ToI512, "convertI16ToI512");
+function convertI16ToI1024(value) {
+  assertI16(value);
+  assertI1024(value);
+  return value;
+}
+__name(convertI16ToI1024, "convertI16ToI1024");
+function convertI32ToI64(value) {
+  assertI32(value);
+  assertI64(value);
+  return value;
+}
+__name(convertI32ToI64, "convertI32ToI64");
+function convertI32ToI128(value) {
+  assertI32(value);
+  assertI128(value);
+  return value;
+}
+__name(convertI32ToI128, "convertI32ToI128");
+function convertI32ToI256(value) {
+  assertI32(value);
+  assertI256(value);
+  return value;
+}
+__name(convertI32ToI256, "convertI32ToI256");
+function convertI32ToI512(value) {
+  assertI32(value);
+  assertI512(value);
+  return value;
+}
+__name(convertI32ToI512, "convertI32ToI512");
+function convertI32ToI1024(value) {
+  assertI32(value);
+  assertI1024(value);
+  return value;
+}
+__name(convertI32ToI1024, "convertI32ToI1024");
+function convertI64ToI128(value) {
+  assertI64(value);
+  assertI128(value);
+  return value;
+}
+__name(convertI64ToI128, "convertI64ToI128");
+function convertI64ToI256(value) {
+  assertI64(value);
+  assertI256(value);
+  return value;
+}
+__name(convertI64ToI256, "convertI64ToI256");
+function convertI64ToI512(value) {
+  assertI64(value);
+  assertI512(value);
+  return value;
+}
+__name(convertI64ToI512, "convertI64ToI512");
+function convertI64ToI1024(value) {
+  assertI64(value);
+  assertI1024(value);
+  return value;
+}
+__name(convertI64ToI1024, "convertI64ToI1024");
+function convertI128ToI256(value) {
+  assertI128(value);
+  assertI256(value);
+  return value;
+}
+__name(convertI128ToI256, "convertI128ToI256");
+function convertI128ToI512(value) {
+  assertI128(value);
+  assertI512(value);
+  return value;
+}
+__name(convertI128ToI512, "convertI128ToI512");
+function convertI128ToI1024(value) {
+  assertI128(value);
+  assertI1024(value);
+  return value;
+}
+__name(convertI128ToI1024, "convertI128ToI1024");
+function convertI256ToI512(value) {
+  assertI256(value);
+  assertI512(value);
+  return value;
+}
+__name(convertI256ToI512, "convertI256ToI512");
+function convertI256ToI1024(value) {
+  assertI256(value);
+  assertI1024(value);
+  return value;
+}
+__name(convertI256ToI1024, "convertI256ToI1024");
+function convertI512ToI1024(value) {
+  assertI512(value);
+  assertI1024(value);
+  return value;
+}
+__name(convertI512ToI1024, "convertI512ToI1024");
+function convertI16ToI8(value) {
+  assertI16(value);
+  if (value < I8_MIN || value > I8_MAX) {
+    throw new ConversionError(
+      `Value ${String(value)} is out of range for I8 [${String(I8_MIN)}, ${String(I8_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I16",
+        targetType: "I8",
+        reason: `Value must be in range [${String(I8_MIN)}, ${String(I8_MAX)}]`
+      }
+    );
+  }
+  assertI8(value);
+  return value;
+}
+__name(convertI16ToI8, "convertI16ToI8");
+function convertI32ToI8(value) {
+  assertI32(value);
+  if (value < I8_MIN || value > I8_MAX) {
+    throw new ConversionError(
+      `Value ${String(value)} is out of range for I8 [${String(I8_MIN)}, ${String(I8_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I32",
+        targetType: "I8",
+        reason: `Value must be in range [${String(I8_MIN)}, ${String(I8_MAX)}]`
+      }
+    );
+  }
+  assertI8(value);
+  return value;
+}
+__name(convertI32ToI8, "convertI32ToI8");
+function convertI32ToI16(value) {
+  assertI32(value);
+  if (value < I16_MIN || value > I16_MAX) {
+    throw new ConversionError(
+      `Value ${String(value)} is out of range for I16 [${String(I16_MIN)}, ${String(I16_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I32",
+        targetType: "I16",
+        reason: `Value must be in range [${String(I16_MIN)}, ${String(I16_MAX)}]`
+      }
+    );
+  }
+  assertI16(value);
+  return value;
+}
+__name(convertI32ToI16, "convertI32ToI16");
+function convertI64ToI8(value) {
+  assertI64(value);
+  if (value < I8_MIN || value > I8_MAX) {
+    throw new ConversionError(
+      `Value ${String(value)} is out of range for I8 [${String(I8_MIN)}, ${String(I8_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I64",
+        targetType: "I8",
+        reason: `Value must be in range [${String(I8_MIN)}, ${String(I8_MAX)}]`
+      }
+    );
+  }
+  assertI8(value);
+  return value;
+}
+__name(convertI64ToI8, "convertI64ToI8");
+function convertI64ToI16(value) {
+  assertI64(value);
+  if (value < I16_MIN || value > I16_MAX) {
+    throw new ConversionError(
+      `Value ${String(value)} is out of range for I16 [${String(I16_MIN)}, ${String(I16_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I64",
+        targetType: "I16",
+        reason: `Value must be in range [${String(I16_MIN)}, ${String(I16_MAX)}]`
+      }
+    );
+  }
+  assertI16(value);
+  return value;
+}
+__name(convertI64ToI16, "convertI64ToI16");
+function convertI64ToI32(value) {
+  assertI64(value);
+  if (value < I32_MIN || value > I32_MAX) {
+    throw new ConversionError(
+      `Value ${String(value)} is out of range for I32 [${String(I32_MIN)}, ${String(I32_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I64",
+        targetType: "I32",
+        reason: `Value must be in range [${String(I32_MIN)}, ${String(I32_MAX)}]`
+      }
+    );
+  }
+  assertI32(value);
+  return value;
+}
+__name(convertI64ToI32, "convertI64ToI32");
+function convertI128ToI8(value) {
+  assertI128(value);
+  if (value < I8_MIN || value > I8_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I8 [${String(I8_MIN)}, ${String(I8_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I128",
+        targetType: "I8",
+        reason: `Value must be in range [${String(I8_MIN)}, ${String(I8_MAX)}]`
+      }
+    );
+  }
+  assertI8(value);
+  return value;
+}
+__name(convertI128ToI8, "convertI128ToI8");
+function convertI128ToI16(value) {
+  assertI128(value);
+  if (value < I16_MIN || value > I16_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I16 [${String(I16_MIN)}, ${String(I16_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I128",
+        targetType: "I16",
+        reason: `Value must be in range [${String(I16_MIN)}, ${String(I16_MAX)}]`
+      }
+    );
+  }
+  assertI16(value);
+  return value;
+}
+__name(convertI128ToI16, "convertI128ToI16");
+function convertI128ToI32(value) {
+  assertI128(value);
+  if (value < I32_MIN || value > I32_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I32 [${String(I32_MIN)}, ${String(I32_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I128",
+        targetType: "I32",
+        reason: `Value must be in range [${String(I32_MIN)}, ${String(I32_MAX)}]`
+      }
+    );
+  }
+  assertI32(value);
+  return value;
+}
+__name(convertI128ToI32, "convertI128ToI32");
+function convertI128ToI64(value) {
+  assertI128(value);
+  if (value < I64_MIN || value > 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]`
+    });
+  }
+  assertI64(value);
+  return value;
+}
+__name(convertI128ToI64, "convertI128ToI64");
+function convertI256ToI8(value) {
+  assertI256(value);
+  if (value < I8_MIN || value > I8_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I8 [${String(I8_MIN)}, ${String(I8_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I256",
+        targetType: "I8",
+        reason: `Value must be in range [${String(I8_MIN)}, ${String(I8_MAX)}]`
+      }
+    );
+  }
+  assertI8(value);
+  return value;
+}
+__name(convertI256ToI8, "convertI256ToI8");
+function convertI256ToI16(value) {
+  assertI256(value);
+  if (value < I16_MIN || value > I16_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I16 [${String(I16_MIN)}, ${String(I16_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I256",
+        targetType: "I16",
+        reason: `Value must be in range [${String(I16_MIN)}, ${String(I16_MAX)}]`
+      }
+    );
+  }
+  assertI16(value);
+  return value;
+}
+__name(convertI256ToI16, "convertI256ToI16");
+function convertI256ToI32(value) {
+  assertI256(value);
+  if (value < I32_MIN || value > I32_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I32 [${String(I32_MIN)}, ${String(I32_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I256",
+        targetType: "I32",
+        reason: `Value must be in range [${String(I32_MIN)}, ${String(I32_MAX)}]`
+      }
+    );
+  }
+  assertI32(value);
+  return value;
+}
+__name(convertI256ToI32, "convertI256ToI32");
+function convertI256ToI64(value) {
+  assertI256(value);
+  if (value < I64_MIN || value > 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]`
+    });
+  }
+  assertI64(value);
+  return value;
+}
+__name(convertI256ToI64, "convertI256ToI64");
+function convertI256ToI128(value) {
+  assertI256(value);
+  if (value < I128_MIN || value > 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]`
+    });
+  }
+  assertI128(value);
+  return value;
+}
+__name(convertI256ToI128, "convertI256ToI128");
+function convertI512ToI8(value) {
+  assertI512(value);
+  if (value < I8_MIN || value > I8_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I8 [${String(I8_MIN)}, ${String(I8_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I512",
+        targetType: "I8",
+        reason: `Value must be in range [${String(I8_MIN)}, ${String(I8_MAX)}]`
+      }
+    );
+  }
+  assertI8(value);
+  return value;
+}
+__name(convertI512ToI8, "convertI512ToI8");
+function convertI512ToI16(value) {
+  assertI512(value);
+  if (value < I16_MIN || value > I16_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I16 [${String(I16_MIN)}, ${String(I16_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I512",
+        targetType: "I16",
+        reason: `Value must be in range [${String(I16_MIN)}, ${String(I16_MAX)}]`
+      }
+    );
+  }
+  assertI16(value);
+  return value;
+}
+__name(convertI512ToI16, "convertI512ToI16");
+function convertI512ToI32(value) {
+  assertI512(value);
+  if (value < I32_MIN || value > I32_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I32 [${String(I32_MIN)}, ${String(I32_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I512",
+        targetType: "I32",
+        reason: `Value must be in range [${String(I32_MIN)}, ${String(I32_MAX)}]`
+      }
+    );
+  }
+  assertI32(value);
+  return value;
+}
+__name(convertI512ToI32, "convertI512ToI32");
+function convertI512ToI64(value) {
+  assertI512(value);
+  if (value < I64_MIN || value > 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]`
+    });
+  }
+  assertI64(value);
+  return value;
+}
+__name(convertI512ToI64, "convertI512ToI64");
+function convertI512ToI128(value) {
+  assertI512(value);
+  if (value < I128_MIN || value > 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]`
+    });
+  }
+  assertI128(value);
+  return value;
+}
+__name(convertI512ToI128, "convertI512ToI128");
+function convertI512ToI256(value) {
+  assertI512(value);
+  if (value < I256_MIN || value > 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]`
+    });
+  }
+  assertI256(value);
+  return value;
+}
+__name(convertI512ToI256, "convertI512ToI256");
+function convertI1024ToI8(value) {
+  assertI1024(value);
+  if (value < I8_MIN || value > I8_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I8 [${String(I8_MIN)}, ${String(I8_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I1024",
+        targetType: "I8",
+        reason: `Value must be in range [${String(I8_MIN)}, ${String(I8_MAX)}]`
+      }
+    );
+  }
+  assertI8(value);
+  return value;
+}
+__name(convertI1024ToI8, "convertI1024ToI8");
+function convertI1024ToI16(value) {
+  assertI1024(value);
+  if (value < I16_MIN || value > I16_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I16 [${String(I16_MIN)}, ${String(I16_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I1024",
+        targetType: "I16",
+        reason: `Value must be in range [${String(I16_MIN)}, ${String(I16_MAX)}]`
+      }
+    );
+  }
+  assertI16(value);
+  return value;
+}
+__name(convertI1024ToI16, "convertI1024ToI16");
+function convertI1024ToI32(value) {
+  assertI1024(value);
+  if (value < I32_MIN || value > I32_MAX) {
+    throw new ConversionError(
+      `Value is out of range for I32 [${String(I32_MIN)}, ${String(I32_MAX)}]`,
+      {
+        sourceValue: value,
+        sourceType: "I1024",
+        targetType: "I32",
+        reason: `Value must be in range [${String(I32_MIN)}, ${String(I32_MAX)}]`
+      }
+    );
+  }
+  assertI32(value);
+  return value;
+}
+__name(convertI1024ToI32, "convertI1024ToI32");
+function convertI1024ToI64(value) {
+  assertI1024(value);
+  if (value < I64_MIN || value > 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]`
+    });
+  }
+  assertI64(value);
+  return value;
+}
+__name(convertI1024ToI64, "convertI1024ToI64");
+function convertI1024ToI128(value) {
+  assertI1024(value);
+  if (value < I128_MIN || value > 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]`
+    });
+  }
+  assertI128(value);
+  return value;
+}
+__name(convertI1024ToI128, "convertI1024ToI128");
+function convertI1024ToI256(value) {
+  assertI1024(value);
+  if (value < I256_MIN || value > 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]`
+    });
+  }
+  assertI256(value);
+  return value;
+}
+__name(convertI1024ToI256, "convertI1024ToI256");
+function convertI1024ToI512(value) {
+  assertI1024(value);
+  if (value < I512_MIN || value > 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]`
+    });
+  }
+  assertI512(value);
+  return value;
+}
+__name(convertI1024ToI512, "convertI1024ToI512");
+
+// src/common/converters/sign-conversions.ts
+function convertI8ToU8(value) {
+  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"
+    });
+  }
+  assertU8(value);
+  return value;
+}
+__name(convertI8ToU8, "convertI8ToU8");
+function convertI16ToU16(value) {
+  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"
+    });
+  }
+  assertU16(value);
+  return value;
+}
+__name(convertI16ToU16, "convertI16ToU16");
+function convertI32ToU32(value) {
+  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"
+    });
+  }
+  assertU32(value);
+  return value;
+}
+__name(convertI32ToU32, "convertI32ToU32");
+function convertI64ToU64(value) {
+  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"
+    });
+  }
+  assertU64(value);
+  return value;
+}
+__name(convertI64ToU64, "convertI64ToU64");
+function convertI128ToU128(value) {
+  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"
+    });
+  }
+  assertU128(value);
+  return value;
+}
+__name(convertI128ToU128, "convertI128ToU128");
+function convertI256ToU256(value) {
+  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"
+    });
+  }
+  assertU256(value);
+  return value;
+}
+__name(convertI256ToU256, "convertI256ToU256");
+function convertI512ToU512(value) {
+  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"
+    });
+  }
+  assertU512(value);
+  return value;
+}
+__name(convertI512ToU512, "convertI512ToU512");
+function convertI1024ToU1024(value) {
+  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"
+    });
+  }
+  assertU1024(value);
+  return value;
+}
+__name(convertI1024ToU1024, "convertI1024ToU1024");
+function convertU8ToI8(value) {
+  assertU8(value);
+  if (value > I8_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds I8 maximum of ${String(I8_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U8",
+      targetType: "I8",
+      reason: `Value must be <= ${String(I8_MAX)}`
+    });
+  }
+  assertI8(value);
+  return value;
+}
+__name(convertU8ToI8, "convertU8ToI8");
+function convertU16ToI16(value) {
+  assertU16(value);
+  if (value > I16_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds I16 maximum of ${String(I16_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U16",
+      targetType: "I16",
+      reason: `Value must be <= ${String(I16_MAX)}`
+    });
+  }
+  assertI16(value);
+  return value;
+}
+__name(convertU16ToI16, "convertU16ToI16");
+function convertU32ToI32(value) {
+  assertU32(value);
+  if (value > I32_MAX) {
+    throw new ConversionError(`Value ${String(value)} exceeds I32 maximum of ${String(I32_MAX)}`, {
+      sourceValue: value,
+      sourceType: "U32",
+      targetType: "I32",
+      reason: `Value must be <= ${String(I32_MAX)}`
+    });
+  }
+  assertI32(value);
+  return value;
+}
+__name(convertU32ToI32, "convertU32ToI32");
+function convertU64ToI64(value) {
+  assertU64(value);
+  if (value > I64_MAX) {
+    throw new ConversionError(`Value exceeds I64 maximum`, {
+      sourceValue: value,
+      sourceType: "U64",
+      targetType: "I64",
+      reason: `Value must be <= 2^63 - 1`
+    });
+  }
+  assertI64(value);
+  return value;
+}
+__name(convertU64ToI64, "convertU64ToI64");
+function convertU128ToI128(value) {
+  assertU128(value);
+  if (value > I128_MAX) {
+    throw new ConversionError(`Value exceeds I128 maximum`, {
+      sourceValue: value,
+      sourceType: "U128",
+      targetType: "I128",
+      reason: `Value must be <= 2^127 - 1`
+    });
+  }
+  assertI128(value);
+  return value;
+}
+__name(convertU128ToI128, "convertU128ToI128");
+function convertU256ToI256(value) {
+  assertU256(value);
+  if (value > I256_MAX) {
+    throw new ConversionError(`Value exceeds I256 maximum`, {
+      sourceValue: value,
+      sourceType: "U256",
+      targetType: "I256",
+      reason: `Value must be <= 2^255 - 1`
+    });
+  }
+  assertI256(value);
+  return value;
+}
+__name(convertU256ToI256, "convertU256ToI256");
+function convertU512ToI512(value) {
+  assertU512(value);
+  if (value > I512_MAX) {
+    throw new ConversionError(`Value exceeds I512 maximum`, {
+      sourceValue: value,
+      sourceType: "U512",
+      targetType: "I512",
+      reason: `Value must be <= 2^511 - 1`
+    });
+  }
+  assertI512(value);
+  return value;
+}
+__name(convertU512ToI512, "convertU512ToI512");
+function convertU1024ToI1024(value) {
+  assertU1024(value);
+  if (value > I1024_MAX) {
+    throw new ConversionError(`Value exceeds I1024 maximum`, {
+      sourceValue: value,
+      sourceType: "U1024",
+      targetType: "I1024",
+      reason: `Value must be <= 2^1023 - 1`
+    });
+  }
+  assertI1024(value);
+  return value;
+}
+__name(convertU1024ToI1024, "convertU1024ToI1024");
+
+// src/common/converters/number-conversions.ts
+var MAX_SAFE = Number.MAX_SAFE_INTEGER;
+var MIN_SAFE = Number.MIN_SAFE_INTEGER;
+var MAX_SAFE_BIGINT = BigInt(MAX_SAFE);
+var MIN_SAFE_BIGINT = BigInt(MIN_SAFE);
+function convertNumberToU8(value) {
+  assertNumberInRange(value, 0, Number(U8_MAX), "U8");
+  const result = BigInt(value);
+  assertU8(result);
+  return result;
+}
+__name(convertNumberToU8, "convertNumberToU8");
+function convertNumberToU16(value) {
+  assertNumberInRange(value, 0, Number(U16_MAX), "U16");
+  const result = BigInt(value);
+  assertU16(result);
+  return result;
+}
+__name(convertNumberToU16, "convertNumberToU16");
+function convertNumberToU32(value) {
+  assertNumberInRange(value, 0, Number(U32_MAX), "U32");
+  const result = BigInt(value);
+  assertU32(result);
+  return result;
+}
+__name(convertNumberToU32, "convertNumberToU32");
+function convertNumberToU64(value) {
+  assertNumberInRange(value, 0, MAX_SAFE, "U64");
+  const result = BigInt(value);
+  assertU64(result);
+  return result;
+}
+__name(convertNumberToU64, "convertNumberToU64");
+function convertNumberToU128(value) {
+  assertNumberInRange(value, 0, MAX_SAFE, "U128");
+  const result = BigInt(value);
+  assertU128(result);
+  return result;
+}
+__name(convertNumberToU128, "convertNumberToU128");
+function convertNumberToU256(value) {
+  assertNumberInRange(value, 0, MAX_SAFE, "U256");
+  const result = BigInt(value);
+  assertU256(result);
+  return result;
+}
+__name(convertNumberToU256, "convertNumberToU256");
+function convertNumberToU512(value) {
+  assertNumberInRange(value, 0, MAX_SAFE, "U512");
+  const result = BigInt(value);
+  assertU512(result);
+  return result;
+}
+__name(convertNumberToU512, "convertNumberToU512");
+function convertNumberToU1024(value) {
+  assertNumberInRange(value, 0, MAX_SAFE, "U1024");
+  const result = BigInt(value);
+  assertU1024(result);
+  return result;
+}
+__name(convertNumberToU1024, "convertNumberToU1024");
+function convertU8ToNumber(value) {
+  return Number(value);
+}
+__name(convertU8ToNumber, "convertU8ToNumber");
+function convertU16ToNumber(value) {
+  return Number(value);
+}
+__name(convertU16ToNumber, "convertU16ToNumber");
+function convertU32ToNumber(value) {
+  return Number(value);
+}
+__name(convertU32ToNumber, "convertU32ToNumber");
+function convertU64ToNumber(value) {
+  if (value > MAX_SAFE_BIGINT) {
+    throw new ConversionError(
+      `U64 value ${String(value)} exceeds Number.MAX_SAFE_INTEGER`,
+      { sourceValue: value, sourceType: "U64", targetType: "number", reason: "Value exceeds 2^53-1" }
+    );
+  }
+  return Number(value);
+}
+__name(convertU64ToNumber, "convertU64ToNumber");
+function convertU128ToNumber(value) {
+  if (value > MAX_SAFE_BIGINT) {
+    throw new ConversionError(
+      `U128 value ${String(value)} exceeds Number.MAX_SAFE_INTEGER`,
+      { sourceValue: value, sourceType: "U128", targetType: "number", reason: "Value exceeds 2^53-1" }
+    );
+  }
+  return Number(value);
+}
+__name(convertU128ToNumber, "convertU128ToNumber");
+function convertU256ToNumber(value) {
+  if (value > MAX_SAFE_BIGINT) {
+    throw new ConversionError(
+      `U256 value ${String(value)} exceeds Number.MAX_SAFE_INTEGER`,
+      { sourceValue: value, sourceType: "U256", targetType: "number", reason: "Value exceeds 2^53-1" }
+    );
+  }
+  return Number(value);
+}
+__name(convertU256ToNumber, "convertU256ToNumber");
+function convertU512ToNumber(value) {
+  if (value > MAX_SAFE_BIGINT) {
+    throw new ConversionError(
+      `U512 value ${String(value)} exceeds Number.MAX_SAFE_INTEGER`,
+      { sourceValue: value, sourceType: "U512", targetType: "number", reason: "Value exceeds 2^53-1" }
+    );
+  }
+  return Number(value);
+}
+__name(convertU512ToNumber, "convertU512ToNumber");
+function convertU1024ToNumber(value) {
+  if (value > MAX_SAFE_BIGINT) {
+    throw new ConversionError(
+      `U1024 value ${String(value)} exceeds Number.MAX_SAFE_INTEGER`,
+      { sourceValue: value, sourceType: "U1024", targetType: "number", reason: "Value exceeds 2^53-1" }
+    );
+  }
+  return Number(value);
+}
+__name(convertU1024ToNumber, "convertU1024ToNumber");
+function convertNumberToI8(value) {
+  assertNumberInRange(value, Number(I8_MIN), Number(I8_MAX), "I8");
+  const result = BigInt(value);
+  assertI8(result);
+  return result;
+}
+__name(convertNumberToI8, "convertNumberToI8");
+function convertNumberToI16(value) {
+  assertNumberInRange(value, Number(I16_MIN), Number(I16_MAX), "I16");
+  const result = BigInt(value);
+  assertI16(result);
+  return result;
+}
+__name(convertNumberToI16, "convertNumberToI16");
+function convertNumberToI32(value) {
+  assertNumberInRange(value, Number(I32_MIN), Number(I32_MAX), "I32");
+  const result = BigInt(value);
+  assertI32(result);
+  return result;
+}
+__name(convertNumberToI32, "convertNumberToI32");
+function convertNumberToI64(value) {
+  assertNumberInRange(value, MIN_SAFE, MAX_SAFE, "I64");
+  const result = BigInt(value);
+  assertI64(result);
+  return result;
+}
+__name(convertNumberToI64, "convertNumberToI64");
+function convertNumberToI128(value) {
+  assertNumberInRange(value, MIN_SAFE, MAX_SAFE, "I128");
+  const result = BigInt(value);
+  assertI128(result);
+  return result;
+}
+__name(convertNumberToI128, "convertNumberToI128");
+function convertNumberToI256(value) {
+  assertNumberInRange(value, MIN_SAFE, MAX_SAFE, "I256");
+  const result = BigInt(value);
+  assertI256(result);
+  return result;
+}
+__name(convertNumberToI256, "convertNumberToI256");
+function convertNumberToI512(value) {
+  assertNumberInRange(value, MIN_SAFE, MAX_SAFE, "I512");
+  const result = BigInt(value);
+  assertI512(result);
+  return result;
+}
+__name(convertNumberToI512, "convertNumberToI512");
+function convertNumberToI1024(value) {
+  assertNumberInRange(value, MIN_SAFE, MAX_SAFE, "I1024");
+  const result = BigInt(value);
+  assertI1024(result);
+  return result;
+}
+__name(convertNumberToI1024, "convertNumberToI1024");
+function convertI8ToNumber(value) {
+  return Number(value);
+}
+__name(convertI8ToNumber, "convertI8ToNumber");
+function convertI16ToNumber(value) {
+  return Number(value);
+}
+__name(convertI16ToNumber, "convertI16ToNumber");
+function convertI32ToNumber(value) {
+  return Number(value);
+}
+__name(convertI32ToNumber, "convertI32ToNumber");
+function convertI64ToNumber(value) {
+  const v = value;
+  if (v > MAX_SAFE_BIGINT || v < MIN_SAFE_BIGINT) {
+    throw new ConversionError(
+      `I64 value ${String(value)} exceeds safe integer range`,
+      { sourceValue: value, sourceType: "I64", targetType: "number", reason: "Value outside [-(2^53-1), 2^53-1]" }
+    );
+  }
+  return Number(value);
+}
+__name(convertI64ToNumber, "convertI64ToNumber");
+function convertI128ToNumber(value) {
+  const v = value;
+  if (v > MAX_SAFE_BIGINT || v < MIN_SAFE_BIGINT) {
+    throw new ConversionError(
+      `I128 value ${String(value)} exceeds safe integer range`,
+      { sourceValue: value, sourceType: "I128", targetType: "number", reason: "Value outside [-(2^53-1), 2^53-1]" }
+    );
+  }
+  return Number(value);
+}
+__name(convertI128ToNumber, "convertI128ToNumber");
+function convertI256ToNumber(value) {
+  const v = value;
+  if (v > MAX_SAFE_BIGINT || v < MIN_SAFE_BIGINT) {
+    throw new ConversionError(
+      `I256 value ${String(value)} exceeds safe integer range`,
+      { sourceValue: value, sourceType: "I256", targetType: "number", reason: "Value outside [-(2^53-1), 2^53-1]" }
+    );
+  }
+  return Number(value);
+}
+__name(convertI256ToNumber, "convertI256ToNumber");
+function convertI512ToNumber(value) {
+  const v = value;
+  if (v > MAX_SAFE_BIGINT || v < MIN_SAFE_BIGINT) {
+    throw new ConversionError(
+      `I512 value ${String(value)} exceeds safe integer range`,
+      { sourceValue: value, sourceType: "I512", targetType: "number", reason: "Value outside [-(2^53-1), 2^53-1]" }
+    );
+  }
+  return Number(value);
+}
+__name(convertI512ToNumber, "convertI512ToNumber");
+function convertI1024ToNumber(value) {
+  const v = value;
+  if (v > MAX_SAFE_BIGINT || v < MIN_SAFE_BIGINT) {
+    throw new ConversionError(
+      `I1024 value ${String(value)} exceeds safe integer range`,
+      { sourceValue: value, sourceType: "I1024", targetType: "number", reason: "Value outside [-(2^53-1), 2^53-1]" }
+    );
+  }
+  return Number(value);
+}
+__name(convertI1024ToNumber, "convertI1024ToNumber");
+
+// src/common/math-utils.ts
+function generateRandomU128() {
+  const bytes = new Uint8Array(U128_BYTE_LENGTH);
+  crypto.getRandomValues(bytes);
+  let result = 0n;
+  for (let index = 0; index < U128_BYTE_LENGTH; index++) {
+    result |= BigInt(bytes[index]) << BigInt(index * 8);
+  }
+  return result;
+}
+__name(generateRandomU128, "generateRandomU128");
+function generateRandomU64() {
+  const bytes = new Uint8Array(U64_BYTE_LENGTH);
+  crypto.getRandomValues(bytes);
+  let result = 0n;
+  for (let index = 0; index < U64_BYTE_LENGTH; index++) {
+    result |= BigInt(bytes[index]) << BigInt(index * 8);
+  }
+  return result;
+}
+__name(generateRandomU64, "generateRandomU64");
+function generateRandomU256() {
+  const bytes = new Uint8Array(U256_BYTE_LENGTH);
+  crypto.getRandomValues(bytes);
+  let result = 0n;
+  for (let index = 0; index < U256_BYTE_LENGTH; index++) {
+    result |= BigInt(bytes[index]) << BigInt(index * 8);
+  }
+  return result;
+}
+__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;
+}
+__name(bigintToBinaryArrayLSB, "bigintToBinaryArrayLSB");
+
+// src/common/arcium.ts
+function generateRandomNonce() {
+  const nonce = generateRandomU128();
+  assertRcEncryptionNonce(nonce);
+  return nonce;
+}
+__name(generateRandomNonce, "generateRandomNonce");
+function generateComputationOffset() {
+  return generateRandomU64();
+}
+__name(generateComputationOffset, "generateComputationOffset");
+function extractClusterOffsetFromMxeAccount(mxeAccount) {
+  if (!mxeAccount.exists) {
+    throw new UmbraError(
+      "MXE account not found on-chain. Cannot determine cluster offset."
+    );
+  }
+  const decoded = decodeMXEAccount(mxeAccount);
+  const cluster = decoded.data.cluster;
+  if (cluster.__option === "None") {
+    throw new UmbraError(
+      "MXE account has no cluster set. The Arcium cluster may not be initialized."
+    );
+  }
+  return cluster.value;
+}
+__name(extractClusterOffsetFromMxeAccount, "extractClusterOffsetFromMxeAccount");
+var cachedAddressEncoder = null;
+function getEncoder() {
+  cachedAddressEncoder ??= getAddressEncoder();
+  return cachedAddressEncoder;
+}
+__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 };
+}
+__name(splitAddressToLowHigh, "splitAddressToLowHigh");
+
+// src/common/temporal/temporal.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());
+  assertYear(yearValue);
+  assertMonth(monthValue);
+  assertDay(dayValue);
+  assertHour(hourValue);
+  assertMinute(minuteValue);
+  assertSecond(secondValue);
+  return {
+    year: yearValue,
+    month: monthValue,
+    day: dayValue,
+    hour: hourValue,
+    minute: minuteValue,
+    second: secondValue
+  };
+}
+__name(extractUtcComponents, "extractUtcComponents");
+function getUtcNow() {
+  return extractUtcComponents(/* @__PURE__ */ new Date());
+}
+__name(getUtcNow, "getUtcNow");
+function getUtcNowFunction(deps) {
+  const dateProvider = deps?.dateProvider ?? (() => /* @__PURE__ */ new Date());
+  return () => extractUtcComponents(dateProvider());
+}
+__name(getUtcNowFunction, "getUtcNowFunction");
+function getExtractUtcComponentsFunction(deps) {
+  return extractUtcComponents;
+}
+__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;
+}
+__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
+  };
+}
+__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);
+}
+__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 address(encoded);
+}
+__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
+  };
+}
+__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;
+}
+__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;
+}
+__name(calculateTransferFee, "calculateTransferFee");
+function ceilDiv(numerator, denominator) {
+  if (denominator === 0n) {
+    throw new Error("Division by zero");
+  }
+  return (numerator + denominator - 1n) / denominator;
+}
+__name(ceilDiv, "ceilDiv");
+function calculateNetAmountAfterFee(feeConfig, currentEpoch, grossAmount) {
+  const fee = calculateTransferFee(feeConfig, currentEpoch, grossAmount);
+  return grossAmount - fee;
+}
+__name(calculateNetAmountAfterFee, "calculateNetAmountAfterFee");
+
+// src/common/type-helpers.ts
+function createU32(value) {
+  assertU32(value);
+  return value;
+}
+__name(createU32, "createU32");
+function createU64(value, name) {
+  assertU64(value, name);
+  return value;
+}
+__name(createU64, "createU64");
+function createU128(value, name) {
+  assertU128(value, name);
+  return value;
+}
+__name(createU128, "createU128");
+function createU256(value, name) {
+  assertU256(value, name);
+  return value;
+}
+__name(createU256, "createU256");
+function createBn254FieldElement(value, name) {
+  assertBn254FieldElement(value, name);
+  return value;
+}
+__name(createBn254FieldElement, "createBn254FieldElement");
+function createCurve25519FieldElement(value, name) {
+  assertCurve25519FieldElement(value, name);
+  return value;
+}
+__name(createCurve25519FieldElement, "createCurve25519FieldElement");
+function createPoseidonKey(value) {
+  assertPoseidonKey(value);
+  return value;
+}
+__name(createPoseidonKey, "createPoseidonKey");
+function createRcPlaintext(value, name) {
+  assertRcPlaintext(value, name);
+  return value;
+}
+__name(createRcPlaintext, "createRcPlaintext");
+function createRcCiphertext(value, name) {
+  assertRcCiphertext(value, name);
+  return value;
+}
+__name(createRcCiphertext, "createRcCiphertext");
+function createRcKey(value, name) {
+  assertRcKey(value, name);
+  return value;
+}
+__name(createRcKey, "createRcKey");
+function createRcEncryptionNonce(value, name) {
+  assertRcEncryptionNonce(value, name);
+  return value;
+}
+__name(createRcEncryptionNonce, "createRcEncryptionNonce");
+function createBase85Limb(value, name) {
+  assertBase85Limb(value, name);
+  return value;
+}
+__name(createBase85Limb, "createBase85Limb");
+function createOptionalData32(value, name) {
+  assertOptionalData32(value, name);
+  return value;
+}
+__name(createOptionalData32, "createOptionalData32");
+function createMicroLamportsPerAcu(value) {
+  if (typeof value !== "bigint") {
+    throw new Error(`MicroLamportsPerAcu: Expected bigint, got ${typeof value}`);
+  }
+  if (value < 0n) {
+    throw new Error(`MicroLamportsPerAcu: Value must be non-negative, got ${String(value)}`);
+  }
+  return value;
+}
+__name(createMicroLamportsPerAcu, "createMicroLamportsPerAcu");
+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;
+}
+__name(getByteAt, "getByteAt");
+
+export { bigintToBinaryArrayLSB, calculateNetAmountAfterFee, calculateTransferFee, convertBn254FieldElementToCurve25519FieldElement, convertBn254FieldElementToDailyViewingKey, convertBn254FieldElementToMasterViewingKey, convertBn254FieldElementToMintViewingKey, convertBn254FieldElementToMonthlyViewingKey, convertBn254FieldElementToPoseidonCiphertext, convertBn254FieldElementToPoseidonHash, convertBn254FieldElementToPoseidonKey, convertBn254FieldElementToPoseidonPlaintext, convertBn254FieldElementToU256, convertBn254FieldElementToYearlyViewingKey, convertCurve25519FieldElementToBn254FieldElement, convertCurve25519FieldElementToRcCiphertext, convertCurve25519FieldElementToRcCounter, convertCurve25519FieldElementToRcKey, convertCurve25519FieldElementToRcPlaintext, convertCurve25519FieldElementToU256, convertI1024ToI128, convertI1024ToI16, convertI1024ToI256, convertI1024ToI32, convertI1024ToI512, convertI1024ToI64, convertI1024ToI8, convertI1024ToNumber, convertI1024ToU1024, convertI128ToI1024, convertI128ToI16, convertI128ToI256, convertI128ToI32, convertI128ToI512, convertI128ToI64, convertI128ToI8, convertI128ToNumber, convertI128ToU128, convertI16ToI1024, convertI16ToI128, convertI16ToI256, convertI16ToI32, convertI16ToI512, convertI16ToI64, convertI16ToI8, convertI16ToNumber, convertI16ToU16, convertI256ToI1024, convertI256ToI128, convertI256ToI16, convertI256ToI32, convertI256ToI512, convertI256ToI64, convertI256ToI8, convertI256ToNumber, convertI256ToU256, convertI32ToI1024, convertI32ToI128, convertI32ToI16, convertI32ToI256, convertI32ToI512, convertI32ToI64, convertI32ToI8, convertI32ToNumber, convertI32ToU32, convertI512ToI1024, convertI512ToI128, convertI512ToI16, convertI512ToI256, convertI512ToI32, convertI512ToI64, convertI512ToI8, convertI512ToNumber, convertI512ToU512, convertI64ToI1024, convertI64ToI128, convertI64ToI16, convertI64ToI256, convertI64ToI32, convertI64ToI512, convertI64ToI8, convertI64ToNumber, convertI64ToU64, convertI8ToI1024, convertI8ToI128, convertI8ToI16, convertI8ToI256, convertI8ToI32, convertI8ToI512, convertI8ToI64, convertI8ToNumber, convertI8ToU8, convertNumberToI1024, convertNumberToI128, convertNumberToI16, convertNumberToI256, convertNumberToI32, convertNumberToI512, convertNumberToI64, convertNumberToI8, convertNumberToU1024, convertNumberToU128, convertNumberToU16, convertNumberToU256, convertNumberToU32, convertNumberToU512, convertNumberToU64, convertNumberToU8, convertPoseidonCiphertextToBn254FieldElement, convertPoseidonCiphertextToU256, convertPoseidonHashToBn254FieldElement, convertPoseidonHashToU256, convertPoseidonKeyToBn254FieldElement, convertPoseidonKeyToU256, convertPoseidonPlaintextToBn254FieldElement, convertPoseidonPlaintextToU256, convertRcCiphertextToCurve25519FieldElement, convertRcCiphertextToU256, convertRcCounterToCurve25519FieldElement, convertRcCounterToU256, convertRcEncryptionNonceToU128, convertRcKeyToCurve25519FieldElement, convertRcKeyToU256, convertRcPlaintextToCurve25519FieldElement, convertRcPlaintextToU256, convertSharedSecretToX25519Bytes, convertU1024ToI1024, convertU1024ToNumber, convertU1024ToU128, convertU1024ToU16, convertU1024ToU256, convertU1024ToU32, convertU1024ToU512, convertU1024ToU64, convertU1024ToU8, convertU128ToI128, convertU128ToNumber, convertU128ToRcEncryptionNonce, convertU128ToU1024, convertU128ToU16, convertU128ToU256, convertU128ToU32, convertU128ToU512, convertU128ToU64, convertU128ToU8, convertU16ToI16, convertU16ToNumber, convertU16ToU1024, convertU16ToU128, convertU16ToU256, convertU16ToU32, convertU16ToU512, convertU16ToU64, convertU16ToU8, convertU256ToBase85Limbs, convertU256ToBn254FieldElement, convertU256ToCurve25519FieldElement, convertU256ToI256, convertU256ToNumber, convertU256ToPoseidonCiphertext, convertU256ToPoseidonHash, convertU256ToPoseidonKey, convertU256ToPoseidonPlaintext, convertU256ToRcCiphertext, convertU256ToRcCounter, convertU256ToRcKey, convertU256ToRcPlaintext, convertU256ToU1024, convertU256ToU128, convertU256ToU16, convertU256ToU32, convertU256ToU512, convertU256ToU64, convertU256ToU8, convertU32ToI32, convertU32ToNumber, convertU32ToU1024, convertU32ToU128, convertU32ToU16, convertU32ToU256, convertU32ToU512, convertU32ToU64, convertU32ToU8, convertU512ToI512, convertU512ToNumber, convertU512ToU1024, convertU512ToU128, convertU512ToU16, convertU512ToU256, convertU512ToU32, convertU512ToU64, convertU512ToU8, convertU64ToI64, convertU64ToNumber, convertU64ToU1024, convertU64ToU128, convertU64ToU16, convertU64ToU256, convertU64ToU32, convertU64ToU512, convertU64ToU8, convertU8ToI8, convertU8ToNumber, convertU8ToU1024, convertU8ToU128, convertU8ToU16, convertU8ToU256, convertU8ToU32, convertU8ToU512, convertU8ToU64, convertX25519BytesToSharedSecret, convertX25519BytesToX25519PrivateKey, convertX25519BytesToX25519PublicKey, convertX25519PrivateKeyToX25519Bytes, convertX25519PublicKeyToX25519Bytes, createBase85Limb, createBn254FieldElement, createCurve25519FieldElement, createMicroLamportsPerAcu, createOptionalData32, createPoseidonKey, createRcCiphertext, createRcEncryptionNonce, createRcKey, createRcPlaintext, createU128, createU256, createU32, createU64, decodeBeBytesToBn254FieldElement, decodeBeBytesToCurve25519FieldElement, decodeBeBytesToRcEncryptionNonce, decodeLeBytesToBn254FieldElement, decodeLeBytesToCurve25519FieldElement, decodeLeBytesToRcEncryptionNonce, defaultExtractUtcComponents, defaultGetUtcNow, encodeBn254FieldElementToBeBytes, encodeBn254FieldElementToLeBytes, encodeCurve25519FieldElementToBeBytes, encodeCurve25519FieldElementToLeBytes, encodeRcEncryptionNonceToBeBytes, encodeRcEncryptionNonceToLeBytes, extractClusterOffsetFromMxeAccount, extractTransferFeeConfig, extractUtcComponents, generateComputationOffset, generateRandomNonce, generateRandomU128, generateRandomU256, generateRandomU64, getByteAt, getExtractUtcComponentsFunction, getUtcNow, getUtcNowFunction, splitAddressToLowHigh, splitU256IntoTwoU128s, splitX25519PublicKeyIntoTwoU128s };
+//# sourceMappingURL=chunk-UXMQI6B7.js.map
+//# sourceMappingURL=chunk-UXMQI6B7.js.map