@umbra-privacy/sdk 1.0.0 → 2.0.1

package/dist/chunk-5GUSMQ74.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common/converters/byte-encoding.ts"],"names":["assertU8LeBytes","assertU8BeBytes","__name","assertU16LeBytes","U16_BYTE_LENGTH","assertU16BeBytes","assertU32LeBytes","U32_BYTE_LENGTH","assertU32BeBytes","assertU64LeBytes","U64_BYTE_LENGTH","assertU64BeBytes","assertU128LeBytes","U128_BYTE_LENGTH","assertU128BeBytes","assertU256LeBytes","U256_BYTE_LENGTH","assertU256BeBytes","assertU512LeBytes","U512_BYTE_LENGTH","assertU512BeBytes","assertU1024LeBytes","U1024_BYTE_LENGTH","assertU1024BeBytes","assertU8","U8_BYTE_LENGTH","assertU16","assertU32","assertU64","assertU128","assertU256","assertU512","assertU1024"],"mappings":"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","file":"chunk-5GUSMQ74.cjs","sourcesContent":["/**\n * Byte Encoding, Decoding, and Endianness Conversions\n *\n * Conversions between branded integer types and their byte-array representations\n * (little-endian and big-endian), plus endianness swap functions.\n *\n * @module common/converters/byte-encoding\n * @since 2.0.0\n */\n\nimport {\n  type U8, type U16, type U32, type U64, type U128, type U256, type U512, type U1024,\n  type U8LeBytes, type U16LeBytes, type U32LeBytes, type U64LeBytes,\n  type U128LeBytes, type U256LeBytes, type U512LeBytes, type U1024LeBytes,\n  type U8BeBytes, type U16BeBytes, type U32BeBytes, type U64BeBytes,\n  type U128BeBytes, type U256BeBytes, type U512BeBytes, type U1024BeBytes,\n  U8_BYTE_LENGTH, U16_BYTE_LENGTH, U32_BYTE_LENGTH, U64_BYTE_LENGTH,\n  U128_BYTE_LENGTH, U256_BYTE_LENGTH, U512_BYTE_LENGTH, U1024_BYTE_LENGTH,\n  assertU8, assertU16, assertU32, assertU64, assertU128, assertU256, assertU512, assertU1024,\n  assertU8LeBytes, assertU16LeBytes, assertU32LeBytes, assertU64LeBytes,\n  assertU128LeBytes, assertU256LeBytes, assertU512LeBytes, assertU1024LeBytes,\n  assertU8BeBytes, assertU16BeBytes, assertU32BeBytes, assertU64BeBytes,\n  assertU128BeBytes, assertU256BeBytes, assertU512BeBytes, assertU1024BeBytes,\n} from \"../types\";\n\n/* =============================================================================\n * ENDIANNESS SWAP CONVERSIONS\n *\n * Convert between little-endian and big-endian byte arrays.\n * ============================================================================= */\n\n/**\n * Converts U8LeBytes to U8BeBytes (endianness swap).\n *\n * @public\n * @param value - The 1-byte little-endian representation to convert\n * @returns The identical byte array re-branded as U8BeBytes\n *\n * @remarks\n * Input type: U8LeBytes (Uint8Array of length 1, little-endian).\n * Output type: U8BeBytes (Uint8Array of length 1, big-endian).\n * For a single byte there is no meaningful distinction between LE and BE;\n * this function copies the byte and re-brands the type, acting as a\n * type-safe no-op. The numeric value encoded is unchanged.\n *\n * @example\n * ```typescript\n * const leBytes = encodeU8ToU8LeBytes(assertU8(42n));\n * const beBytes = convertU8LeBytesToU8BeBytes(leBytes); // same content, BE brand\n * ```\n *\n * @see {@link convertU8BeBytesToU8LeBytes} for the inverse conversion\n * @see {@link encodeU8ToU8LeBytes} to produce U8LeBytes from a U8 integer\n * @see {@link decodeU8LeBytesToU8} to decode U8LeBytes back to U8\n */\nexport function convertU8LeBytesToU8BeBytes(value: U8LeBytes): U8BeBytes {\n  assertU8LeBytes(value);\n  // Single byte - no actual swap needed, just re-brand\n  const result = new Uint8Array(value);\n  assertU8BeBytes(result);\n  return result;\n}\n\n/**\n * Converts U8BeBytes to U8LeBytes (endianness swap).\n *\n * @public\n * @param value - The 1-byte big-endian representation to convert\n * @returns The identical byte array re-branded as U8LeBytes\n *\n * @remarks\n * Input type: U8BeBytes (Uint8Array of length 1, big-endian).\n * Output type: U8LeBytes (Uint8Array of length 1, little-endian).\n * For a single byte this is a type-safe no-op; the byte content is copied unchanged.\n *\n * @example\n * ```typescript\n * const beBytes = encodeU8ToU8BeBytes(assertU8(42n));\n * const leBytes = convertU8BeBytesToU8LeBytes(beBytes); // same content, LE brand\n * ```\n *\n * @see {@link convertU8LeBytesToU8BeBytes} for the inverse conversion\n * @see {@link encodeU8ToU8BeBytes} to produce U8BeBytes from a U8 integer\n * @see {@link decodeU8BeBytesToU8} to decode U8BeBytes back to U8\n */\nexport function convertU8BeBytesToU8LeBytes(value: U8BeBytes): U8LeBytes {\n  assertU8BeBytes(value);\n  const result = new Uint8Array(value);\n  assertU8LeBytes(result);\n  return result;\n}\n\n/**\n * Converts U16LeBytes to U16BeBytes (endianness swap).\n *\n * @public\n * @param value - The 2-byte little-endian representation to convert\n * @returns A new Uint8Array of length 2 with bytes in reversed (big-endian) order\n *\n * @remarks\n * Input type: U16LeBytes (Uint8Array of length 2, little-endian — byte[0] is LSB).\n * Output type: U16BeBytes (Uint8Array of length 2, big-endian — byte[0] is MSB).\n * The reversal is performed by writing `value[LENGTH-1-i]` into `result[i]` for\n * each index. The encoded integer value is preserved.\n *\n * @example\n * ```typescript\n * // Encoding 0x0102 in LE: [0x02, 0x01]\n * const leBytes = encodeU16ToU16LeBytes(assertU16(0x0102n));\n * const beBytes = convertU16LeBytesToU16BeBytes(leBytes); // [0x01, 0x02]\n * ```\n *\n * @see {@link convertU16BeBytesToU16LeBytes} for the inverse conversion\n * @see {@link encodeU16ToU16LeBytes} to encode U16 to LE bytes\n * @see {@link decodeU16BeBytesToU16} to decode the resulting BE bytes back to U16\n */\nexport function convertU16LeBytesToU16BeBytes(value: U16LeBytes): U16BeBytes {\n  assertU16LeBytes(value);\n  const result = new Uint8Array(U16_BYTE_LENGTH);\n  for (let index = 0; index < U16_BYTE_LENGTH; index++) {\n    result[index] = value[U16_BYTE_LENGTH - 1 - index];\n  }\n  assertU16BeBytes(result);\n  return result;\n}\n\n/**\n * Converts U16BeBytes to U16LeBytes (endianness swap).\n *\n * @public\n * @param value - The 2-byte big-endian representation to convert\n * @returns A new Uint8Array of length 2 with bytes in reversed (little-endian) order\n *\n * @remarks\n * Input type: U16BeBytes (Uint8Array of length 2, big-endian — byte[0] is MSB).\n * Output type: U16LeBytes (Uint8Array of length 2, little-endian — byte[0] is LSB).\n * The reversal is performed by writing `value[LENGTH-1-i]` into `result[i]`.\n * The encoded integer value is preserved.\n *\n * @example\n * ```typescript\n * // Encoding 0x0102 in BE: [0x01, 0x02]\n * const beBytes = encodeU16ToU16BeBytes(assertU16(0x0102n));\n * const leBytes = convertU16BeBytesToU16LeBytes(beBytes); // [0x02, 0x01]\n * ```\n *\n * @see {@link convertU16LeBytesToU16BeBytes} for the inverse conversion\n * @see {@link encodeU16ToU16BeBytes} to encode U16 to BE bytes\n * @see {@link decodeU16LeBytesToU16} to decode the resulting LE bytes back to U16\n */\nexport function convertU16BeBytesToU16LeBytes(value: U16BeBytes): U16LeBytes {\n  assertU16BeBytes(value);\n  const result = new Uint8Array(U16_BYTE_LENGTH);\n  for (let index = 0; index < U16_BYTE_LENGTH; index++) {\n    result[index] = value[U16_BYTE_LENGTH - 1 - index];\n  }\n  assertU16LeBytes(result);\n  return result;\n}\n\n/**\n * Converts U32LeBytes to U32BeBytes (endianness swap).\n *\n * @public\n * @param value - The 4-byte little-endian representation to convert\n * @returns A new Uint8Array of length 4 with bytes in reversed (big-endian) order\n *\n * @remarks\n * Input type: U32LeBytes (Uint8Array of length 4, little-endian — byte[0] is LSB).\n * Output type: U32BeBytes (Uint8Array of length 4, big-endian — byte[0] is MSB).\n * Bytes are reversed by index. The encoded integer value is preserved.\n *\n * @example\n * ```typescript\n * const leBytes = encodeU32ToU32LeBytes(assertU32(0x01020304n));\n * // leBytes = [0x04, 0x03, 0x02, 0x01]\n * const beBytes = convertU32LeBytesToU32BeBytes(leBytes);\n * // beBytes = [0x01, 0x02, 0x03, 0x04]\n * ```\n *\n * @see {@link convertU32BeBytesToU32LeBytes} for the inverse conversion\n */\nexport function convertU32LeBytesToU32BeBytes(value: U32LeBytes): U32BeBytes {\n  assertU32LeBytes(value);\n  const result = new Uint8Array(U32_BYTE_LENGTH);\n  for (let index = 0; index < U32_BYTE_LENGTH; index++) {\n    result[index] = value[U32_BYTE_LENGTH - 1 - index];\n  }\n  assertU32BeBytes(result);\n  return result;\n}\n\n/**\n * Converts U32BeBytes to U32LeBytes (endianness swap).\n *\n * @public\n * @param value - The 4-byte big-endian representation to convert\n * @returns A new Uint8Array of length 4 with bytes in reversed (little-endian) order\n *\n * @remarks\n * Input type: U32BeBytes (Uint8Array of length 4, big-endian — byte[0] is MSB).\n * Output type: U32LeBytes (Uint8Array of length 4, little-endian — byte[0] is LSB).\n * Bytes are reversed by index. The encoded integer value is preserved.\n *\n * @example\n * ```typescript\n * const beBytes = encodeU32ToU32BeBytes(assertU32(0x01020304n));\n * // beBytes = [0x01, 0x02, 0x03, 0x04]\n * const leBytes = convertU32BeBytesToU32LeBytes(beBytes);\n * // leBytes = [0x04, 0x03, 0x02, 0x01]\n * ```\n *\n * @see {@link convertU32LeBytesToU32BeBytes} for the inverse conversion\n */\nexport function convertU32BeBytesToU32LeBytes(value: U32BeBytes): U32LeBytes {\n  assertU32BeBytes(value);\n  const result = new Uint8Array(U32_BYTE_LENGTH);\n  for (let index = 0; index < U32_BYTE_LENGTH; index++) {\n    result[index] = value[U32_BYTE_LENGTH - 1 - index];\n  }\n  assertU32LeBytes(result);\n  return result;\n}\n\n/**\n * Converts U64LeBytes to U64BeBytes (endianness swap).\n *\n * @public\n * @param value - The 8-byte little-endian representation to convert\n * @returns A new Uint8Array of length 8 with bytes in reversed (big-endian) order\n *\n * @remarks\n * Input type: U64LeBytes (Uint8Array of length 8, little-endian — byte[0] is LSB).\n * Output type: U64BeBytes (Uint8Array of length 8, big-endian — byte[0] is MSB).\n * Bytes are reversed by index. The encoded integer value is preserved.\n * U64 LE encoding is the canonical format for Solana account lamport amounts and\n * other on-chain 64-bit values; BE is used in some cross-chain message formats.\n *\n * @example\n * ```typescript\n * const leBytes = encodeU64ToU64LeBytes(assertU64(1000n));\n * const beBytes = convertU64LeBytesToU64BeBytes(leBytes);\n * ```\n *\n * @see {@link convertU64BeBytesToU64LeBytes} for the inverse conversion\n */\nexport function convertU64LeBytesToU64BeBytes(value: U64LeBytes): U64BeBytes {\n  assertU64LeBytes(value);\n  const result = new Uint8Array(U64_BYTE_LENGTH);\n  for (let index = 0; index < U64_BYTE_LENGTH; index++) {\n    result[index] = value[U64_BYTE_LENGTH - 1 - index];\n  }\n  assertU64BeBytes(result);\n  return result;\n}\n\n/**\n * Converts U64BeBytes to U64LeBytes (endianness swap).\n *\n * @public\n * @param value - The 8-byte big-endian representation to convert\n * @returns A new Uint8Array of length 8 with bytes in reversed (little-endian) order\n *\n * @remarks\n * Input type: U64BeBytes (Uint8Array of length 8, big-endian — byte[0] is MSB).\n * Output type: U64LeBytes (Uint8Array of length 8, little-endian — byte[0] is LSB).\n * Bytes are reversed by index. The encoded integer value is preserved.\n *\n * @example\n * ```typescript\n * const beBytes = encodeU64ToU64BeBytes(assertU64(1000n));\n * const leBytes = convertU64BeBytesToU64LeBytes(beBytes);\n * ```\n *\n * @see {@link convertU64LeBytesToU64BeBytes} for the inverse conversion\n */\nexport function convertU64BeBytesToU64LeBytes(value: U64BeBytes): U64LeBytes {\n  assertU64BeBytes(value);\n  const result = new Uint8Array(U64_BYTE_LENGTH);\n  for (let index = 0; index < U64_BYTE_LENGTH; index++) {\n    result[index] = value[U64_BYTE_LENGTH - 1 - index];\n  }\n  assertU64LeBytes(result);\n  return result;\n}\n\n/**\n * Converts U128LeBytes to U128BeBytes (endianness swap).\n *\n * @public\n * @param value - The 16-byte little-endian representation to convert\n * @returns A new Uint8Array of length 16 with bytes in reversed (big-endian) order\n *\n * @remarks\n * Input type: U128LeBytes (Uint8Array of length 16, little-endian — byte[0] is LSB).\n * Output type: U128BeBytes (Uint8Array of length 16, big-endian — byte[0] is MSB).\n * Bytes are reversed by index. The encoded integer value is preserved.\n *\n * @example\n * ```typescript\n * const leBytes = encodeU128ToU128LeBytes(assertU128(2n ** 64n));\n * const beBytes = convertU128LeBytesToU128BeBytes(leBytes);\n * ```\n *\n * @see {@link convertU128BeBytesToU128LeBytes} for the inverse conversion\n */\nexport function convertU128LeBytesToU128BeBytes(value: U128LeBytes): U128BeBytes {\n  assertU128LeBytes(value);\n  const result = new Uint8Array(U128_BYTE_LENGTH);\n  for (let index = 0; index < U128_BYTE_LENGTH; index++) {\n    result[index] = value[U128_BYTE_LENGTH - 1 - index];\n  }\n  assertU128BeBytes(result);\n  return result;\n}\n\n/**\n * Converts U128BeBytes to U128LeBytes (endianness swap).\n *\n * @public\n * @param value - The 16-byte big-endian representation to convert\n * @returns A new Uint8Array of length 16 with bytes in reversed (little-endian) order\n *\n * @remarks\n * Input type: U128BeBytes (Uint8Array of length 16, big-endian — byte[0] is MSB).\n * Output type: U128LeBytes (Uint8Array of length 16, little-endian — byte[0] is LSB).\n * Bytes are reversed by index. The encoded integer value is preserved.\n *\n * @example\n * ```typescript\n * const beBytes = encodeU128ToU128BeBytes(assertU128(2n ** 64n));\n * const leBytes = convertU128BeBytesToU128LeBytes(beBytes);\n * ```\n *\n * @see {@link convertU128LeBytesToU128BeBytes} for the inverse conversion\n */\nexport function convertU128BeBytesToU128LeBytes(value: U128BeBytes): U128LeBytes {\n  assertU128BeBytes(value);\n  const result = new Uint8Array(U128_BYTE_LENGTH);\n  for (let index = 0; index < U128_BYTE_LENGTH; index++) {\n    result[index] = value[U128_BYTE_LENGTH - 1 - index];\n  }\n  assertU128LeBytes(result);\n  return result;\n}\n\n/**\n * Converts U256LeBytes to U256BeBytes (endianness swap).\n *\n * @public\n * @param value - The 32-byte little-endian representation to convert\n * @returns A new Uint8Array of length 32 with bytes in reversed (big-endian) order\n *\n * @remarks\n * Input type: U256LeBytes (Uint8Array of length 32, little-endian — byte[0] is LSB).\n * Output type: U256BeBytes (Uint8Array of length 32, big-endian — byte[0] is MSB).\n * Bytes are reversed by index. The encoded integer value is preserved.\n * This conversion is commonly used when bridging between Solana's LE storage\n * format and BN254/Groth16 proof verification which expects BE field elements.\n *\n * @example\n * ```typescript\n * const leBytes = encodeU256ToU256LeBytes(assertU256(2n ** 200n));\n * const beBytes = convertU256LeBytesToU256BeBytes(leBytes);\n * ```\n *\n * @see {@link convertU256BeBytesToU256LeBytes} for the inverse conversion\n */\nexport function convertU256LeBytesToU256BeBytes(value: U256LeBytes): U256BeBytes {\n  assertU256LeBytes(value);\n  const result = new Uint8Array(U256_BYTE_LENGTH);\n  for (let index = 0; index < U256_BYTE_LENGTH; index++) {\n    result[index] = value[U256_BYTE_LENGTH - 1 - index];\n  }\n  assertU256BeBytes(result);\n  return result;\n}\n\n/**\n * Converts U256BeBytes to U256LeBytes (endianness swap).\n *\n * @public\n * @param value - The 32-byte big-endian representation to convert\n * @returns A new Uint8Array of length 32 with bytes in reversed (little-endian) order\n *\n * @remarks\n * Input type: U256BeBytes (Uint8Array of length 32, big-endian — byte[0] is MSB).\n * Output type: U256LeBytes (Uint8Array of length 32, little-endian — byte[0] is LSB).\n * Bytes are reversed by index. The encoded integer value is preserved.\n * Commonly used after receiving a BE-encoded BN254 field element and converting\n * it to LE format for on-chain Solana storage or comparison.\n *\n * @example\n * ```typescript\n * const beBytes = encodeU256ToU256BeBytes(assertU256(2n ** 200n));\n * const leBytes = convertU256BeBytesToU256LeBytes(beBytes);\n * ```\n *\n * @see {@link convertU256LeBytesToU256BeBytes} for the inverse conversion\n */\nexport function convertU256BeBytesToU256LeBytes(value: U256BeBytes): U256LeBytes {\n  assertU256BeBytes(value);\n  const result = new Uint8Array(U256_BYTE_LENGTH);\n  for (let index = 0; index < U256_BYTE_LENGTH; index++) {\n    result[index] = value[U256_BYTE_LENGTH - 1 - index];\n  }\n  assertU256LeBytes(result);\n  return result;\n}\n\n/**\n * Converts U512LeBytes to U512BeBytes (endianness swap).\n *\n * @public\n * @param value - The 64-byte little-endian representation to convert\n * @returns A new Uint8Array of length 64 with bytes in reversed (big-endian) order\n *\n * @remarks\n * Input type: U512LeBytes (Uint8Array of length 64, little-endian — byte[0] is LSB).\n * Output type: U512BeBytes (Uint8Array of length 64, big-endian — byte[0] is MSB).\n * Bytes are reversed by index. The encoded integer value is preserved.\n *\n * @example\n * ```typescript\n * const leBytes = encodeU512ToU512LeBytes(assertU512(2n ** 400n));\n * const beBytes = convertU512LeBytesToU512BeBytes(leBytes);\n * ```\n *\n * @see {@link convertU512BeBytesToU512LeBytes} for the inverse conversion\n */\nexport function convertU512LeBytesToU512BeBytes(value: U512LeBytes): U512BeBytes {\n  assertU512LeBytes(value);\n  const result = new Uint8Array(U512_BYTE_LENGTH);\n  for (let index = 0; index < U512_BYTE_LENGTH; index++) {\n    result[index] = value[U512_BYTE_LENGTH - 1 - index];\n  }\n  assertU512BeBytes(result);\n  return result;\n}\n\n/**\n * Converts U512BeBytes to U512LeBytes (endianness swap).\n *\n * @public\n * @param value - The 64-byte big-endian representation to convert\n * @returns A new Uint8Array of length 64 with bytes in reversed (little-endian) order\n *\n * @remarks\n * Input type: U512BeBytes (Uint8Array of length 64, big-endian — byte[0] is MSB).\n * Output type: U512LeBytes (Uint8Array of length 64, little-endian — byte[0] is LSB).\n * Bytes are reversed by index. The encoded integer value is preserved.\n *\n * @example\n * ```typescript\n * const beBytes = encodeU512ToU512BeBytes(assertU512(2n ** 400n));\n * const leBytes = convertU512BeBytesToU512LeBytes(beBytes);\n * ```\n *\n * @see {@link convertU512LeBytesToU512BeBytes} for the inverse conversion\n */\nexport function convertU512BeBytesToU512LeBytes(value: U512BeBytes): U512LeBytes {\n  assertU512BeBytes(value);\n  const result = new Uint8Array(U512_BYTE_LENGTH);\n  for (let index = 0; index < U512_BYTE_LENGTH; index++) {\n    result[index] = value[U512_BYTE_LENGTH - 1 - index];\n  }\n  assertU512LeBytes(result);\n  return result;\n}\n\n/**\n * Converts U1024LeBytes to U1024BeBytes (endianness swap).\n *\n * @public\n * @param value - The 128-byte little-endian representation to convert\n * @returns A new Uint8Array of length 128 with bytes in reversed (big-endian) order\n *\n * @remarks\n * Input type: U1024LeBytes (Uint8Array of length 128, little-endian — byte[0] is LSB).\n * Output type: U1024BeBytes (Uint8Array of length 128, big-endian — byte[0] is MSB).\n * Bytes are reversed by index. The encoded integer value is preserved.\n *\n * @example\n * ```typescript\n * const leBytes = encodeU1024ToU1024LeBytes(assertU1024(2n ** 900n));\n * const beBytes = convertU1024LeBytesToU1024BeBytes(leBytes);\n * ```\n *\n * @see {@link convertU1024BeBytesToU1024LeBytes} for the inverse conversion\n */\nexport function convertU1024LeBytesToU1024BeBytes(value: U1024LeBytes): U1024BeBytes {\n  assertU1024LeBytes(value);\n  const result = new Uint8Array(U1024_BYTE_LENGTH);\n  for (let index = 0; index < U1024_BYTE_LENGTH; index++) {\n    result[index] = value[U1024_BYTE_LENGTH - 1 - index];\n  }\n  assertU1024BeBytes(result);\n  return result;\n}\n\n/**\n * Converts U1024BeBytes to U1024LeBytes (endianness swap).\n *\n * @public\n * @param value - The 128-byte big-endian representation to convert\n * @returns A new Uint8Array of length 128 with bytes in reversed (little-endian) order\n *\n * @remarks\n * Input type: U1024BeBytes (Uint8Array of length 128, big-endian — byte[0] is MSB).\n * Output type: U1024LeBytes (Uint8Array of length 128, little-endian — byte[0] is LSB).\n * Bytes are reversed by index. The encoded integer value is preserved.\n *\n * @example\n * ```typescript\n * const beBytes = encodeU1024ToU1024BeBytes(assertU1024(2n ** 900n));\n * const leBytes = convertU1024BeBytesToU1024LeBytes(beBytes);\n * ```\n *\n * @see {@link convertU1024LeBytesToU1024BeBytes} for the inverse conversion\n */\nexport function convertU1024BeBytesToU1024LeBytes(value: U1024BeBytes): U1024LeBytes {\n  assertU1024BeBytes(value);\n  const result = new Uint8Array(U1024_BYTE_LENGTH);\n  for (let index = 0; index < U1024_BYTE_LENGTH; index++) {\n    result[index] = value[U1024_BYTE_LENGTH - 1 - index];\n  }\n  assertU1024LeBytes(result);\n  return result;\n}\n\n/* =============================================================================\n * INTEGER TO BYTE ARRAY ENCODING\n *\n * Encode integers as byte arrays in specified endianness.\n * ============================================================================= */\n\n/**\n * Encodes a U8 integer as a 1-byte little-endian byte array.\n *\n * @public\n * @param value - The U8 value to encode (range [0, 255])\n * @returns A Uint8Array of length 1 containing the single byte\n *\n * @remarks\n * Input type: U8 (bigint, range [0, 255]).\n * Output type: U8LeBytes (Uint8Array of length 1, little-endian).\n * For a single byte there is no endianness; byte[0] = value & 0xFF.\n * This is the canonical encoding for 8-bit values in Solana account data.\n *\n * @example\n * ```typescript\n * const bytes = encodeU8ToU8LeBytes(assertU8(42n)); // Uint8Array [42]\n * ```\n *\n * @see {@link decodeU8LeBytesToU8} for the inverse decoding\n * @see {@link encodeU8ToU8BeBytes} for the big-endian variant (identical for 1 byte)\n */\nexport function encodeU8ToU8LeBytes(value: U8): U8LeBytes {\n  assertU8(value);\n  const result = new Uint8Array(U8_BYTE_LENGTH);\n  result[0] = Number(value);\n  assertU8LeBytes(result);\n  return result;\n}\n\n/**\n * Encodes a U8 integer as a 1-byte big-endian byte array.\n *\n * @public\n * @param value - The U8 value to encode (range [0, 255])\n * @returns A Uint8Array of length 1 containing the single byte\n *\n * @remarks\n * Input type: U8 (bigint, range [0, 255]).\n * Output type: U8BeBytes (Uint8Array of length 1, big-endian).\n * For a single byte there is no endianness; byte[0] = value & 0xFF.\n *\n * @example\n * ```typescript\n * const bytes = encodeU8ToU8BeBytes(assertU8(255n)); // Uint8Array [255]\n * ```\n *\n * @see {@link decodeU8BeBytesToU8} for the inverse decoding\n * @see {@link encodeU8ToU8LeBytes} for the little-endian variant (identical for 1 byte)\n */\nexport function encodeU8ToU8BeBytes(value: U8): U8BeBytes {\n  assertU8(value);\n  const result = new Uint8Array(U8_BYTE_LENGTH);\n  result[0] = Number(value);\n  assertU8BeBytes(result);\n  return result;\n}\n\n/**\n * Encodes a U16 integer as a 2-byte little-endian byte array.\n *\n * @public\n * @param value - The U16 value to encode (range [0, 65535])\n * @returns A Uint8Array of length 2 in little-endian byte order (LSB at index 0)\n *\n * @remarks\n * Input type: U16 (bigint, range [0, 65535]).\n * Output type: U16LeBytes (Uint8Array of length 2, little-endian).\n * Encoding algorithm: iterates indices 0..1, writes `value & 0xff` to `result[index]`,\n * then shifts `value >>= 8n`. This places the least-significant byte at index 0.\n * Little-endian encoding matches Solana's on-chain data layout for u16 fields.\n *\n * @example\n * ```typescript\n * // 0x0102 = 258; LE = [0x02, 0x01]\n * const bytes = encodeU16ToU16LeBytes(assertU16(258n));\n * // bytes[0] = 2, bytes[1] = 1\n * ```\n *\n * @see {@link decodeU16LeBytesToU16} for the inverse decoding\n * @see {@link encodeU16ToU16BeBytes} for the big-endian variant\n */\nexport function encodeU16ToU16LeBytes(value: U16): U16LeBytes {\n  assertU16(value);\n  const result = new Uint8Array(U16_BYTE_LENGTH);\n  let temporary: bigint = value;\n  for (let index = 0; index < U16_BYTE_LENGTH; index++) {\n    result[index] = Number(temporary & 0xffn);\n    temporary >>= 8n;\n  }\n  assertU16LeBytes(result);\n  return result;\n}\n\n/**\n * Encodes a U16 integer as a 2-byte big-endian byte array.\n *\n * @public\n * @param value - The U16 value to encode (range [0, 65535])\n * @returns A Uint8Array of length 2 in big-endian byte order (MSB at index 0)\n *\n * @remarks\n * Input type: U16 (bigint, range [0, 65535]).\n * Output type: U16BeBytes (Uint8Array of length 2, big-endian).\n * Encoding algorithm: iterates indices from LENGTH-1 down to 0, writes `value & 0xff`\n * to `result[index]`, then shifts `value >>= 8n`. This places the most-significant\n * byte at index 0.\n *\n * @example\n * ```typescript\n * // 0x0102 = 258; BE = [0x01, 0x02]\n * const bytes = encodeU16ToU16BeBytes(assertU16(258n));\n * // bytes[0] = 1, bytes[1] = 2\n * ```\n *\n * @see {@link decodeU16BeBytesToU16} for the inverse decoding\n * @see {@link encodeU16ToU16LeBytes} for the little-endian variant\n */\nexport function encodeU16ToU16BeBytes(value: U16): U16BeBytes {\n  assertU16(value);\n  const result = new Uint8Array(U16_BYTE_LENGTH);\n  let temporary: bigint = value;\n  for (let index = U16_BYTE_LENGTH - 1; index >= 0; index--) {\n    result[index] = Number(temporary & 0xffn);\n    temporary >>= 8n;\n  }\n  assertU16BeBytes(result);\n  return result;\n}\n\n/**\n * Encodes a U32 integer as a 4-byte little-endian byte array.\n *\n * @public\n * @param value - The U32 value to encode (range [0, 2^32 - 1])\n * @returns A Uint8Array of length 4 in little-endian byte order (LSB at index 0)\n *\n * @remarks\n * Input type: U32 (bigint, range [0, 4294967295]).\n * Output type: U32LeBytes (Uint8Array of length 4, little-endian).\n * Iterates indices 0..3, writing low byte then shifting right by 8 bits each step.\n * This is the standard encoding for Solana u32 discriminators and lengths.\n *\n * @example\n * ```typescript\n * const bytes = encodeU32ToU32LeBytes(assertU32(0x01020304n));\n * // bytes = [0x04, 0x03, 0x02, 0x01]\n * ```\n *\n * @see {@link decodeU32LeBytesToU32} for the inverse decoding\n * @see {@link encodeU32ToU32BeBytes} for the big-endian variant\n */\nexport function encodeU32ToU32LeBytes(value: U32): U32LeBytes {\n  assertU32(value);\n  const result = new Uint8Array(U32_BYTE_LENGTH);\n  let temporary: bigint = value;\n  for (let index = 0; index < U32_BYTE_LENGTH; index++) {\n    result[index] = Number(temporary & 0xffn);\n    temporary >>= 8n;\n  }\n  assertU32LeBytes(result);\n  return result;\n}\n\n/**\n * Encodes a U32 integer as a 4-byte big-endian byte array.\n *\n * @public\n * @param value - The U32 value to encode (range [0, 2^32 - 1])\n * @returns A Uint8Array of length 4 in big-endian byte order (MSB at index 0)\n *\n * @remarks\n * Input type: U32 (bigint, range [0, 4294967295]).\n * Output type: U32BeBytes (Uint8Array of length 4, big-endian).\n * Iterates indices from 3 down to 0, writing low byte then shifting right by 8 bits.\n * This places the most-significant byte at index 0.\n *\n * @example\n * ```typescript\n * const bytes = encodeU32ToU32BeBytes(assertU32(0x01020304n));\n * // bytes = [0x01, 0x02, 0x03, 0x04]\n * ```\n *\n * @see {@link decodeU32BeBytesToU32} for the inverse decoding\n * @see {@link encodeU32ToU32LeBytes} for the little-endian variant\n */\nexport function encodeU32ToU32BeBytes(value: U32): U32BeBytes {\n  assertU32(value);\n  const result = new Uint8Array(U32_BYTE_LENGTH);\n  let temporary: bigint = value;\n  for (let index = U32_BYTE_LENGTH - 1; index >= 0; index--) {\n    result[index] = Number(temporary & 0xffn);\n    temporary >>= 8n;\n  }\n  assertU32BeBytes(result);\n  return result;\n}\n\n/**\n * Encodes a U64 integer as an 8-byte little-endian byte array.\n *\n * @public\n * @param value - The U64 value to encode (range [0, 2^64 - 1])\n * @returns A Uint8Array of length 8 in little-endian byte order (LSB at index 0)\n *\n * @remarks\n * Input type: U64 (bigint, range [0, 2^64 - 1]).\n * Output type: U64LeBytes (Uint8Array of length 8, little-endian).\n * Iterates indices 0..7, writing low byte then shifting right by 8 bits each step.\n * This is the canonical encoding for Solana lamport amounts, token quantities,\n * and other 64-bit on-chain values.\n *\n * @example\n * ```typescript\n * const bytes = encodeU64ToU64LeBytes(assertU64(1000000000n)); // 1 SOL in lamports\n * // bytes[0] is LSB; bytes[7] is MSB\n * ```\n *\n * @see {@link decodeU64LeBytesToU64} for the inverse decoding\n * @see {@link encodeU64ToU64BeBytes} for the big-endian variant\n */\nexport function encodeU64ToU64LeBytes(value: U64): U64LeBytes {\n  assertU64(value);\n  const result = new Uint8Array(U64_BYTE_LENGTH);\n  let temporary: bigint = value;\n  for (let index = 0; index < U64_BYTE_LENGTH; index++) {\n    result[index] = Number(temporary & 0xffn);\n    temporary >>= 8n;\n  }\n  assertU64LeBytes(result);\n  return result;\n}\n\n/**\n * Encodes a U64 integer as an 8-byte big-endian byte array.\n *\n * @public\n * @param value - The U64 value to encode (range [0, 2^64 - 1])\n * @returns A Uint8Array of length 8 in big-endian byte order (MSB at index 0)\n *\n * @remarks\n * Input type: U64 (bigint, range [0, 2^64 - 1]).\n * Output type: U64BeBytes (Uint8Array of length 8, big-endian).\n * Iterates indices from 7 down to 0, writing low byte then shifting right by 8 bits.\n * MSB is at index 0.\n *\n * @example\n * ```typescript\n * const bytes = encodeU64ToU64BeBytes(assertU64(0x0102030405060708n));\n * // bytes = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]\n * ```\n *\n * @see {@link decodeU64BeBytesToU64} for the inverse decoding\n * @see {@link encodeU64ToU64LeBytes} for the little-endian variant\n */\nexport function encodeU64ToU64BeBytes(value: U64): U64BeBytes {\n  assertU64(value);\n  const result = new Uint8Array(U64_BYTE_LENGTH);\n  let temporary: bigint = value;\n  for (let index = U64_BYTE_LENGTH - 1; index >= 0; index--) {\n    result[index] = Number(temporary & 0xffn);\n    temporary >>= 8n;\n  }\n  assertU64BeBytes(result);\n  return result;\n}\n\n/**\n * Encodes a U128 integer as a 16-byte little-endian byte array.\n *\n * @public\n * @param value - The U128 value to encode (range [0, 2^128 - 1])\n * @returns A Uint8Array of length 16 in little-endian byte order (LSB at index 0)\n *\n * @remarks\n * Input type: U128 (bigint, range [0, 2^128 - 1]).\n * Output type: U128LeBytes (Uint8Array of length 16, little-endian).\n * Iterates indices 0..15, writing low byte then shifting right by 8 bits each step.\n * Commonly used to encode 128-bit nonces, RcEncryptionNonce values, and token amounts\n * that exceed the U64 range.\n *\n * @example\n * ```typescript\n * const bytes = encodeU128ToU128LeBytes(assertU128(2n ** 64n));\n * // bytes[8] = 1; all others = 0 (since 2^64 = 1 at byte index 8)\n * ```\n *\n * @see {@link decodeU128LeBytesToU128} for the inverse decoding\n * @see {@link encodeU128ToU128BeBytes} for the big-endian variant\n */\nexport function encodeU128ToU128LeBytes(value: U128): U128LeBytes {\n  assertU128(value);\n  const result = new Uint8Array(U128_BYTE_LENGTH);\n  let temporary: bigint = value;\n  for (let index = 0; index < U128_BYTE_LENGTH; index++) {\n    result[index] = Number(temporary & 0xffn);\n    temporary >>= 8n;\n  }\n  assertU128LeBytes(result);\n  return result;\n}\n\n/**\n * Encodes a U128 integer as a 16-byte big-endian byte array.\n *\n * @public\n * @param value - The U128 value to encode (range [0, 2^128 - 1])\n * @returns A Uint8Array of length 16 in big-endian byte order (MSB at index 0)\n *\n * @remarks\n * Input type: U128 (bigint, range [0, 2^128 - 1]).\n * Output type: U128BeBytes (Uint8Array of length 16, big-endian).\n * Iterates indices from 15 down to 0, writing low byte then shifting right by 8 bits.\n * MSB is at index 0.\n *\n * @example\n * ```typescript\n * const bytes = encodeU128ToU128BeBytes(assertU128(1n));\n * // bytes = [0, 0, ..., 0, 1] (15 zero bytes then 0x01)\n * ```\n *\n * @see {@link decodeU128BeBytesToU128} for the inverse decoding\n * @see {@link encodeU128ToU128LeBytes} for the little-endian variant\n */\nexport function encodeU128ToU128BeBytes(value: U128): U128BeBytes {\n  assertU128(value);\n  const result = new Uint8Array(U128_BYTE_LENGTH);\n  let temporary: bigint = value;\n  for (let index = U128_BYTE_LENGTH - 1; index >= 0; index--) {\n    result[index] = Number(temporary & 0xffn);\n    temporary >>= 8n;\n  }\n  assertU128BeBytes(result);\n  return result;\n}\n\n/**\n * Encodes a U256 integer as a 32-byte little-endian byte array.\n *\n * @public\n * @param value - The U256 value to encode (range [0, 2^256 - 1])\n * @returns A Uint8Array of length 32 in little-endian byte order (LSB at index 0)\n *\n * @remarks\n * Input type: U256 (bigint, range [0, 2^256 - 1]).\n * Output type: U256LeBytes (Uint8Array of length 32, little-endian).\n * Iterates indices 0..31, writing low byte then shifting right by 8 bits each step.\n * This is the canonical Solana on-chain encoding for 256-bit values such as\n * X25519 public keys, Poseidon hash outputs, and UTXO commitments.\n *\n * @example\n * ```typescript\n * const bytes = encodeU256ToU256LeBytes(assertU256(1n));\n * // bytes[0] = 1; bytes[1..31] = 0\n * ```\n *\n * @see {@link decodeU256LeBytesToU256} for the inverse decoding\n * @see {@link encodeU256ToU256BeBytes} for the big-endian variant\n */\nexport function encodeU256ToU256LeBytes(value: U256): U256LeBytes {\n  assertU256(value);\n  const result = new Uint8Array(U256_BYTE_LENGTH);\n  let temporary: bigint = value;\n  for (let index = 0; index < U256_BYTE_LENGTH; index++) {\n    result[index] = Number(temporary & 0xffn);\n    temporary >>= 8n;\n  }\n  assertU256LeBytes(result);\n  return result;\n}\n\n/**\n * Encodes a U256 integer as a 32-byte big-endian byte array.\n *\n * @public\n * @param value - The U256 value to encode (range [0, 2^256 - 1])\n * @returns A Uint8Array of length 32 in big-endian byte order (MSB at index 0)\n *\n * @remarks\n * Input type: U256 (bigint, range [0, 2^256 - 1]).\n * Output type: U256BeBytes (Uint8Array of length 32, big-endian).\n * Iterates indices from 31 down to 0, writing low byte then shifting right by 8 bits.\n * MSB is at index 0. This is the standard format for BN254/Groth16 field elements\n * and EVM-compatible 32-byte word encoding.\n *\n * @example\n * ```typescript\n * const bytes = encodeU256ToU256BeBytes(assertU256(1n));\n * // bytes[0..30] = 0; bytes[31] = 1\n * ```\n *\n * @see {@link decodeU256BeBytesToU256} for the inverse decoding\n * @see {@link encodeU256ToU256LeBytes} for the little-endian variant\n */\nexport function encodeU256ToU256BeBytes(value: U256): U256BeBytes {\n  assertU256(value);\n  const result = new Uint8Array(U256_BYTE_LENGTH);\n  let temporary: bigint = value;\n  for (let index = U256_BYTE_LENGTH - 1; index >= 0; index--) {\n    result[index] = Number(temporary & 0xffn);\n    temporary >>= 8n;\n  }\n  assertU256BeBytes(result);\n  return result;\n}\n\n/**\n * Encodes a U512 integer as a 64-byte little-endian byte array.\n *\n * @public\n * @param value - The U512 value to encode (range [0, 2^512 - 1])\n * @returns A Uint8Array of length 64 in little-endian byte order (LSB at index 0)\n *\n * @remarks\n * Input type: U512 (bigint, range [0, 2^512 - 1]).\n * Output type: U512LeBytes (Uint8Array of length 64, little-endian).\n * Iterates indices 0..63, writing low byte then shifting right by 8 bits each step.\n *\n * @example\n * ```typescript\n * const bytes = encodeU512ToU512LeBytes(assertU512(2n ** 256n));\n * // bytes[32] = 1; all others = 0\n * ```\n *\n * @see {@link decodeU512LeBytesToU512} for the inverse decoding\n * @see {@link encodeU512ToU512BeBytes} for the big-endian variant\n */\nexport function encodeU512ToU512LeBytes(value: U512): U512LeBytes {\n  assertU512(value);\n  const result = new Uint8Array(U512_BYTE_LENGTH);\n  let temporary: bigint = value;\n  for (let index = 0; index < U512_BYTE_LENGTH; index++) {\n    result[index] = Number(temporary & 0xffn);\n    temporary >>= 8n;\n  }\n  assertU512LeBytes(result);\n  return result;\n}\n\n/**\n * Encodes a U512 integer as a 64-byte big-endian byte array.\n *\n * @public\n * @param value - The U512 value to encode (range [0, 2^512 - 1])\n * @returns A Uint8Array of length 64 in big-endian byte order (MSB at index 0)\n *\n * @remarks\n * Input type: U512 (bigint, range [0, 2^512 - 1]).\n * Output type: U512BeBytes (Uint8Array of length 64, big-endian).\n * Iterates indices from 63 down to 0, writing low byte then shifting right by 8 bits.\n * MSB is at index 0.\n *\n * @example\n * ```typescript\n * const bytes = encodeU512ToU512BeBytes(assertU512(1n));\n * // bytes[0..62] = 0; bytes[63] = 1\n * ```\n *\n * @see {@link decodeU512BeBytesToU512} for the inverse decoding\n * @see {@link encodeU512ToU512LeBytes} for the little-endian variant\n */\nexport function encodeU512ToU512BeBytes(value: U512): U512BeBytes {\n  assertU512(value);\n  const result = new Uint8Array(U512_BYTE_LENGTH);\n  let temporary: bigint = value;\n  for (let index = U512_BYTE_LENGTH - 1; index >= 0; index--) {\n    result[index] = Number(temporary & 0xffn);\n    temporary >>= 8n;\n  }\n  assertU512BeBytes(result);\n  return result;\n}\n\n/**\n * Encodes a U1024 integer as a 128-byte little-endian byte array.\n *\n * @public\n * @param value - The U1024 value to encode (range [0, 2^1024 - 1])\n * @returns A Uint8Array of length 128 in little-endian byte order (LSB at index 0)\n *\n * @remarks\n * Input type: U1024 (bigint, range [0, 2^1024 - 1]).\n * Output type: U1024LeBytes (Uint8Array of length 128, little-endian).\n * Iterates indices 0..127, writing low byte then shifting right by 8 bits each step.\n *\n * @example\n * ```typescript\n * const bytes = encodeU1024ToU1024LeBytes(assertU1024(2n ** 512n));\n * // bytes[64] = 1; all others = 0\n * ```\n *\n * @see {@link decodeU1024LeBytesToU1024} for the inverse decoding\n * @see {@link encodeU1024ToU1024BeBytes} for the big-endian variant\n */\nexport function encodeU1024ToU1024LeBytes(value: U1024): U1024LeBytes {\n  assertU1024(value);\n  const result = new Uint8Array(U1024_BYTE_LENGTH);\n  let temporary: bigint = value;\n  for (let index = 0; index < U1024_BYTE_LENGTH; index++) {\n    result[index] = Number(temporary & 0xffn);\n    temporary >>= 8n;\n  }\n  assertU1024LeBytes(result);\n  return result;\n}\n\n/**\n * Encodes a U1024 integer as a 128-byte big-endian byte array.\n *\n * @public\n * @param value - The U1024 value to encode (range [0, 2^1024 - 1])\n * @returns A Uint8Array of length 128 in big-endian byte order (MSB at index 0)\n *\n * @remarks\n * Input type: U1024 (bigint, range [0, 2^1024 - 1]).\n * Output type: U1024BeBytes (Uint8Array of length 128, big-endian).\n * Iterates indices from 127 down to 0, writing low byte then shifting right by 8 bits.\n * MSB is at index 0.\n *\n * @example\n * ```typescript\n * const bytes = encodeU1024ToU1024BeBytes(assertU1024(1n));\n * // bytes[0..126] = 0; bytes[127] = 1\n * ```\n *\n * @see {@link decodeU1024BeBytesToU1024} for the inverse decoding\n * @see {@link encodeU1024ToU1024LeBytes} for the little-endian variant\n */\nexport function encodeU1024ToU1024BeBytes(value: U1024): U1024BeBytes {\n  assertU1024(value);\n  const result = new Uint8Array(U1024_BYTE_LENGTH);\n  let temporary: bigint = value;\n  for (let index = U1024_BYTE_LENGTH - 1; index >= 0; index--) {\n    result[index] = Number(temporary & 0xffn);\n    temporary >>= 8n;\n  }\n  assertU1024BeBytes(result);\n  return result;\n}\n\n/* =============================================================================\n * BYTE ARRAY TO INTEGER DECODING\n *\n * Decode byte arrays to integers from specified endianness.\n * ============================================================================= */\n\n/**\n * Decodes a 1-byte little-endian byte array to a U8 integer.\n *\n * @public\n * @param value - The U8LeBytes array (Uint8Array of length 1) to decode\n * @returns The decoded value as U8\n *\n * @remarks\n * Input type: U8LeBytes (Uint8Array of length 1, little-endian).\n * Output type: U8 (bigint, range [0, 255]).\n * Decoding: `BigInt(value[0])`. For a single byte there is no endianness ambiguity.\n *\n * @example\n * ```typescript\n * const bytes = encodeU8ToU8LeBytes(assertU8(42n));\n * const u8Value = decodeU8LeBytesToU8(bytes); // 42n\n * ```\n *\n * @see {@link encodeU8ToU8LeBytes} for the inverse encoding\n * @see {@link decodeU8BeBytesToU8} for the big-endian variant (identical result)\n */\nexport function decodeU8LeBytesToU8(value: U8LeBytes): U8 {\n  assertU8LeBytes(value);\n\n  const result = BigInt(value[0]);\n  assertU8(result);\n  return result;\n}\n\n/**\n * Decodes a 1-byte big-endian byte array to a U8 integer.\n *\n * @public\n * @param value - The U8BeBytes array (Uint8Array of length 1) to decode\n * @returns The decoded value as U8\n *\n * @remarks\n * Input type: U8BeBytes (Uint8Array of length 1, big-endian).\n * Output type: U8 (bigint, range [0, 255]).\n * Decoding: `BigInt(value[0])`. For a single byte there is no endianness ambiguity.\n *\n * @example\n * ```typescript\n * const bytes = encodeU8ToU8BeBytes(assertU8(255n));\n * const u8Value = decodeU8BeBytesToU8(bytes); // 255n\n * ```\n *\n * @see {@link encodeU8ToU8BeBytes} for the inverse encoding\n * @see {@link decodeU8LeBytesToU8} for the little-endian variant (identical result)\n */\nexport function decodeU8BeBytesToU8(value: U8BeBytes): U8 {\n  assertU8BeBytes(value);\n\n  const result = BigInt(value[0]);\n  assertU8(result);\n  return result;\n}\n\n/**\n * Decodes a 2-byte little-endian byte array to a U16 integer.\n *\n * @public\n * @param value - The U16LeBytes array (Uint8Array of length 2, LSB at index 0) to decode\n * @returns The decoded value as U16\n *\n * @remarks\n * Input type: U16LeBytes (Uint8Array of length 2, little-endian — byte[0] is LSB).\n * Output type: U16 (bigint, range [0, 65535]).\n * Decoding algorithm: iterates from index LENGTH-1 down to 0, accumulating\n * `result = (result << 8n) | BigInt(value[index])`. Starting from the high index\n * of a LE array means the first byte consumed is the most-significant byte of the\n * stored value, producing the correct big-endian accumulation.\n *\n * @example\n * ```typescript\n * // [0x02, 0x01] in LE encodes 0x0102 = 258\n * const bytes = encodeU16ToU16LeBytes(assertU16(258n));\n * const u16Value = decodeU16LeBytesToU16(bytes); // 258n\n * ```\n *\n * @see {@link encodeU16ToU16LeBytes} for the inverse encoding\n * @see {@link decodeU16BeBytesToU16} for the big-endian variant\n */\nexport function decodeU16LeBytesToU16(value: U16LeBytes): U16 {\n  assertU16LeBytes(value);\n  let result = 0n;\n  for (let index = U16_BYTE_LENGTH - 1; index >= 0; index--) {\n    result = (result << 8n) | BigInt(value[index]);\n  }\n  assertU16(result);\n  return result;\n}\n\n/**\n * Decodes a 2-byte big-endian byte array to a U16 integer.\n *\n * @public\n * @param value - The U16BeBytes array (Uint8Array of length 2, MSB at index 0) to decode\n * @returns The decoded value as U16\n *\n * @remarks\n * Input type: U16BeBytes (Uint8Array of length 2, big-endian — byte[0] is MSB).\n * Output type: U16 (bigint, range [0, 65535]).\n * Decoding algorithm: iterates from index 0 to LENGTH-1, accumulating\n * `result = (result << 8n) | BigInt(value[index])`. Reading from the MSB first\n * produces the correct integer value.\n *\n * @example\n * ```typescript\n * // [0x01, 0x02] in BE encodes 0x0102 = 258\n * const bytes = encodeU16ToU16BeBytes(assertU16(258n));\n * const u16Value = decodeU16BeBytesToU16(bytes); // 258n\n * ```\n *\n * @see {@link encodeU16ToU16BeBytes} for the inverse encoding\n * @see {@link decodeU16LeBytesToU16} for the little-endian variant\n */\nexport function decodeU16BeBytesToU16(value: U16BeBytes): U16 {\n  assertU16BeBytes(value);\n  let result = 0n;\n  for (let index = 0; index < U16_BYTE_LENGTH; index++) {\n    result = (result << 8n) | BigInt(value[index]);\n  }\n  assertU16(result);\n  return result;\n}\n\n/**\n * Decodes a 4-byte little-endian byte array to a U32 integer.\n *\n * @public\n * @param value - The U32LeBytes array (Uint8Array of length 4, LSB at index 0) to decode\n * @returns The decoded value as U32\n *\n * @remarks\n * Input type: U32LeBytes (Uint8Array of length 4, little-endian — byte[0] is LSB).\n * Output type: U32 (bigint, range [0, 4294967295]).\n * Decoding algorithm: iterates from index LENGTH-1 down to 0, accumulating with\n * left-shift-8 and OR at each step.\n *\n * @example\n * ```typescript\n * const bytes = encodeU32ToU32LeBytes(assertU32(0x01020304n));\n * // bytes = [0x04, 0x03, 0x02, 0x01]\n * const u32Value = decodeU32LeBytesToU32(bytes); // 0x01020304n\n * ```\n *\n * @see {@link encodeU32ToU32LeBytes} for the inverse encoding\n * @see {@link decodeU32BeBytesToU32} for the big-endian variant\n */\nexport function decodeU32LeBytesToU32(value: U32LeBytes): U32 {\n  assertU32LeBytes(value);\n  let result = 0n;\n  for (let index = U32_BYTE_LENGTH - 1; index >= 0; index--) {\n    result = (result << 8n) | BigInt(value[index]);\n  }\n  assertU32(result);\n  return result;\n}\n\n/**\n * Decodes a 4-byte big-endian byte array to a U32 integer.\n *\n * @public\n * @param value - The U32BeBytes array (Uint8Array of length 4, MSB at index 0) to decode\n * @returns The decoded value as U32\n *\n * @remarks\n * Input type: U32BeBytes (Uint8Array of length 4, big-endian — byte[0] is MSB).\n * Output type: U32 (bigint, range [0, 4294967295]).\n * Decoding algorithm: iterates from index 0 to LENGTH-1, accumulating with\n * left-shift-8 and OR at each step.\n *\n * @example\n * ```typescript\n * const bytes = encodeU32ToU32BeBytes(assertU32(0x01020304n));\n * // bytes = [0x01, 0x02, 0x03, 0x04]\n * const u32Value = decodeU32BeBytesToU32(bytes); // 0x01020304n\n * ```\n *\n * @see {@link encodeU32ToU32BeBytes} for the inverse encoding\n * @see {@link decodeU32LeBytesToU32} for the little-endian variant\n */\nexport function decodeU32BeBytesToU32(value: U32BeBytes): U32 {\n  assertU32BeBytes(value);\n  let result = 0n;\n  for (let index = 0; index < U32_BYTE_LENGTH; index++) {\n    result = (result << 8n) | BigInt(value[index]);\n  }\n  assertU32(result);\n  return result;\n}\n\n/**\n * Decodes an 8-byte little-endian byte array to a U64 integer.\n *\n * @public\n * @param value - The U64LeBytes array (Uint8Array of length 8, LSB at index 0) to decode\n * @returns The decoded value as U64\n *\n * @remarks\n * Input type: U64LeBytes (Uint8Array of length 8, little-endian — byte[0] is LSB).\n * Output type: U64 (bigint, range [0, 2^64 - 1]).\n * Decoding algorithm: iterates from index LENGTH-1 down to 0, accumulating with\n * left-shift-8 and OR at each step.\n * Commonly used to read Solana lamport amounts and 64-bit fields from account data.\n *\n * @example\n * ```typescript\n * const bytes = encodeU64ToU64LeBytes(assertU64(1000n));\n * const u64Value = decodeU64LeBytesToU64(bytes); // 1000n\n * ```\n *\n * @see {@link encodeU64ToU64LeBytes} for the inverse encoding\n * @see {@link decodeU64BeBytesToU64} for the big-endian variant\n */\nexport function decodeU64LeBytesToU64(value: U64LeBytes): U64 {\n  assertU64LeBytes(value);\n  let result = 0n;\n  for (let index = U64_BYTE_LENGTH - 1; index >= 0; index--) {\n    result = (result << 8n) | BigInt(value[index]);\n  }\n  assertU64(result);\n  return result;\n}\n\n/**\n * Decodes an 8-byte big-endian byte array to a U64 integer.\n *\n * @public\n * @param value - The U64BeBytes array (Uint8Array of length 8, MSB at index 0) to decode\n * @returns The decoded value as U64\n *\n * @remarks\n * Input type: U64BeBytes (Uint8Array of length 8, big-endian — byte[0] is MSB).\n * Output type: U64 (bigint, range [0, 2^64 - 1]).\n * Decoding algorithm: iterates from index 0 to LENGTH-1, accumulating with\n * left-shift-8 and OR at each step.\n *\n * @example\n * ```typescript\n * const bytes = encodeU64ToU64BeBytes(assertU64(1000n));\n * const u64Value = decodeU64BeBytesToU64(bytes); // 1000n\n * ```\n *\n * @see {@link encodeU64ToU64BeBytes} for the inverse encoding\n * @see {@link decodeU64LeBytesToU64} for the little-endian variant\n */\nexport function decodeU64BeBytesToU64(value: U64BeBytes): U64 {\n  assertU64BeBytes(value);\n  let result = 0n;\n  for (let index = 0; index < U64_BYTE_LENGTH; index++) {\n    result = (result << 8n) | BigInt(value[index]);\n  }\n  assertU64(result);\n  return result;\n}\n\n/**\n * Decodes a 16-byte little-endian byte array to a U128 integer.\n *\n * @public\n * @param value - The U128LeBytes array (Uint8Array of length 16, LSB at index 0) to decode\n * @returns The decoded value as U128\n *\n * @remarks\n * Input type: U128LeBytes (Uint8Array of length 16, little-endian — byte[0] is LSB).\n * Output type: U128 (bigint, range [0, 2^128 - 1]).\n * Decoding algorithm: iterates from index LENGTH-1 down to 0, accumulating with\n * left-shift-8 and OR at each step.\n * Used to decode 128-bit nonces and RcEncryptionNonce values from on-chain data.\n *\n * @example\n * ```typescript\n * const bytes = encodeU128ToU128LeBytes(assertU128(2n ** 64n));\n * const u128Value = decodeU128LeBytesToU128(bytes); // 2n ** 64n\n * ```\n *\n * @see {@link encodeU128ToU128LeBytes} for the inverse encoding\n * @see {@link decodeU128BeBytesToU128} for the big-endian variant\n */\nexport function decodeU128LeBytesToU128(value: U128LeBytes): U128 {\n  assertU128LeBytes(value);\n  let result = 0n;\n  for (let index = U128_BYTE_LENGTH - 1; index >= 0; index--) {\n    result = (result << 8n) | BigInt(value[index]);\n  }\n  assertU128(result);\n  return result;\n}\n\n/**\n * Decodes a 16-byte big-endian byte array to a U128 integer.\n *\n * @public\n * @param value - The U128BeBytes array (Uint8Array of length 16, MSB at index 0) to decode\n * @returns The decoded value as U128\n *\n * @remarks\n * Input type: U128BeBytes (Uint8Array of length 16, big-endian — byte[0] is MSB).\n * Output type: U128 (bigint, range [0, 2^128 - 1]).\n * Decoding algorithm: iterates from index 0 to LENGTH-1, accumulating with\n * left-shift-8 and OR at each step.\n *\n * @example\n * ```typescript\n * const bytes = encodeU128ToU128BeBytes(assertU128(2n ** 64n));\n * const u128Value = decodeU128BeBytesToU128(bytes); // 2n ** 64n\n * ```\n *\n * @see {@link encodeU128ToU128BeBytes} for the inverse encoding\n * @see {@link decodeU128LeBytesToU128} for the little-endian variant\n */\nexport function decodeU128BeBytesToU128(value: U128BeBytes): U128 {\n  assertU128BeBytes(value);\n  let result = 0n;\n  for (let index = 0; index < U128_BYTE_LENGTH; index++) {\n    result = (result << 8n) | BigInt(value[index]);\n  }\n  assertU128(result);\n  return result;\n}\n\n/**\n * Decodes a 32-byte little-endian byte array to a U256 integer.\n *\n * @public\n * @param value - The U256LeBytes array (Uint8Array of length 32, LSB at index 0) to decode\n * @returns The decoded value as U256\n *\n * @remarks\n * Input type: U256LeBytes (Uint8Array of length 32, little-endian — byte[0] is LSB).\n * Output type: U256 (bigint, range [0, 2^256 - 1]).\n * Decoding algorithm: iterates from index LENGTH-1 down to 0, accumulating with\n * left-shift-8 and OR at each step.\n * Commonly used to read X25519 public keys, Poseidon hashes, and UTXO commitments\n * from Solana account data.\n *\n * @example\n * ```typescript\n * const bytes = encodeU256ToU256LeBytes(assertU256(2n ** 200n));\n * const u256Value = decodeU256LeBytesToU256(bytes); // 2n ** 200n\n * ```\n *\n * @see {@link encodeU256ToU256LeBytes} for the inverse encoding\n * @see {@link decodeU256BeBytesToU256} for the big-endian variant\n */\nexport function decodeU256LeBytesToU256(value: U256LeBytes): U256 {\n  assertU256LeBytes(value);\n  let result = 0n;\n  for (let index = U256_BYTE_LENGTH - 1; index >= 0; index--) {\n    result = (result << 8n) | BigInt(value[index]);\n  }\n  assertU256(result);\n  return result;\n}\n\n/**\n * Decodes a 32-byte big-endian byte array to a U256 integer.\n *\n * @public\n * @param value - The U256BeBytes array (Uint8Array of length 32, MSB at index 0) to decode\n * @returns The decoded value as U256\n *\n * @remarks\n * Input type: U256BeBytes (Uint8Array of length 32, big-endian — byte[0] is MSB).\n * Output type: U256 (bigint, range [0, 2^256 - 1]).\n * Decoding algorithm: iterates from index 0 to LENGTH-1, accumulating with\n * left-shift-8 and OR at each step.\n * Used to decode BN254/Groth16 field elements received in BE wire format.\n *\n * @example\n * ```typescript\n * const bytes = encodeU256ToU256BeBytes(assertU256(2n ** 200n));\n * const u256Value = decodeU256BeBytesToU256(bytes); // 2n ** 200n\n * ```\n *\n * @see {@link encodeU256ToU256BeBytes} for the inverse encoding\n * @see {@link decodeU256LeBytesToU256} for the little-endian variant\n */\nexport function decodeU256BeBytesToU256(value: U256BeBytes): U256 {\n  assertU256BeBytes(value);\n  let result = 0n;\n  for (let index = 0; index < U256_BYTE_LENGTH; index++) {\n    result = (result << 8n) | BigInt(value[index]);\n  }\n  assertU256(result);\n  return result;\n}\n\n/**\n * Decodes a 64-byte little-endian byte array to a U512 integer.\n *\n * @public\n * @param value - The U512LeBytes array (Uint8Array of length 64, LSB at index 0) to decode\n * @returns The decoded value as U512\n *\n * @remarks\n * Input type: U512LeBytes (Uint8Array of length 64, little-endian — byte[0] is LSB).\n * Output type: U512 (bigint, range [0, 2^512 - 1]).\n * Decoding algorithm: iterates from index LENGTH-1 down to 0, accumulating with\n * left-shift-8 and OR at each step.\n *\n * @example\n * ```typescript\n * const bytes = encodeU512ToU512LeBytes(assertU512(2n ** 400n));\n * const u512Value = decodeU512LeBytesToU512(bytes); // 2n ** 400n\n * ```\n *\n * @see {@link encodeU512ToU512LeBytes} for the inverse encoding\n * @see {@link decodeU512BeBytesToU512} for the big-endian variant\n */\nexport function decodeU512LeBytesToU512(value: U512LeBytes): U512 {\n  assertU512LeBytes(value);\n  let result = 0n;\n  for (let index = U512_BYTE_LENGTH - 1; index >= 0; index--) {\n    result = (result << 8n) | BigInt(value[index]);\n  }\n  assertU512(result);\n  return result;\n}\n\n/**\n * Decodes a 64-byte big-endian byte array to a U512 integer.\n *\n * @public\n * @param value - The U512BeBytes array (Uint8Array of length 64, MSB at index 0) to decode\n * @returns The decoded value as U512\n *\n * @remarks\n * Input type: U512BeBytes (Uint8Array of length 64, big-endian — byte[0] is MSB).\n * Output type: U512 (bigint, range [0, 2^512 - 1]).\n * Decoding algorithm: iterates from index 0 to LENGTH-1, accumulating with\n * left-shift-8 and OR at each step.\n *\n * @example\n * ```typescript\n * const bytes = encodeU512ToU512BeBytes(assertU512(2n ** 400n));\n * const u512Value = decodeU512BeBytesToU512(bytes); // 2n ** 400n\n * ```\n *\n * @see {@link encodeU512ToU512BeBytes} for the inverse encoding\n * @see {@link decodeU512LeBytesToU512} for the little-endian variant\n */\nexport function decodeU512BeBytesToU512(value: U512BeBytes): U512 {\n  assertU512BeBytes(value);\n  let result = 0n;\n  for (let index = 0; index < U512_BYTE_LENGTH; index++) {\n    result = (result << 8n) | BigInt(value[index]);\n  }\n  assertU512(result);\n  return result;\n}\n\n/**\n * Decodes a 128-byte little-endian byte array to a U1024 integer.\n *\n * @public\n * @param value - The U1024LeBytes array (Uint8Array of length 128, LSB at index 0) to decode\n * @returns The decoded value as U1024\n *\n * @remarks\n * Input type: U1024LeBytes (Uint8Array of length 128, little-endian — byte[0] is LSB).\n * Output type: U1024 (bigint, range [0, 2^1024 - 1]).\n * Decoding algorithm: iterates from index LENGTH-1 down to 0, accumulating with\n * left-shift-8 and OR at each step.\n *\n * @example\n * ```typescript\n * const bytes = encodeU1024ToU1024LeBytes(assertU1024(2n ** 900n));\n * const u1024Value = decodeU1024LeBytesToU1024(bytes); // 2n ** 900n\n * ```\n *\n * @see {@link encodeU1024ToU1024LeBytes} for the inverse encoding\n * @see {@link decodeU1024BeBytesToU1024} for the big-endian variant\n */\nexport function decodeU1024LeBytesToU1024(value: U1024LeBytes): U1024 {\n  assertU1024LeBytes(value);\n  let result = 0n;\n  for (let index = U1024_BYTE_LENGTH - 1; index >= 0; index--) {\n    result = (result << 8n) | BigInt(value[index]);\n  }\n  assertU1024(result);\n  return result;\n}\n\n/**\n * Decodes a 128-byte big-endian byte array to a U1024 integer.\n *\n * @public\n * @param value - The U1024BeBytes array (Uint8Array of length 128, MSB at index 0) to decode\n * @returns The decoded value as U1024\n *\n * @remarks\n * Input type: U1024BeBytes (Uint8Array of length 128, big-endian — byte[0] is MSB).\n * Output type: U1024 (bigint, range [0, 2^1024 - 1]).\n * Decoding algorithm: iterates from index 0 to LENGTH-1, accumulating with\n * left-shift-8 and OR at each step.\n *\n * @example\n * ```typescript\n * const bytes = encodeU1024ToU1024BeBytes(assertU1024(2n ** 900n));\n * const u1024Value = decodeU1024BeBytesToU1024(bytes); // 2n ** 900n\n * ```\n *\n * @see {@link encodeU1024ToU1024BeBytes} for the inverse encoding\n * @see {@link decodeU1024LeBytesToU1024} for the little-endian variant\n */\nexport function decodeU1024BeBytesToU1024(value: U1024BeBytes): U1024 {\n  assertU1024BeBytes(value);\n  let result = 0n;\n  for (let index = 0; index < U1024_BYTE_LENGTH; index++) {\n    result = (result << 8n) | BigInt(value[index]);\n  }\n  assertU1024(result);\n  return result;\n}\n"]}

package/dist/chunk-5KPQXPQM.js

@@ -0,0 +1,36 @@
+import { UmbraError } from './chunk-4TZVXB5G.js';
+import { __name } from './chunk-7QVYU63E.js';
+
+// src/crypto/errors.ts
+var CryptographyError = class extends UmbraError {
+  static {
+    __name(this, "CryptographyError");
+  }
+  /**
+   * The cryptographic operation that failed.
+   */
+  operation;
+  constructor(message, options) {
+    super(message, {
+      code: options?.code ?? "CRYPTOGRAPHY_ERROR",
+      ...options?.context !== void 0 && {
+        context: options.context
+      },
+      ...options?.cause !== void 0 && {
+        cause: options.cause
+      }
+    });
+    this.name = "CryptographyError";
+    if (options?.operation !== void 0) {
+      this.operation = options.operation;
+    }
+  }
+};
+function isCryptographyError(error) {
+  return error instanceof CryptographyError;
+}
+__name(isCryptographyError, "isCryptographyError");
+
+export { CryptographyError, isCryptographyError };
+//# sourceMappingURL=chunk-5KPQXPQM.js.map
+//# sourceMappingURL=chunk-5KPQXPQM.js.map

package/dist/chunk-5KPQXPQM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/crypto/errors.ts"],"names":[],"mappings":";;;;AA4BO,IAAM,iBAAA,GAAN,cAAgC,UAAA,CAAW;AAAA,EA5BlD;AA4BkD,IAAA,MAAA,CAAA,IAAA,EAAA,mBAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAIvC,SAAA;AAAA,EAET,WAAA,CACE,SACA,OAAA,EAMA;AACA,IAAA,KAAA,CAAM,OAAA,EAAS;AAAA,MACb,IAAA,EAAM,SAAS,IAAA,IAAQ,oBAAA;AAAA,MACvB,GAAI,OAAA,EAAS,OAAA,KAAY,MAAA,IAAa;AAAA,QACpC,SAAS,OAAA,CAAQ;AAAA,OACnB;AAAA,MACA,GAAI,OAAA,EAAS,KAAA,KAAU,MAAA,IAAa;AAAA,QAClC,OAAO,OAAA,CAAQ;AAAA;AACjB,KACD,CAAA;AACD,IAAA,IAAA,CAAK,IAAA,GAAO,mBAAA;AACZ,IAAA,IAAI,OAAA,EAAS,cAAc,MAAA,EAAW;AACpC,MAAA,IAAA,CAAK,YAAY,OAAA,CAAQ,SAAA;AAAA,IAC3B;AAAA,EACF;AACF;AAKO,SAAS,oBAAoB,KAAA,EAA4C;AAC9E,EAAA,OAAO,KAAA,YAAiB,iBAAA;AAC1B;AAFgB,MAAA,CAAA,mBAAA,EAAA,qBAAA,CAAA","file":"chunk-5KPQXPQM.js","sourcesContent":["/**\n * Cryptography Error Classes\n *\n * This module provides error classes for cryptographic operation failures\n * in the Umbra SDK.\n *\n * @module crypto/errors\n */\n\nimport { UmbraError } from \"../common/errors\";\n\n/**\n * Error thrown when a cryptographic operation fails.\n *\n * This includes key derivation failures, encryption/decryption errors,\n * hash computation failures, and ZK proof generation errors.\n *\n * @example\n * ```typescript\n * try {\n *   const commitment = await generateUserCommitment(mvk, index, seed);\n * } catch (error) {\n *   if (error instanceof CryptographyError) {\n *     console.log('Crypto operation failed:', error.operation);\n *   }\n * }\n * ```\n */\nexport class CryptographyError extends UmbraError {\n  /**\n   * The cryptographic operation that failed.\n   */\n  readonly operation?: string;\n\n  constructor(\n    message: string,\n    options?: {\n      code?: string;\n      operation?: string;\n      context?: Record<string, unknown>;\n      cause?: unknown;\n    },\n  ) {\n    super(message, {\n      code: options?.code ?? \"CRYPTOGRAPHY_ERROR\",\n      ...(options?.context !== undefined && {\n        context: options.context,\n      }),\n      ...(options?.cause !== undefined && {\n        cause: options.cause,\n      }),\n    });\n    this.name = \"CryptographyError\";\n    if (options?.operation !== undefined) {\n      this.operation = options.operation;\n    }\n  }\n}\n\n/**\n * Type guard to check if an error is a CryptographyError.\n */\nexport function isCryptographyError(error: unknown): error is CryptographyError {\n  return error instanceof CryptographyError;\n}\n"]}

package/dist/chunk-AXD7LXYY.cjs

@@ -0,0 +1,405 @@
+'use strict';
+
+var chunkENVYYEM4_cjs = require('./chunk-ENVYYEM4.cjs');
+var chunkFZYWLQAF_cjs = require('./chunk-FZYWLQAF.cjs');
+var chunkPK6SKIKE_cjs = require('./chunk-PK6SKIKE.cjs');
+var kit = require('@solana/kit');
+var walletStandardFeatures = require('@solana/wallet-standard-features');
+
+function getRpcAccountInfoProvider(config) {
+  const { rpcUrl } = config;
+  let rpcClient = null;
+  function getRpc() {
+    rpcClient ??= kit.createSolanaRpc(rpcUrl);
+    return rpcClient;
+  }
+  chunkPK6SKIKE_cjs.__name(getRpc, "getRpc");
+  return async (addresses, options) => {
+    const commitment = options?.commitment ?? "confirmed";
+    if (addresses.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const uniqueAddresses = [];
+    for (const addr of addresses) {
+      const key = addr.toString();
+      if (!seen.has(key)) {
+        seen.add(key);
+        uniqueAddresses.push(addr);
+      }
+    }
+    const rpc = getRpc();
+    const accounts = await kit.fetchEncodedAccounts(rpc, uniqueAddresses, { commitment });
+    const result = /* @__PURE__ */ new Map();
+    for (const [index, uniqueAddress] of uniqueAddresses.entries()) {
+      result.set(uniqueAddress, accounts[index]);
+    }
+    return result;
+  };
+}
+chunkPK6SKIKE_cjs.__name(getRpcAccountInfoProvider, "getRpcAccountInfoProvider");
+function getRpcBlockhashProvider(config, deps) {
+  const { rpcUrl } = config;
+  const { createRpc = kit.createSolanaRpc } = deps ?? {};
+  const rpc = createRpc(rpcUrl);
+  return async (options) => {
+    const commitment = options?.commitment ?? "confirmed";
+    const response = await rpc.getLatestBlockhash({ commitment }).send();
+    return {
+      blockhash: response.value.blockhash,
+      lastValidBlockHeight: response.value.lastValidBlockHeight
+    };
+  };
+}
+chunkPK6SKIKE_cjs.__name(getRpcBlockhashProvider, "getRpcBlockhashProvider");
+function getRpcEpochInfoProvider(config, deps) {
+  const { rpcUrl } = config;
+  const { createRpc = kit.createSolanaRpc } = deps ?? {};
+  const rpc = createRpc(rpcUrl);
+  return async (options) => {
+    const commitment = options?.commitment ?? "confirmed";
+    const response = await rpc.getEpochInfo({ commitment }).send();
+    return {
+      epoch: response.epoch,
+      slotIndex: response.slotIndex,
+      slotsInEpoch: response.slotsInEpoch,
+      absoluteSlot: response.absoluteSlot,
+      blockHeight: response.blockHeight,
+      ...response.transactionCount !== null && {
+        transactionCount: response.transactionCount
+      }
+    };
+  };
+}
+chunkPK6SKIKE_cjs.__name(getRpcEpochInfoProvider, "getRpcEpochInfoProvider");
+function convertSolanaKitKeypairSignerToIUmbraSigner(kps) {
+  return {
+    address: kps.address,
+    async signTransaction(transaction) {
+      const kitTx = transaction;
+      const [sigDict] = await kps.signTransactions([kitTx]);
+      return {
+        ...transaction,
+        signatures: { ...transaction.signatures, ...sigDict }
+      };
+    },
+    async signTransactions(transactions) {
+      const kitTxs = transactions;
+      const sigDicts = await kps.signTransactions(kitTxs);
+      return transactions.map((tx, index) => ({
+        ...tx,
+        signatures: { ...tx.signatures, ...sigDicts[index] }
+      }));
+    },
+    async signMessage(message) {
+      const signature = await kit.signBytes(kps.keyPair.privateKey, message);
+      return { message, signature, signer: kps.address };
+    }
+  };
+}
+chunkPK6SKIKE_cjs.__name(convertSolanaKitKeypairSignerToIUmbraSigner, "convertSolanaKitKeypairSignerToIUmbraSigner");
+function convertWalletStandardAccountToIUmbraSigner(wallet, account) {
+  const walletFeatures = wallet.features;
+  const signTxFeature = walletFeatures[walletStandardFeatures.SolanaSignTransaction];
+  const signMessageFeature = walletFeatures[walletStandardFeatures.SolanaSignMessage];
+  if (signTxFeature === void 0) {
+    throw new Error(
+      `Wallet "${wallet.name}" does not support the "${walletStandardFeatures.SolanaSignTransaction}" feature`
+    );
+  }
+  if (signMessageFeature === void 0) {
+    throw new Error(`Wallet "${wallet.name}" does not support the "${walletStandardFeatures.SolanaSignMessage}" feature`);
+  }
+  const encoder = kit.getTransactionEncoder();
+  const decoder = kit.getTransactionDecoder();
+  return {
+    address: account.address,
+    async signTransaction(transaction) {
+      const wireBytes = encoder.encode(transaction);
+      const [output] = await signTxFeature.signTransaction({ account, transaction: wireBytes });
+      const decoded = decoder.decode(output.signedTransaction);
+      return {
+        ...transaction,
+        signatures: { ...transaction.signatures, ...decoded.signatures }
+      };
+    },
+    async signTransactions(transactions) {
+      const inputs = transactions.map((tx) => ({
+        account,
+        transaction: encoder.encode(tx)
+      }));
+      const outputs = await signTxFeature.signTransaction(...inputs);
+      return transactions.map((tx, index) => {
+        const decoded = decoder.decode(outputs[index].signedTransaction);
+        return {
+          ...tx,
+          signatures: { ...tx.signatures, ...decoded.signatures }
+        };
+      });
+    },
+    async signMessage(message) {
+      const [output] = await signMessageFeature.signMessage({ account, message });
+      return {
+        message,
+        // Cast required: Wallet Standard returns its own signature type,
+        // we need @solana/kit's SignatureBytes. Both are 64-byte Uint8Array.
+        signature: output.signature,
+        signer: account.address
+      };
+    }
+  };
+}
+chunkPK6SKIKE_cjs.__name(convertWalletStandardAccountToIUmbraSigner, "convertWalletStandardAccountToIUmbraSigner");
+async function createInMemorySigner() {
+  const kps = await kit.generateKeyPairSigner();
+  return convertSolanaKitKeypairSignerToIUmbraSigner(kps);
+}
+chunkPK6SKIKE_cjs.__name(createInMemorySigner, "createInMemorySigner");
+async function createSignerFromPrivateKeyBytes(bytes) {
+  const kps = await kit.createKeyPairSignerFromBytes(bytes);
+  return convertSolanaKitKeypairSignerToIUmbraSigner(kps);
+}
+chunkPK6SKIKE_cjs.__name(createSignerFromPrivateKeyBytes, "createSignerFromPrivateKeyBytes");
+function createSignerFromKeyPair(kps) {
+  return convertSolanaKitKeypairSignerToIUmbraSigner(kps);
+}
+chunkPK6SKIKE_cjs.__name(createSignerFromKeyPair, "createSignerFromKeyPair");
+function createSignerFromWalletAccount(wallet, account) {
+  return convertWalletStandardAccountToIUmbraSigner(wallet, account);
+}
+chunkPK6SKIKE_cjs.__name(createSignerFromWalletAccount, "createSignerFromWalletAccount");
+function assertKitCompatibleTransaction(transaction) {
+  if (transaction.messageBytes === void 0) {
+    throw new Error("Transaction is missing messageBytes — not a valid signed transaction");
+  }
+}
+chunkPK6SKIKE_cjs.__name(assertKitCompatibleTransaction, "assertKitCompatibleTransaction");
+function toTransactionSignature(signature) {
+  const sigString = signature.toString();
+  chunkFZYWLQAF_cjs.assertTransactionSignature(sigString);
+  return sigString;
+}
+chunkPK6SKIKE_cjs.__name(toTransactionSignature, "toTransactionSignature");
+function getWebsocketTransactionForwarder(config, deps) {
+  const { rpcUrl, rpcSubscriptionsUrl } = config;
+  const {
+    createRpc = kit.createSolanaRpc,
+    createRpcSubscriptions = kit.createSolanaRpcSubscriptions,
+    sendAndConfirmTransactionFactory = kit.sendAndConfirmTransactionFactory
+  } = deps ?? {};
+  const rpc = createRpc(rpcUrl);
+  const rpcSubscriptions = createRpcSubscriptions(rpcSubscriptionsUrl);
+  const sendAndConfirm = sendAndConfirmTransactionFactory({
+    rpc,
+    rpcSubscriptions
+  });
+  async function sendAndConfirmTransaction(transaction, options) {
+    const commitment = options.commitment ?? "confirmed";
+    assertKitCompatibleTransaction(transaction);
+    await sendAndConfirm(transaction, {
+      commitment
+    });
+    const signature = kit.getSignatureFromTransaction(transaction);
+    return toTransactionSignature(signature);
+  }
+  chunkPK6SKIKE_cjs.__name(sendAndConfirmTransaction, "sendAndConfirmTransaction");
+  return {
+    /**
+     * Forwards transactions one at a time, waiting for each to reach the
+     * requested commitment level before submitting the next.
+     *
+     * @param transactions - Ordered array of signed transactions.
+     * @param options - Forward options (commitment). Defaults to `"confirmed"`.
+     * @returns Array of confirmed signatures in input order.
+     */
+    forwardSequentially: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(async (transactions, options = {}) => {
+      const signatures = [];
+      for (const transaction of transactions) {
+        const signature = await sendAndConfirmTransaction(transaction, options);
+        signatures.push(signature);
+      }
+      return signatures;
+    }, "forwardSequentially"),
+    /**
+     * Forwards all transactions simultaneously via `Promise.all`.
+     *
+     * Each transaction is passed to `sendAndConfirmTransaction` concurrently.
+     * Results are returned in input order regardless of confirmation order.
+     *
+     * @param transactions - Array of signed transactions to submit in parallel.
+     * @param options - Forward options (commitment). Defaults to `"confirmed"`.
+     * @returns Array of confirmed signatures in input order.
+     */
+    forwardInParallel: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(async (transactions, options = {}) => {
+      const signaturePromises = transactions.map(
+        async (tx) => sendAndConfirmTransaction(tx, options)
+      );
+      return Promise.all(signaturePromises);
+    }, "forwardInParallel"),
+    fireAndForget: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(async (transaction) => {
+      const wireTransaction = kit.getBase64EncodedWireTransaction(transaction);
+      const response = await rpc.sendTransaction(wireTransaction, {
+        encoding: "base64",
+        skipPreflight: true
+      }).send();
+      return toTransactionSignature(response);
+    }, "fireAndForget")
+  };
+}
+chunkPK6SKIKE_cjs.__name(getWebsocketTransactionForwarder, "getWebsocketTransactionForwarder");
+function getPollingTransactionForwarder(config, deps) {
+  const { rpcUrl } = config;
+  const { createRpc = kit.createSolanaRpc } = deps ?? {};
+  const rpc = createRpc(rpcUrl);
+  async function sendTransactionOnly(transaction, commitment) {
+    const wireTransaction = kit.getBase64EncodedWireTransaction(transaction);
+    const response = await rpc.sendTransaction(wireTransaction, {
+      encoding: "base64",
+      preflightCommitment: commitment
+    }).send();
+    return toTransactionSignature(response);
+  }
+  chunkPK6SKIKE_cjs.__name(sendTransactionOnly, "sendTransactionOnly");
+  async function waitForConfirmation(signature, commitment, timeoutMs, pollingIntervalMs) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const response = await rpc.getSignatureStatuses([kit.signature(signature)], {
+        searchTransactionHistory: false
+      }).send();
+      const status = response.value[0];
+      if (status !== null) {
+        const confirmedCommitments = ["confirmed", "finalized"];
+        const finalizedCommitments = ["finalized"];
+        const confirmationStatus = status.confirmationStatus;
+        if (commitment === "processed" && confirmationStatus !== null) {
+          return;
+        }
+        if (commitment === "confirmed" && confirmationStatus !== null && confirmedCommitments.includes(confirmationStatus)) {
+          return;
+        }
+        if (commitment === "finalized" && confirmationStatus !== null && finalizedCommitments.includes(confirmationStatus)) {
+          return;
+        }
+        if (status.err !== null) {
+          throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
+        }
+      }
+      await chunkENVYYEM4_cjs.sleep(pollingIntervalMs);
+    }
+    throw new Error(`Transaction confirmation timed out after ${String(timeoutMs)}ms`);
+  }
+  chunkPK6SKIKE_cjs.__name(waitForConfirmation, "waitForConfirmation");
+  async function sendWithRetries(transaction, commitment, maxRetries) {
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        return await sendTransactionOnly(transaction, commitment);
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < maxRetries - 1) {
+          await chunkENVYYEM4_cjs.sleep(1e3 * (attempt + 1));
+        }
+      }
+    }
+    throw lastError ?? new Error("Failed to send transaction after retries");
+  }
+  chunkPK6SKIKE_cjs.__name(sendWithRetries, "sendWithRetries");
+  return {
+    /**
+     * Forwards transactions sequentially using polling-based confirmation.
+     *
+     * @remarks
+     * For each transaction in order:
+     * 1. Sends with retries (up to `maxRetries`).
+     * 2. Polls until confirmed (up to `timeoutMs`).
+     * 3. Invokes `onTransactionConfirmed` if provided (awaited).
+     *
+     * Aborts on first failure without submitting subsequent transactions.
+     *
+     * @param transactions - Ordered array of signed transactions.
+     * @param options - Polling-specific options. All fields have defaults.
+     * @returns Array of confirmed signatures in input order.
+     */
+    forwardSequentially: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(async (transactions, options = {}) => {
+      const {
+        commitment = "confirmed",
+        timeoutMs = 6e4,
+        pollingIntervalMs = 1e3,
+        maxRetries = 3,
+        onTransactionConfirmed
+      } = options;
+      const signatures = [];
+      const totalCount = transactions.length;
+      for (const [index, transaction] of transactions.entries()) {
+        const signature = await sendWithRetries(transaction, commitment, maxRetries);
+        await waitForConfirmation(signature, commitment, timeoutMs, pollingIntervalMs);
+        signatures.push(signature);
+        if (onTransactionConfirmed !== void 0) {
+          await onTransactionConfirmed({
+            signature,
+            index,
+            totalCount
+          });
+        }
+      }
+      return signatures;
+    }, "forwardSequentially"),
+    /**
+     * Forwards all transactions in parallel using polling-based confirmation.
+     *
+     * @remarks
+     * All transactions are sent concurrently (with retries), then all
+     * confirmations are awaited concurrently. The `onTransactionConfirmed`
+     * callback is NOT invoked during parallel forwarding.
+     *
+     * @param transactions - Array of signed transactions to submit in parallel.
+     * @param options - Polling-specific options. All fields have defaults.
+     * @returns Array of confirmed signatures in input order.
+     */
+    forwardInParallel: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(async (transactions, options = {}) => {
+      const {
+        commitment = "confirmed",
+        timeoutMs = 6e4,
+        pollingIntervalMs = 1e3,
+        maxRetries = 3
+      } = options;
+      const sendPromises = transactions.map(
+        async (tx) => sendWithRetries(tx, commitment, maxRetries)
+      );
+      const signatures = await Promise.all(sendPromises);
+      const confirmationPromises = signatures.map(
+        async (sig) => waitForConfirmation(sig, commitment, timeoutMs, pollingIntervalMs)
+      );
+      await Promise.all(confirmationPromises);
+      return signatures;
+    }, "forwardInParallel"),
+    fireAndForget: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(async (transaction) => {
+      return sendTransactionOnly(transaction, "confirmed");
+    }, "fireAndForget")
+  };
+}
+chunkPK6SKIKE_cjs.__name(getPollingTransactionForwarder, "getPollingTransactionForwarder");
+
+// src/solana/alt-utils.ts
+function buildAltAddressesRecord(altEntry) {
+  return { [altEntry.altAddress]: [...altEntry.addresses] };
+}
+chunkPK6SKIKE_cjs.__name(buildAltAddressesRecord, "buildAltAddressesRecord");
+function lookupAltEntry(addressLookupTables, clusterOffset, instructionName) {
+  return addressLookupTables[clusterOffset]?.[instructionName];
+}
+chunkPK6SKIKE_cjs.__name(lookupAltEntry, "lookupAltEntry");
+
+exports.buildAltAddressesRecord = buildAltAddressesRecord;
+exports.createInMemorySigner = createInMemorySigner;
+exports.createSignerFromKeyPair = createSignerFromKeyPair;
+exports.createSignerFromPrivateKeyBytes = createSignerFromPrivateKeyBytes;
+exports.createSignerFromWalletAccount = createSignerFromWalletAccount;
+exports.getPollingTransactionForwarder = getPollingTransactionForwarder;
+exports.getRpcAccountInfoProvider = getRpcAccountInfoProvider;
+exports.getRpcBlockhashProvider = getRpcBlockhashProvider;
+exports.getRpcEpochInfoProvider = getRpcEpochInfoProvider;
+exports.getWebsocketTransactionForwarder = getWebsocketTransactionForwarder;
+exports.lookupAltEntry = lookupAltEntry;
+//# sourceMappingURL=chunk-AXD7LXYY.cjs.map
+//# sourceMappingURL=chunk-AXD7LXYY.cjs.map