@bcts/rand 1.0.0-alpha.9 → 1.0.0-beta.0

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["TEST_SEED: [bigint, bigint, bigint, bigint]"],"sources":["../src/widening.ts","../src/magnitude.ts","../src/random-number-generator.ts","../src/secure-random.ts","../src/seeded-random.ts"],"sourcesContent":["// The below is so we don't have to use #![feature(bigint_helper_methods)]\n// Ported from bc-rand-rust/src/widening.rs\n\n/**\n * Wide multiplication result type - returns (low, high) parts.\n * For a multiplication of two N-bit values, the result is 2N bits\n * split into two N-bit parts.\n */\nexport type WideMulResult = [bigint, bigint];\n\n/**\n * Performs wide multiplication for unsigned integers.\n * Returns (low, high) parts of the full-width result.\n *\n * This is equivalent to Rust's widening_mul for unsigned types.\n */\nexport function wideMul(a: bigint, b: bigint, bits: number): WideMulResult {\n  const mask = (1n << BigInt(bits)) - 1n;\n  const wide = (a & mask) * (b & mask);\n  const low = wide & mask;\n  const high = wide >> BigInt(bits);\n  return [low, high];\n}\n\n/**\n * Wide multiplication for 8-bit unsigned integers.\n * @param a - First 8-bit value\n * @param b - Second 8-bit value\n * @returns Tuple of (low 8 bits, high 8 bits)\n */\nexport function wideMulU8(a: number, b: number): [number, number] {\n  const wide = (a & 0xff) * (b & 0xff);\n  return [wide & 0xff, (wide >> 8) & 0xff];\n}\n\n/**\n * Wide multiplication for 16-bit unsigned integers.\n * @param a - First 16-bit value\n * @param b - Second 16-bit value\n * @returns Tuple of (low 16 bits, high 16 bits)\n */\nexport function wideMulU16(a: number, b: number): [number, number] {\n  const wide = (a & 0xffff) * (b & 0xffff);\n  return [wide & 0xffff, (wide >>> 16) & 0xffff];\n}\n\n/**\n * Wide multiplication for 32-bit unsigned integers.\n * @param a - First 32-bit value\n * @param b - Second 32-bit value\n * @returns Tuple of (low 32 bits, high 32 bits) as bigints\n */\nexport function wideMulU32(a: number, b: number): [bigint, bigint] {\n  const aBig = BigInt(a >>> 0);\n  const bBig = BigInt(b >>> 0);\n  const wide = aBig * bBig;\n  return [wide & 0xffffffffn, wide >> 32n];\n}\n\n/**\n * Wide multiplication for 64-bit unsigned integers.\n * @param a - First 64-bit value as bigint\n * @param b - Second 64-bit value as bigint\n * @returns Tuple of (low 64 bits, high 64 bits) as bigints\n */\nexport function wideMulU64(a: bigint, b: bigint): [bigint, bigint] {\n  const mask64 = 0xffffffffffffffffn;\n  const wide = (a & mask64) * (b & mask64);\n  return [wide & mask64, wide >> 64n];\n}\n","// Ported from bc-rand-rust/src/magnitude.rs\n\n/**\n * Converts a signed integer to its unsigned magnitude.\n * For positive numbers, returns the number unchanged.\n * For negative numbers, returns the absolute value (wrapping for MIN values).\n *\n * This matches Rust's wrapping_abs() behavior.\n */\nexport function toMagnitude(value: number, bits: 8 | 16 | 32): number {\n  switch (bits) {\n    case 8: {\n      // i8 to u8: wrapping_abs\n      const i8Value = (value << 24) >> 24; // Sign extend to i8\n      return Math.abs(i8Value) & 0xff;\n    }\n    case 16: {\n      // i16 to u16: wrapping_abs\n      const i16Value = (value << 16) >> 16; // Sign extend to i16\n      return Math.abs(i16Value) & 0xffff;\n    }\n    case 32: {\n      // i32 to u32: wrapping_abs\n      const i32Value = value | 0; // Force to i32\n      // Handle MIN_VALUE specially (wrapping behavior)\n      if (i32Value === -2147483648) {\n        return 2147483648; // Returns as positive\n      }\n      return Math.abs(i32Value) >>> 0; // Convert to unsigned\n    }\n  }\n}\n\n/**\n * Converts a signed bigint to its unsigned magnitude for 64-bit values.\n */\nexport function toMagnitude64(value: bigint): bigint {\n  const mask = 0xffffffffffffffffn;\n  // Handle negative values\n  if (value < 0n) {\n    // Wrapping absolute value\n    const absValue = -value;\n    return absValue & mask;\n  }\n  return value & mask;\n}\n\n/**\n * Converts an unsigned magnitude back to a signed value.\n * Simply reinterprets the bits.\n */\nexport function fromMagnitude(magnitude: number, bits: 8 | 16 | 32): number {\n  switch (bits) {\n    case 8:\n      return (magnitude << 24) >> 24; // Sign extend from u8 to i8\n    case 16:\n      return (magnitude << 16) >> 16; // Sign extend from u16 to i16\n    case 32:\n      return magnitude | 0; // Reinterpret as i32\n  }\n}\n\n/**\n * Converts an unsigned 64-bit magnitude back to a signed bigint.\n */\nexport function fromMagnitude64(magnitude: bigint): bigint {\n  const mask = 0xffffffffffffffffn;\n  const signBit = 1n << 63n;\n  const maskedMag = magnitude & mask;\n  if ((maskedMag & signBit) !== 0n) {\n    // Negative value - convert from two's complement\n    return maskedMag - (1n << 64n);\n  }\n  return maskedMag;\n}\n","// Ported from bc-rand-rust/src/random_number_generator.rs\n\nimport { wideMulU32, wideMulU64 } from \"./widening.js\";\nimport {\n  toMagnitude,\n  toMagnitude64 as _toMagnitude64,\n  fromMagnitude as _fromMagnitude,\n  fromMagnitude64 as _fromMagnitude64,\n} from \"./magnitude.js\";\n\n/**\n * Interface for random number generators.\n * This is the TypeScript equivalent of Rust's RandomNumberGenerator trait\n * which extends RngCore + CryptoRng.\n *\n * This is compatible with the RandomNumberGenerator Swift protocol used\n * in MacOS and iOS, which is important for cross-platform testing.\n */\nexport interface RandomNumberGenerator {\n  /**\n   * Returns the next random 32-bit unsigned integer.\n   */\n  nextU32(): number;\n\n  /**\n   * Returns the next random 64-bit unsigned integer as a bigint.\n   */\n  nextU64(): bigint;\n\n  /**\n   * Fills the given Uint8Array with random bytes.\n   */\n  fillBytes(dest: Uint8Array): void;\n\n  /**\n   * Returns a Uint8Array of random bytes of the given size.\n   */\n  randomData(size: number): Uint8Array;\n\n  /**\n   * Fills the given Uint8Array with random bytes.\n   * Alias for fillBytes for compatibility.\n   */\n  fillRandomData(data: Uint8Array): void;\n}\n\n/**\n * Returns a Uint8Array of random bytes of the given size.\n */\nexport function rngRandomData(rng: RandomNumberGenerator, size: number): Uint8Array {\n  const data = new Uint8Array(size);\n  rng.fillRandomData(data);\n  return data;\n}\n\n/**\n * Fills the given Uint8Array with random bytes.\n */\nexport function rngFillRandomData(rng: RandomNumberGenerator, data: Uint8Array): void {\n  rng.fillRandomData(data);\n}\n\n/**\n * Returns a random value that is less than the given upper bound.\n *\n * Uses Lemire's \"nearly divisionless\" method for generating random\n * integers in an interval. For a detailed explanation, see:\n * https://arxiv.org/abs/1805.10941\n *\n * @param rng - The random number generator to use\n * @param upperBound - The upper bound for the randomly generated value. Must be non-zero.\n * @returns A random value in the range [0, upperBound). Every value in the range is equally likely.\n */\nexport function rngNextWithUpperBound(rng: RandomNumberGenerator, upperBound: bigint): bigint {\n  if (upperBound === 0n) {\n    throw new Error(\"upperBound must be non-zero\");\n  }\n\n  // We use Lemire's \"nearly divisionless\" method for generating random\n  // integers in an interval. For a detailed explanation, see:\n  // https://arxiv.org/abs/1805.10941\n\n  const bitmask = 0xffffffffffffffffn; // u64 max\n  let random = rng.nextU64() & bitmask;\n  let m = wideMulU64(random, upperBound);\n\n  if (m[0] < upperBound) {\n    // t = (0 - upperBound) % upperBound\n    const negUpperBound = (bitmask + 1n - upperBound) & bitmask;\n    const t = negUpperBound % upperBound;\n    while (m[0] < t) {\n      random = rng.nextU64() & bitmask;\n      m = wideMulU64(random, upperBound);\n    }\n  }\n\n  return m[1];\n}\n\n/**\n * Returns a random 32-bit value that is less than the given upper bound.\n * This matches Rust's behavior when called with u32 type.\n *\n * Uses Lemire's \"nearly divisionless\" method with 32-bit arithmetic.\n *\n * @param rng - The random number generator to use\n * @param upperBound - The upper bound for the randomly generated value. Must be non-zero and fit in u32.\n * @returns A random u32 value in the range [0, upperBound).\n */\nexport function rngNextWithUpperBoundU32(rng: RandomNumberGenerator, upperBound: number): number {\n  if (upperBound === 0) {\n    throw new Error(\"upperBound must be non-zero\");\n  }\n\n  const upperBoundU32 = upperBound >>> 0;\n  const bitmask = 0xffffffff;\n\n  // Get random and mask to 32 bits (matches Rust behavior)\n  let random = Number(rng.nextU64() & BigInt(bitmask));\n  let m = wideMulU32(random, upperBoundU32);\n\n  if (Number(m[0]) < upperBoundU32) {\n    // t = (0 - upperBound) % upperBound (wrapping subtraction)\n    const t = ((bitmask + 1 - upperBoundU32) >>> 0) % upperBoundU32;\n    while (Number(m[0]) < t) {\n      random = Number(rng.nextU64() & BigInt(bitmask));\n      m = wideMulU32(random, upperBoundU32);\n    }\n  }\n\n  return Number(m[1]);\n}\n\n/**\n * Returns a random value within the specified range [start, end) using 32-bit arithmetic.\n * This matches Rust's behavior when called with i32 types.\n *\n * @param rng - The random number generator to use\n * @param start - The lower bound (inclusive) as i32\n * @param end - The upper bound (exclusive) as i32\n * @returns A random i32 value within the bounds\n */\nexport function rngNextInRangeI32(rng: RandomNumberGenerator, start: number, end: number): number {\n  if (start >= end) {\n    throw new Error(\"start must be less than end\");\n  }\n\n  const startI32 = start | 0;\n  const endI32 = end | 0;\n  const delta = toMagnitude(endI32 - startI32, 32);\n\n  if (delta === 0xffffffff) {\n    return rng.nextU32() | 0;\n  }\n\n  const random = rngNextWithUpperBoundU32(rng, delta);\n  return (startI32 + random) | 0;\n}\n\n/**\n * Returns a random value within the specified range [start, end).\n *\n * @param rng - The random number generator to use\n * @param start - The lower bound (inclusive)\n * @param end - The upper bound (exclusive)\n * @returns A random value within the bounds of the range\n */\nexport function rngNextInRange(rng: RandomNumberGenerator, start: bigint, end: bigint): bigint {\n  if (start >= end) {\n    throw new Error(\"start must be less than end\");\n  }\n\n  const delta = end - start;\n\n  // If delta covers the entire range, just return a random value\n  const maxU64 = 0xffffffffffffffffn;\n  if (delta === maxU64) {\n    return rng.nextU64();\n  }\n\n  const random = rngNextWithUpperBound(rng, delta);\n  return start + random;\n}\n\n/**\n * Returns a random value within the specified closed range [start, end].\n *\n * @param rng - The random number generator to use\n * @param start - The lower bound (inclusive)\n * @param end - The upper bound (inclusive)\n * @returns A random value within the bounds of the range\n */\nexport function rngNextInClosedRange(\n  rng: RandomNumberGenerator,\n  start: bigint,\n  end: bigint,\n): bigint {\n  if (start > end) {\n    throw new Error(\"start must be less than or equal to end\");\n  }\n\n  const delta = end - start;\n\n  // If delta covers the entire range, just return a random value\n  const maxU64 = 0xffffffffffffffffn;\n  if (delta === maxU64) {\n    return rng.nextU64();\n  }\n\n  const random = rngNextWithUpperBound(rng, delta + 1n);\n  return start + random;\n}\n\n/**\n * Returns a random value within the specified closed range [start, end] for i32 values.\n * Convenience function that handles signed 32-bit integers.\n *\n * @param rng - The random number generator to use\n * @param start - The lower bound (inclusive) as i32\n * @param end - The upper bound (inclusive) as i32\n * @returns A random i32 value within the bounds of the range\n */\nexport function rngNextInClosedRangeI32(\n  rng: RandomNumberGenerator,\n  start: number,\n  end: number,\n): number {\n  if (start > end) {\n    throw new Error(\"start must be less than or equal to end\");\n  }\n\n  // Convert to i32\n  const startI32 = start | 0;\n  const endI32 = end | 0;\n\n  // Calculate delta as u32 magnitude\n  const delta = toMagnitude(endI32 - startI32, 32);\n\n  // If delta covers the entire u32 range, just return a random value\n  if (delta === 0xffffffff) {\n    return rng.nextU32() | 0;\n  }\n\n  const random = rngNextWithUpperBoundU32(rng, delta + 1);\n  return (startI32 + random) | 0;\n}\n\n/**\n * Returns a fixed-size array of random bytes.\n *\n * @param rng - The random number generator to use\n * @param size - The size of the array to return\n * @returns A Uint8Array of the specified size filled with random bytes\n */\nexport function rngRandomArray(rng: RandomNumberGenerator, size: number): Uint8Array {\n  const data = new Uint8Array(size);\n  rng.fillRandomData(data);\n  return data;\n}\n\n/**\n * Returns a random boolean value.\n *\n * @param rng - The random number generator to use\n * @returns A random boolean\n */\nexport function rngRandomBool(rng: RandomNumberGenerator): boolean {\n  return (rng.nextU32() & 1) === 0;\n}\n\n/**\n * Returns a random 32-bit unsigned integer.\n *\n * @param rng - The random number generator to use\n * @returns A random u32 value\n */\nexport function rngRandomU32(rng: RandomNumberGenerator): number {\n  return rng.nextU32();\n}\n","// Ported from bc-rand-rust/src/secure_random.rs\n\nimport type { RandomNumberGenerator } from \"./random-number-generator.js\";\n\n/**\n * Detects the crypto API available in the current environment.\n * Works in both Node.js and browser environments.\n */\nfunction getCrypto(): Crypto {\n  // Browser environment\n  if (\n    typeof globalThis !== \"undefined\" &&\n    globalThis.crypto !== null &&\n    globalThis.crypto !== undefined\n  ) {\n    return globalThis.crypto;\n  }\n  // Node.js environment - globalThis.crypto is also available in Node.js >= 15\n  if (typeof globalThis.crypto !== \"undefined\") {\n    return globalThis.crypto;\n  }\n  throw new Error(\"No crypto API available in this environment\");\n}\n\n/**\n * Generate a Uint8Array of cryptographically strong random bytes of the given size.\n */\nexport function randomData(size: number): Uint8Array {\n  const data = new Uint8Array(size);\n  fillRandomData(data);\n  return data;\n}\n\n/**\n * Fill the given Uint8Array with cryptographically strong random bytes.\n */\nexport function fillRandomData(data: Uint8Array): void {\n  const crypto = getCrypto();\n  crypto.getRandomValues(data);\n}\n\n/**\n * Returns the next cryptographically strong random 64-bit unsigned integer.\n */\nexport function nextU64(): bigint {\n  const data = new Uint8Array(8);\n  fillRandomData(data);\n  const view = new DataView(data.buffer);\n  return view.getBigUint64(0, true); // little-endian\n}\n\n/**\n * A random number generator that can be used as a source of\n * cryptographically-strong randomness.\n *\n * Uses the Web Crypto API (crypto.getRandomValues) which is available\n * in both browsers and Node.js >= 15.\n */\nexport class SecureRandomNumberGenerator implements RandomNumberGenerator {\n  /**\n   * Returns the next random 32-bit unsigned integer.\n   */\n  nextU32(): number {\n    const data = new Uint8Array(4);\n    fillRandomData(data);\n    const view = new DataView(data.buffer);\n    return view.getUint32(0, true) >>> 0; // little-endian, unsigned\n  }\n\n  /**\n   * Returns the next random 64-bit unsigned integer as a bigint.\n   */\n  nextU64(): bigint {\n    return nextU64();\n  }\n\n  /**\n   * Fills the given Uint8Array with random bytes.\n   */\n  fillBytes(dest: Uint8Array): void {\n    fillRandomData(dest);\n  }\n\n  /**\n   * Returns a Uint8Array of random bytes of the given size.\n   */\n  randomData(size: number): Uint8Array {\n    return randomData(size);\n  }\n\n  /**\n   * Fills the given Uint8Array with random bytes.\n   */\n  fillRandomData(data: Uint8Array): void {\n    fillRandomData(data);\n  }\n}\n","// Ported from bc-rand-rust/src/seeded_random.rs\n\nimport type { RandomNumberGenerator } from \"./random-number-generator.js\";\n\n/**\n * Xoshiro256** state\n * Based on xoshiro256** 1.0 by David Blackman and Sebastiano Vigna\n * https://prng.di.unimi.it/\n */\ninterface Xoshiro256State {\n  s0: bigint;\n  s1: bigint;\n  s2: bigint;\n  s3: bigint;\n}\n\n/**\n * Rotate left for 64-bit bigint\n */\nfunction rotl(x: bigint, k: number): bigint {\n  const mask = 0xffffffffffffffffn;\n  return ((x << BigInt(k)) | (x >> BigInt(64 - k))) & mask;\n}\n\n/**\n * Xoshiro256** PRNG implementation\n * This is the same algorithm used by rand_xoshiro in Rust\n */\nfunction xoshiro256StarStar(state: Xoshiro256State): bigint {\n  const mask = 0xffffffffffffffffn;\n\n  // result = rotl(s1 * 5, 7) * 9\n  const result = (rotl((state.s1 * 5n) & mask, 7) * 9n) & mask;\n\n  // t = s1 << 17\n  const t = (state.s1 << 17n) & mask;\n\n  // Update state\n  state.s2 ^= state.s0;\n  state.s3 ^= state.s1;\n  state.s1 ^= state.s2;\n  state.s0 ^= state.s3;\n\n  state.s2 ^= t;\n  state.s3 = rotl(state.s3, 45);\n\n  return result;\n}\n\n/**\n * A random number generator that can be used as a source of deterministic\n * pseudo-randomness for testing purposes.\n *\n * Uses the Xoshiro256** algorithm, which is the same algorithm used by\n * rand_xoshiro in Rust. This ensures cross-platform compatibility with\n * the Rust implementation.\n *\n * WARNING: This is NOT cryptographically secure and should only be used\n * for testing purposes.\n */\nexport class SeededRandomNumberGenerator implements RandomNumberGenerator {\n  private readonly state: Xoshiro256State;\n\n  /**\n   * Creates a new seeded random number generator.\n   *\n   * The seed should be a 256-bit value, represented as an array of 4 64-bit\n   * integers (as bigints). For the output distribution to look random, the seed\n   * should not have any obvious patterns, like all zeroes or all ones.\n   *\n   * This is not cryptographically secure, and should only be used for\n   * testing purposes.\n   *\n   * @param seed - Array of 4 64-bit unsigned integers as bigints\n   */\n  constructor(seed: [bigint, bigint, bigint, bigint]) {\n    this.state = {\n      s0: seed[0] & 0xffffffffffffffffn,\n      s1: seed[1] & 0xffffffffffffffffn,\n      s2: seed[2] & 0xffffffffffffffffn,\n      s3: seed[3] & 0xffffffffffffffffn,\n    };\n  }\n\n  /**\n   * Creates a new seeded random number generator from a seed array.\n   * Convenience method that accepts numbers and converts to bigints.\n   *\n   * @param seed - Array of 4 64-bit unsigned integers\n   */\n  static fromSeed(seed: [bigint, bigint, bigint, bigint]): SeededRandomNumberGenerator {\n    return new SeededRandomNumberGenerator(seed);\n  }\n\n  /**\n   * Returns the next random 64-bit unsigned integer as a bigint.\n   */\n  nextU64(): bigint {\n    return xoshiro256StarStar(this.state);\n  }\n\n  /**\n   * Returns the next random 32-bit unsigned integer.\n   */\n  nextU32(): number {\n    return Number(this.nextU64() & 0xffffffffn) >>> 0;\n  }\n\n  /**\n   * Fills the given Uint8Array with random bytes.\n   *\n   * Note: This implementation matches the Rust behavior exactly -\n   * it uses one nextU64() call per byte (taking only the low byte),\n   * which matches the Swift version's behavior.\n   */\n  fillBytes(dest: Uint8Array): void {\n    for (let i = 0; i < dest.length; i++) {\n      dest[i] = Number(this.nextU64() & 0xffn);\n    }\n  }\n\n  /**\n   * Returns a Uint8Array of random bytes of the given size.\n   *\n   * This might not be the most efficient implementation,\n   * but it works the same as the Swift version.\n   */\n  randomData(size: number): Uint8Array {\n    const data = new Uint8Array(size);\n    for (let i = 0; i < size; i++) {\n      data[i] = Number(this.nextU64() & 0xffn);\n    }\n    return data;\n  }\n\n  /**\n   * Fills the given Uint8Array with random bytes.\n   */\n  fillRandomData(data: Uint8Array): void {\n    this.fillBytes(data);\n  }\n}\n\n/**\n * The standard test seed used across all Blockchain Commons implementations.\n */\nexport const TEST_SEED: [bigint, bigint, bigint, bigint] = [\n  17295166580085024720n,\n  422929670265678780n,\n  5577237070365765850n,\n  7953171132032326923n,\n];\n\n/**\n * Creates a seeded random number generator with a fixed seed.\n * This is useful for reproducible testing across different platforms.\n */\nexport function makeFakeRandomNumberGenerator(): SeededRandomNumberGenerator {\n  return new SeededRandomNumberGenerator(TEST_SEED);\n}\n\n/**\n * Creates a Uint8Array of random data with a fixed seed.\n * This is useful for reproducible testing.\n *\n * @param size - The number of bytes to generate\n * @returns A Uint8Array of pseudo-random bytes\n */\nexport function fakeRandomData(size: number): Uint8Array {\n  return makeFakeRandomNumberGenerator().randomData(size);\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/widening.ts","../src/magnitude.ts","../src/random-number-generator.ts","../src/secure-random.ts","../src/seeded-random.ts"],"sourcesContent":["/**\n * Copyright © 2023-2026 Blockchain Commons, LLC\n * Copyright © 2025-2026 Parity Technologies\n *\n */\n\n// The below is so we don't have to use #![feature(bigint_helper_methods)]\n// Ported from bc-rand-rust/src/widening.rs\n\n/**\n * Wide multiplication result type - returns (low, high) parts.\n * For a multiplication of two N-bit values, the result is 2N bits\n * split into two N-bit parts.\n */\nexport type WideMulResult = [bigint, bigint];\n\n/**\n * Performs wide multiplication for unsigned integers.\n * Returns (low, high) parts of the full-width result.\n *\n * This is equivalent to Rust's widening_mul for unsigned types.\n */\nexport function wideMul(a: bigint, b: bigint, bits: number): WideMulResult {\n  const mask = (1n << BigInt(bits)) - 1n;\n  const wide = (a & mask) * (b & mask);\n  const low = wide & mask;\n  const high = wide >> BigInt(bits);\n  return [low, high];\n}\n\n/**\n * Wide multiplication for 8-bit unsigned integers.\n * @param a - First 8-bit value\n * @param b - Second 8-bit value\n * @returns Tuple of (low 8 bits, high 8 bits)\n */\nexport function wideMulU8(a: number, b: number): [number, number] {\n  const wide = (a & 0xff) * (b & 0xff);\n  return [wide & 0xff, (wide >> 8) & 0xff];\n}\n\n/**\n * Wide multiplication for 16-bit unsigned integers.\n * @param a - First 16-bit value\n * @param b - Second 16-bit value\n * @returns Tuple of (low 16 bits, high 16 bits)\n */\nexport function wideMulU16(a: number, b: number): [number, number] {\n  const wide = (a & 0xffff) * (b & 0xffff);\n  return [wide & 0xffff, (wide >>> 16) & 0xffff];\n}\n\n/**\n * Wide multiplication for 32-bit unsigned integers.\n * @param a - First 32-bit value\n * @param b - Second 32-bit value\n * @returns Tuple of (low 32 bits, high 32 bits) as bigints\n */\nexport function wideMulU32(a: number, b: number): [bigint, bigint] {\n  const aBig = BigInt(a >>> 0);\n  const bBig = BigInt(b >>> 0);\n  const wide = aBig * bBig;\n  return [wide & 0xffffffffn, wide >> 32n];\n}\n\n/**\n * Wide multiplication for 64-bit unsigned integers.\n * @param a - First 64-bit value as bigint\n * @param b - Second 64-bit value as bigint\n * @returns Tuple of (low 64 bits, high 64 bits) as bigints\n */\nexport function wideMulU64(a: bigint, b: bigint): [bigint, bigint] {\n  const mask64 = 0xffffffffffffffffn;\n  const wide = (a & mask64) * (b & mask64);\n  return [wide & mask64, wide >> 64n];\n}\n","/**\n * Copyright © 2023-2026 Blockchain Commons, LLC\n * Copyright © 2025-2026 Parity Technologies\n *\n */\n\n// Ported from bc-rand-rust/src/magnitude.rs\n\n/**\n * Converts a signed integer to its unsigned magnitude.\n * For positive numbers, returns the number unchanged.\n * For negative numbers, returns the absolute value (wrapping for MIN values).\n *\n * This matches Rust's wrapping_abs() behavior.\n */\nexport function toMagnitude(value: number, bits: 8 | 16 | 32): number {\n  switch (bits) {\n    case 8: {\n      // i8 to u8: wrapping_abs\n      const i8Value = (value << 24) >> 24; // Sign extend to i8\n      return Math.abs(i8Value) & 0xff;\n    }\n    case 16: {\n      // i16 to u16: wrapping_abs\n      const i16Value = (value << 16) >> 16; // Sign extend to i16\n      return Math.abs(i16Value) & 0xffff;\n    }\n    case 32: {\n      // i32 to u32: wrapping_abs\n      const i32Value = value | 0; // Force to i32\n      // Handle MIN_VALUE specially (wrapping behavior)\n      if (i32Value === -2147483648) {\n        return 2147483648; // Returns as positive\n      }\n      return Math.abs(i32Value) >>> 0; // Convert to unsigned\n    }\n  }\n}\n\n/**\n * Converts a signed bigint to its unsigned magnitude for 64-bit values.\n */\nexport function toMagnitude64(value: bigint): bigint {\n  const mask = 0xffffffffffffffffn;\n  // Handle negative values\n  if (value < 0n) {\n    // Wrapping absolute value\n    const absValue = -value;\n    return absValue & mask;\n  }\n  return value & mask;\n}\n\n/**\n * Converts an unsigned magnitude back to a signed value.\n * Simply reinterprets the bits.\n */\nexport function fromMagnitude(magnitude: number, bits: 8 | 16 | 32): number {\n  switch (bits) {\n    case 8:\n      return (magnitude << 24) >> 24; // Sign extend from u8 to i8\n    case 16:\n      return (magnitude << 16) >> 16; // Sign extend from u16 to i16\n    case 32:\n      return magnitude | 0; // Reinterpret as i32\n  }\n}\n\n/**\n * Converts an unsigned 64-bit magnitude back to a signed bigint.\n */\nexport function fromMagnitude64(magnitude: bigint): bigint {\n  const mask = 0xffffffffffffffffn;\n  const signBit = 1n << 63n;\n  const maskedMag = magnitude & mask;\n  if ((maskedMag & signBit) !== 0n) {\n    // Negative value - convert from two's complement\n    return maskedMag - (1n << 64n);\n  }\n  return maskedMag;\n}\n","/**\n * Copyright © 2023-2026 Blockchain Commons, LLC\n * Copyright © 2025-2026 Parity Technologies\n *\n */\n\n// Ported from bc-rand-rust/src/random_number_generator.rs\n\nimport { wideMulU8, wideMulU16, wideMulU32, wideMulU64 } from \"./widening.js\";\nimport { toMagnitude, toMagnitude64, fromMagnitude64 } from \"./magnitude.js\";\n\n/**\n * Interface for random number generators.\n *\n * The TypeScript equivalent of Rust's `RandomNumberGenerator` trait\n * (which extends `RngCore + CryptoRng`).\n */\nexport interface RandomNumberGenerator {\n  /** Returns the next random 32-bit unsigned integer. */\n  nextU32(): number;\n\n  /** Returns the next random 64-bit unsigned integer as a bigint. */\n  nextU64(): bigint;\n\n  /** Fills the given Uint8Array with random bytes. */\n  fillBytes(dest: Uint8Array): void;\n\n  /** Returns a Uint8Array of random bytes of the given size. */\n  randomData(size: number): Uint8Array;\n\n  /** Fills the given Uint8Array with random bytes. Alias for fillBytes. */\n  fillRandomData(data: Uint8Array): void;\n}\n\n/**\n * Returns a Uint8Array of random bytes of the given size.\n */\nexport function rngRandomData(rng: RandomNumberGenerator, size: number): Uint8Array {\n  const data = new Uint8Array(size);\n  rng.fillRandomData(data);\n  return data;\n}\n\n/**\n * Fills the given Uint8Array with random bytes.\n */\nexport function rngFillRandomData(rng: RandomNumberGenerator, data: Uint8Array): void {\n  rng.fillRandomData(data);\n}\n\n// =====================================================================\n// Lemire's \"nearly divisionless\" upper-bound sampler\n// (https://arxiv.org/abs/1805.10941)\n//\n// Rust exposes a single generic `rng_next_with_upper_bound<T>`. JavaScript\n// has no integer-width generics, so we provide one specialization per\n// width — `U8`, `U16`, `U32`, `U64` — exactly mirroring the Rust dispatch.\n// =====================================================================\n\n/**\n * Returns a random `u8` value strictly less than `upperBound`.\n */\nexport function rngNextWithUpperBoundU8(rng: RandomNumberGenerator, upperBound: number): number {\n  if (upperBound === 0) throw new Error(\"upperBound must be non-zero\");\n  const ub = upperBound & 0xff;\n  let random = Number(rng.nextU64() & 0xffn);\n  let m = wideMulU8(random, ub);\n  if (m[0] < ub) {\n    const t = ((0x100 - ub) & 0xff) % ub;\n    while (m[0] < t) {\n      random = Number(rng.nextU64() & 0xffn);\n      m = wideMulU8(random, ub);\n    }\n  }\n  return m[1];\n}\n\n/**\n * Returns a random `u16` value strictly less than `upperBound`.\n */\nexport function rngNextWithUpperBoundU16(rng: RandomNumberGenerator, upperBound: number): number {\n  if (upperBound === 0) throw new Error(\"upperBound must be non-zero\");\n  const ub = upperBound & 0xffff;\n  let random = Number(rng.nextU64() & 0xffffn);\n  let m = wideMulU16(random, ub);\n  if (m[0] < ub) {\n    const t = ((0x10000 - ub) & 0xffff) % ub;\n    while (m[0] < t) {\n      random = Number(rng.nextU64() & 0xffffn);\n      m = wideMulU16(random, ub);\n    }\n  }\n  return m[1];\n}\n\n/**\n * Returns a random `u32` value strictly less than `upperBound`.\n */\nexport function rngNextWithUpperBoundU32(rng: RandomNumberGenerator, upperBound: number): number {\n  if (upperBound === 0) throw new Error(\"upperBound must be non-zero\");\n  const ub = upperBound >>> 0;\n  let random = Number(rng.nextU64() & 0xffffffffn);\n  let m = wideMulU32(random, ub);\n  if (Number(m[0]) < ub) {\n    const t = ((0x100000000 - ub) >>> 0) % ub;\n    while (Number(m[0]) < t) {\n      random = Number(rng.nextU64() & 0xffffffffn);\n      m = wideMulU32(random, ub);\n    }\n  }\n  return Number(m[1]);\n}\n\n/**\n * Returns a random `u64` value strictly less than `upperBound`.\n */\nexport function rngNextWithUpperBoundU64(rng: RandomNumberGenerator, upperBound: bigint): bigint {\n  if (upperBound === 0n) throw new Error(\"upperBound must be non-zero\");\n  const mask64 = 0xffffffffffffffffn;\n  const ub = upperBound & mask64;\n  let random = rng.nextU64() & mask64;\n  let m = wideMulU64(random, ub);\n  if (m[0] < ub) {\n    // wrapping_sub(0, ub) within u64\n    const t = ((mask64 + 1n - ub) & mask64) % ub;\n    while (m[0] < t) {\n      random = rng.nextU64() & mask64;\n      m = wideMulU64(random, ub);\n    }\n  }\n  return m[1];\n}\n\n/**\n * Alias of `rngNextWithUpperBoundU64`. Kept for API backwards compatibility.\n *\n * @deprecated Prefer the explicit-width name `rngNextWithUpperBoundU64`.\n */\nexport const rngNextWithUpperBound = rngNextWithUpperBoundU64;\n\n// =====================================================================\n// Range / closed-range samplers\n//\n// Mirrors Rust `rng_next_in_range<T>` and `rng_next_in_closed_range<T>`.\n// `from_u64(...).unwrap()` in the early-return branch panics in Rust when\n// the random `u64` does not fit in `T`. We mirror that with a thrown\n// `Error` so cross-platform behavior matches exactly.\n// =====================================================================\n\nfunction fromU64ThrowsIfAbove(value: bigint, max: bigint): bigint {\n  if (value > max) {\n    throw new Error(\"from_u64 conversion overflow\");\n  }\n  return value;\n}\n\n/** Random `u8` in the half-open range [start, end). */\nexport function rngNextInRangeU8(rng: RandomNumberGenerator, start: number, end: number): number {\n  if (start >= end) throw new Error(\"start must be less than end\");\n  const lo = start & 0xff;\n  const hi = end & 0xff;\n  const delta = (hi - lo) & 0xff;\n  if (delta === 0xff) {\n    return Number(fromU64ThrowsIfAbove(rng.nextU64(), 0xffn));\n  }\n  return (lo + rngNextWithUpperBoundU8(rng, delta)) & 0xff;\n}\n\n/** Random `u16` in the half-open range [start, end). */\nexport function rngNextInRangeU16(rng: RandomNumberGenerator, start: number, end: number): number {\n  if (start >= end) throw new Error(\"start must be less than end\");\n  const lo = start & 0xffff;\n  const hi = end & 0xffff;\n  const delta = (hi - lo) & 0xffff;\n  if (delta === 0xffff) {\n    return Number(fromU64ThrowsIfAbove(rng.nextU64(), 0xffffn));\n  }\n  return (lo + rngNextWithUpperBoundU16(rng, delta)) & 0xffff;\n}\n\n/** Random `u32` in the half-open range [start, end). */\nexport function rngNextInRangeU32(rng: RandomNumberGenerator, start: number, end: number): number {\n  if (start >= end) throw new Error(\"start must be less than end\");\n  const lo = start >>> 0;\n  const hi = end >>> 0;\n  const delta = (hi - lo) >>> 0;\n  if (delta === 0xffffffff) {\n    return Number(fromU64ThrowsIfAbove(rng.nextU64(), 0xffffffffn));\n  }\n  return (lo + rngNextWithUpperBoundU32(rng, delta)) >>> 0;\n}\n\n/** Random `u64` in the half-open range [start, end). */\nexport function rngNextInRangeU64(rng: RandomNumberGenerator, start: bigint, end: bigint): bigint {\n  if (start >= end) throw new Error(\"start must be less than end\");\n  const mask64 = 0xffffffffffffffffn;\n  const delta = (end - start) & mask64;\n  if (delta === mask64) {\n    // Every u64 fits in u64 — `from_u64::<u64>` is total — no throw.\n    return rng.nextU64();\n  }\n  return (start + rngNextWithUpperBoundU64(rng, delta)) & mask64;\n}\n\n/**\n * Alias of `rngNextInRangeU64`. Kept for API backwards compatibility.\n *\n * @deprecated Prefer the explicit-width name `rngNextInRangeU64`.\n */\nexport const rngNextInRange = rngNextInRangeU64;\n\n/** Random `i8` in the half-open range [start, end). */\nexport function rngNextInRangeI8(rng: RandomNumberGenerator, start: number, end: number): number {\n  if (start >= end) throw new Error(\"start must be less than end\");\n  const lo = (start << 24) >> 24;\n  const hi = (end << 24) >> 24;\n  const delta = toMagnitude(hi - lo, 8);\n  if (delta === 0xff) {\n    // i8::from_u64 succeeds only when value <= i8::MAX = 127\n    return Number(fromU64ThrowsIfAbove(rng.nextU64(), 0x7fn));\n  }\n  const random = rngNextWithUpperBoundU8(rng, delta);\n  return ((lo + random) << 24) >> 24;\n}\n\n/** Random `i16` in the half-open range [start, end). */\nexport function rngNextInRangeI16(rng: RandomNumberGenerator, start: number, end: number): number {\n  if (start >= end) throw new Error(\"start must be less than end\");\n  const lo = (start << 16) >> 16;\n  const hi = (end << 16) >> 16;\n  const delta = toMagnitude(hi - lo, 16);\n  if (delta === 0xffff) {\n    // i16::from_u64 succeeds only when value <= i16::MAX = 32767\n    return Number(fromU64ThrowsIfAbove(rng.nextU64(), 0x7fffn));\n  }\n  const random = rngNextWithUpperBoundU16(rng, delta);\n  return ((lo + random) << 16) >> 16;\n}\n\n/** Random `i32` in the half-open range [start, end). */\nexport function rngNextInRangeI32(rng: RandomNumberGenerator, start: number, end: number): number {\n  if (start >= end) throw new Error(\"start must be less than end\");\n  const lo = start | 0;\n  const hi = end | 0;\n  const delta = toMagnitude(hi - lo, 32);\n  if (delta === 0xffffffff) {\n    // i32::from_u64 succeeds only when value <= i32::MAX = 2147483647\n    return Number(fromU64ThrowsIfAbove(rng.nextU64(), 0x7fffffffn));\n  }\n  const random = rngNextWithUpperBoundU32(rng, delta);\n  return (lo + random) | 0;\n}\n\n/** Random `i64` in the half-open range [start, end). */\nexport function rngNextInRangeI64(rng: RandomNumberGenerator, start: bigint, end: bigint): bigint {\n  if (start >= end) throw new Error(\"start must be less than end\");\n  const delta = toMagnitude64(end - start);\n  const mask64 = 0xffffffffffffffffn;\n  if (delta === mask64) {\n    // i64::from_u64 succeeds only when value <= i64::MAX = (2^63 - 1)\n    return fromU64ThrowsIfAbove(rng.nextU64(), 0x7fffffffffffffffn);\n  }\n  const random = rngNextWithUpperBoundU64(rng, delta);\n  return fromMagnitude64((toMagnitude64(start) + random) & mask64);\n}\n\n/** Random `u8` in the closed range [start, end]. */\nexport function rngNextInClosedRangeU8(\n  rng: RandomNumberGenerator,\n  start: number,\n  end: number,\n): number {\n  if (start > end) throw new Error(\"start must be less than or equal to end\");\n  const lo = start & 0xff;\n  const hi = end & 0xff;\n  const delta = (hi - lo) & 0xff;\n  if (delta === 0xff) {\n    return Number(fromU64ThrowsIfAbove(rng.nextU64(), 0xffn));\n  }\n  return (lo + rngNextWithUpperBoundU8(rng, delta + 1)) & 0xff;\n}\n\n/** Random `u16` in the closed range [start, end]. */\nexport function rngNextInClosedRangeU16(\n  rng: RandomNumberGenerator,\n  start: number,\n  end: number,\n): number {\n  if (start > end) throw new Error(\"start must be less than or equal to end\");\n  const lo = start & 0xffff;\n  const hi = end & 0xffff;\n  const delta = (hi - lo) & 0xffff;\n  if (delta === 0xffff) {\n    return Number(fromU64ThrowsIfAbove(rng.nextU64(), 0xffffn));\n  }\n  return (lo + rngNextWithUpperBoundU16(rng, delta + 1)) & 0xffff;\n}\n\n/** Random `u32` in the closed range [start, end]. */\nexport function rngNextInClosedRangeU32(\n  rng: RandomNumberGenerator,\n  start: number,\n  end: number,\n): number {\n  if (start > end) throw new Error(\"start must be less than or equal to end\");\n  const lo = start >>> 0;\n  const hi = end >>> 0;\n  const delta = (hi - lo) >>> 0;\n  if (delta === 0xffffffff) {\n    return Number(fromU64ThrowsIfAbove(rng.nextU64(), 0xffffffffn));\n  }\n  return (lo + rngNextWithUpperBoundU32(rng, delta + 1)) >>> 0;\n}\n\n/** Random `u64` in the closed range [start, end]. */\nexport function rngNextInClosedRangeU64(\n  rng: RandomNumberGenerator,\n  start: bigint,\n  end: bigint,\n): bigint {\n  if (start > end) throw new Error(\"start must be less than or equal to end\");\n  const mask64 = 0xffffffffffffffffn;\n  const delta = (end - start) & mask64;\n  if (delta === mask64) {\n    return rng.nextU64();\n  }\n  return (start + rngNextWithUpperBoundU64(rng, delta + 1n)) & mask64;\n}\n\n/**\n * Alias of `rngNextInClosedRangeU64`. Kept for API backwards compatibility.\n *\n * @deprecated Prefer the explicit-width name `rngNextInClosedRangeU64`.\n */\nexport const rngNextInClosedRange = rngNextInClosedRangeU64;\n\n/** Random `i8` in the closed range [start, end]. */\nexport function rngNextInClosedRangeI8(\n  rng: RandomNumberGenerator,\n  start: number,\n  end: number,\n): number {\n  if (start > end) throw new Error(\"start must be less than or equal to end\");\n  const lo = (start << 24) >> 24;\n  const hi = (end << 24) >> 24;\n  const delta = toMagnitude(hi - lo, 8);\n  if (delta === 0xff) {\n    return Number(fromU64ThrowsIfAbove(rng.nextU64(), 0x7fn));\n  }\n  const random = rngNextWithUpperBoundU8(rng, delta + 1);\n  return ((lo + random) << 24) >> 24;\n}\n\n/** Random `i16` in the closed range [start, end]. */\nexport function rngNextInClosedRangeI16(\n  rng: RandomNumberGenerator,\n  start: number,\n  end: number,\n): number {\n  if (start > end) throw new Error(\"start must be less than or equal to end\");\n  const lo = (start << 16) >> 16;\n  const hi = (end << 16) >> 16;\n  const delta = toMagnitude(hi - lo, 16);\n  if (delta === 0xffff) {\n    return Number(fromU64ThrowsIfAbove(rng.nextU64(), 0x7fffn));\n  }\n  const random = rngNextWithUpperBoundU16(rng, delta + 1);\n  return ((lo + random) << 16) >> 16;\n}\n\n/** Random `i32` in the closed range [start, end]. */\nexport function rngNextInClosedRangeI32(\n  rng: RandomNumberGenerator,\n  start: number,\n  end: number,\n): number {\n  if (start > end) throw new Error(\"start must be less than or equal to end\");\n  const lo = start | 0;\n  const hi = end | 0;\n  const delta = toMagnitude(hi - lo, 32);\n  if (delta === 0xffffffff) {\n    return Number(fromU64ThrowsIfAbove(rng.nextU64(), 0x7fffffffn));\n  }\n  const random = rngNextWithUpperBoundU32(rng, delta + 1);\n  return (lo + random) | 0;\n}\n\n/** Random `i64` in the closed range [start, end]. */\nexport function rngNextInClosedRangeI64(\n  rng: RandomNumberGenerator,\n  start: bigint,\n  end: bigint,\n): bigint {\n  if (start > end) throw new Error(\"start must be less than or equal to end\");\n  const delta = toMagnitude64(end - start);\n  const mask64 = 0xffffffffffffffffn;\n  if (delta === mask64) {\n    return fromU64ThrowsIfAbove(rng.nextU64(), 0x7fffffffffffffffn);\n  }\n  const random = rngNextWithUpperBoundU64(rng, delta + 1n);\n  return fromMagnitude64((toMagnitude64(start) + random) & mask64);\n}\n\n/**\n * Returns a random fixed-size byte array.\n *\n * Mirrors Rust's `rng_random_array<const N: usize>()` but takes the size at\n * runtime since JavaScript lacks const generics.\n */\nexport function rngRandomArray(rng: RandomNumberGenerator, size: number): Uint8Array {\n  const data = new Uint8Array(size);\n  rng.fillRandomData(data);\n  return data;\n}\n\n/**\n * Returns a random boolean. Mirrors Rust's `rng_random_bool` which tests\n * whether `next_u32()` is a multiple of 2.\n */\nexport function rngRandomBool(rng: RandomNumberGenerator): boolean {\n  return (rng.nextU32() & 1) === 0;\n}\n\n/**\n * Returns a random 32-bit unsigned integer.\n */\nexport function rngRandomU32(rng: RandomNumberGenerator): number {\n  return rng.nextU32();\n}\n","/**\n * Copyright © 2023-2026 Blockchain Commons, LLC\n * Copyright © 2025-2026 Parity Technologies\n *\n */\n\n// Ported from bc-rand-rust/src/secure_random.rs\n\nimport type { RandomNumberGenerator } from \"./random-number-generator.js\";\n\n/**\n * Returns the Web Crypto API for the current environment. Available natively\n * in browsers and in Node.js >= 15 via `globalThis.crypto`.\n */\nfunction getCrypto(): Crypto {\n  if (typeof globalThis !== \"undefined\" && globalThis.crypto != null) {\n    return globalThis.crypto;\n  }\n  throw new Error(\"No crypto API available in this environment\");\n}\n\n/**\n * Generate a Uint8Array of cryptographically strong random bytes of the given size.\n */\nexport function randomData(size: number): Uint8Array {\n  const data = new Uint8Array(size);\n  fillRandomData(data);\n  return data;\n}\n\n/**\n * Fill the given Uint8Array with cryptographically strong random bytes.\n */\nexport function fillRandomData(data: Uint8Array): void {\n  const crypto = getCrypto();\n  crypto.getRandomValues(data as Uint8Array<ArrayBuffer>);\n}\n\n/**\n * Returns the next cryptographically strong random 64-bit unsigned integer.\n *\n * This mirrors Rust's module-private `secure_random::next_u64()` and is not\n * re-exported from the package surface (matches Rust `lib.rs` behavior).\n */\nfunction nextU64(): bigint {\n  const data = new Uint8Array(8);\n  fillRandomData(data);\n  const view = new DataView(data.buffer);\n  return view.getBigUint64(0, true); // little-endian\n}\n\n/**\n * A random number generator that can be used as a source of\n * cryptographically-strong randomness.\n *\n * Uses the Web Crypto API (crypto.getRandomValues) which is available\n * in both browsers and Node.js >= 15.\n */\nexport class SecureRandomNumberGenerator implements RandomNumberGenerator {\n  /**\n   * Returns the next random 32-bit unsigned integer.\n   *\n   * Mirrors Rust's `next_u32` impl which returns `next_u64() as u32` —\n   * the low 32 bits of a 64-bit draw.\n   */\n  nextU32(): number {\n    return Number(this.nextU64() & 0xffffffffn) >>> 0;\n  }\n\n  /**\n   * Returns the next random 64-bit unsigned integer as a bigint.\n   */\n  nextU64(): bigint {\n    return nextU64();\n  }\n\n  /**\n   * Fills the given Uint8Array with random bytes.\n   */\n  fillBytes(dest: Uint8Array): void {\n    fillRandomData(dest);\n  }\n\n  /**\n   * Returns a Uint8Array of random bytes of the given size.\n   */\n  randomData(size: number): Uint8Array {\n    return randomData(size);\n  }\n\n  /**\n   * Fills the given Uint8Array with random bytes.\n   */\n  fillRandomData(data: Uint8Array): void {\n    fillRandomData(data);\n  }\n}\n\n/**\n * Returns a thread-local cryptographically-strong RNG. Mirrors Rust's\n * `thread_rng()`. In TypeScript there are no thread-locals, so this returns\n * a fresh `SecureRandomNumberGenerator` — every instance backs onto the\n * same Web Crypto source, so the effect is equivalent.\n */\nexport function threadRng(): SecureRandomNumberGenerator {\n  return new SecureRandomNumberGenerator();\n}\n","/**\n * Copyright © 2023-2026 Blockchain Commons, LLC\n * Copyright © 2025-2026 Parity Technologies\n *\n */\n\n// Ported from bc-rand-rust/src/seeded_random.rs\n\nimport type { RandomNumberGenerator } from \"./random-number-generator.js\";\n\n/**\n * Xoshiro256** state\n * Based on xoshiro256** 1.0 by David Blackman and Sebastiano Vigna\n * https://prng.di.unimi.it/\n */\ninterface Xoshiro256State {\n  s0: bigint;\n  s1: bigint;\n  s2: bigint;\n  s3: bigint;\n}\n\n/**\n * Rotate left for 64-bit bigint\n */\nfunction rotl(x: bigint, k: number): bigint {\n  const mask = 0xffffffffffffffffn;\n  return ((x << BigInt(k)) | (x >> BigInt(64 - k))) & mask;\n}\n\n/**\n * Xoshiro256** PRNG implementation\n * This is the same algorithm used by rand_xoshiro in Rust\n */\nfunction xoshiro256StarStar(state: Xoshiro256State): bigint {\n  const mask = 0xffffffffffffffffn;\n\n  // result = rotl(s1 * 5, 7) * 9\n  const result = (rotl((state.s1 * 5n) & mask, 7) * 9n) & mask;\n\n  // t = s1 << 17\n  const t = (state.s1 << 17n) & mask;\n\n  // Update state\n  state.s2 ^= state.s0;\n  state.s3 ^= state.s1;\n  state.s1 ^= state.s2;\n  state.s0 ^= state.s3;\n\n  state.s2 ^= t;\n  state.s3 = rotl(state.s3, 45);\n\n  return result;\n}\n\n/**\n * A random number generator that can be used as a source of deterministic\n * pseudo-randomness for testing purposes.\n *\n * Uses the Xoshiro256** algorithm, which is the same algorithm used by\n * rand_xoshiro in Rust. This ensures cross-platform compatibility with\n * the Rust implementation.\n *\n * WARNING: This is NOT cryptographically secure and should only be used\n * for testing purposes.\n */\nexport class SeededRandomNumberGenerator implements RandomNumberGenerator {\n  private readonly state: Xoshiro256State;\n\n  /**\n   * Creates a new seeded random number generator.\n   *\n   * The seed should be a 256-bit value, represented as an array of 4 64-bit\n   * integers (as bigints). For the output distribution to look random, the seed\n   * should not have any obvious patterns, like all zeroes or all ones.\n   *\n   * This is not cryptographically secure, and should only be used for\n   * testing purposes.\n   *\n   * @param seed - Array of 4 64-bit unsigned integers as bigints\n   */\n  constructor(seed: [bigint, bigint, bigint, bigint]) {\n    this.state = {\n      s0: seed[0] & 0xffffffffffffffffn,\n      s1: seed[1] & 0xffffffffffffffffn,\n      s2: seed[2] & 0xffffffffffffffffn,\n      s3: seed[3] & 0xffffffffffffffffn,\n    };\n  }\n\n  /**\n   * Returns the next random 64-bit unsigned integer as a bigint.\n   */\n  nextU64(): bigint {\n    return xoshiro256StarStar(this.state);\n  }\n\n  /**\n   * Returns the next random 32-bit unsigned integer.\n   */\n  nextU32(): number {\n    return Number(this.nextU64() & 0xffffffffn) >>> 0;\n  }\n\n  /**\n   * Fills the given Uint8Array with random bytes.\n   *\n   * Note: This implementation matches the Rust behavior exactly -\n   * it uses one nextU64() call per byte (taking only the low byte),\n   * which matches the Swift version's behavior.\n   */\n  fillBytes(dest: Uint8Array): void {\n    for (let i = 0; i < dest.length; i++) {\n      dest[i] = Number(this.nextU64() & 0xffn);\n    }\n  }\n\n  /**\n   * Returns a Uint8Array of random bytes of the given size.\n   *\n   * This might not be the most efficient implementation,\n   * but it works the same as the Swift version.\n   */\n  randomData(size: number): Uint8Array {\n    const data = new Uint8Array(size);\n    for (let i = 0; i < size; i++) {\n      data[i] = Number(this.nextU64() & 0xffn);\n    }\n    return data;\n  }\n\n  /**\n   * Fills the given Uint8Array with random bytes.\n   */\n  fillRandomData(data: Uint8Array): void {\n    this.fillBytes(data);\n  }\n}\n\n/**\n * Standard test seed for `makeFakeRandomNumberGenerator`. Module-private to\n * mirror Rust where the equivalent constant lives inside `mod tests`.\n */\nconst TEST_SEED: [bigint, bigint, bigint, bigint] = [\n  17295166580085024720n,\n  422929670265678780n,\n  5577237070365765850n,\n  7953171132032326923n,\n];\n\n/**\n * Creates a seeded random number generator with a fixed seed.\n * This is useful for reproducible testing across different platforms.\n */\nexport function makeFakeRandomNumberGenerator(): SeededRandomNumberGenerator {\n  return new SeededRandomNumberGenerator(TEST_SEED);\n}\n\n/**\n * Creates a Uint8Array of random data with a fixed seed.\n * This is useful for reproducible testing.\n *\n * @param size - The number of bytes to generate\n * @returns A Uint8Array of pseudo-random bytes\n */\nexport function fakeRandomData(size: number): Uint8Array {\n  return makeFakeRandomNumberGenerator().randomData(size);\n}\n"],"mappings":"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"}

package/dist/index.d.cts

@@ -1,4 +1,9 @@
 //#region src/widening.d.ts
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
 /**
  * Wide multiplication result type - returns (low, high) parts.
  * For a multiplication of two N-bit values, the result is 2N bits
@@ -42,6 +47,11 @@ declare function wideMulU32(a: number, b: number): [bigint, bigint];
 declare function wideMulU64(a: bigint, b: bigint): [bigint, bigint];
 //#endregion
 //#region src/magnitude.d.ts
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
 /**
  * Converts a signed integer to its unsigned magnitude.
  * For positive numbers, returns the number unchanged.
@@ -65,35 +75,27 @@ declare function fromMagnitude(magnitude: number, bits: 8 | 16 | 32): number;
 declare function fromMagnitude64(magnitude: bigint): bigint;
 //#endregion
 //#region src/random-number-generator.d.ts
+/**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ */
 /**
  * Interface for random number generators.
- * This is the TypeScript equivalent of Rust's RandomNumberGenerator trait
- * which extends RngCore + CryptoRng.
  *
- * This is compatible with the RandomNumberGenerator Swift protocol used
- * in MacOS and iOS, which is important for cross-platform testing.
+ * The TypeScript equivalent of Rust's `RandomNumberGenerator` trait
+ * (which extends `RngCore + CryptoRng`).
  */
 interface RandomNumberGenerator {
-  /**
-   * Returns the next random 32-bit unsigned integer.
-   */
+  /** Returns the next random 32-bit unsigned integer. */
   nextU32(): number;
-  /**
-   * Returns the next random 64-bit unsigned integer as a bigint.
-   */
+  /** Returns the next random 64-bit unsigned integer as a bigint. */
   nextU64(): bigint;
-  /**
-   * Fills the given Uint8Array with random bytes.
-   */
+  /** Fills the given Uint8Array with random bytes. */
   fillBytes(dest: Uint8Array): void;
-  /**
-   * Returns a Uint8Array of random bytes of the given size.
-   */
+  /** Returns a Uint8Array of random bytes of the given size. */
   randomData(size: number): Uint8Array;
-  /**
-   * Fills the given Uint8Array with random bytes.
-   * Alias for fillBytes for compatibility.
-   */
+  /** Fills the given Uint8Array with random bytes. Alias for fillBytes. */
   fillRandomData(data: Uint8Array): void;
 }
 /**
@@ -105,86 +107,85 @@ declare function rngRandomData(rng: RandomNumberGenerator, size: number): Uint8A
  */
 declare function rngFillRandomData(rng: RandomNumberGenerator, data: Uint8Array): void;
 /**
- * Returns a random value that is less than the given upper bound.
- *
- * Uses Lemire's "nearly divisionless" method for generating random
- * integers in an interval. For a detailed explanation, see:
- * https://arxiv.org/abs/1805.10941
- *
- * @param rng - The random number generator to use
- * @param upperBound - The upper bound for the randomly generated value. Must be non-zero.
- * @returns A random value in the range [0, upperBound). Every value in the range is equally likely.
+ * Returns a random `u8` value strictly less than `upperBound`.
  */
-declare function rngNextWithUpperBound(rng: RandomNumberGenerator, upperBound: bigint): bigint;
+declare function rngNextWithUpperBoundU8(rng: RandomNumberGenerator, upperBound: number): number;
 /**
- * Returns a random 32-bit value that is less than the given upper bound.
- * This matches Rust's behavior when called with u32 type.
- *
- * Uses Lemire's "nearly divisionless" method with 32-bit arithmetic.
- *
- * @param rng - The random number generator to use
- * @param upperBound - The upper bound for the randomly generated value. Must be non-zero and fit in u32.
- * @returns A random u32 value in the range [0, upperBound).
+ * Returns a random `u16` value strictly less than `upperBound`.
+ */
+declare function rngNextWithUpperBoundU16(rng: RandomNumberGenerator, upperBound: number): number;
+/**
+ * Returns a random `u32` value strictly less than `upperBound`.
  */
 declare function rngNextWithUpperBoundU32(rng: RandomNumberGenerator, upperBound: number): number;
 /**
- * Returns a random value within the specified range [start, end) using 32-bit arithmetic.
- * This matches Rust's behavior when called with i32 types.
- *
- * @param rng - The random number generator to use
- * @param start - The lower bound (inclusive) as i32
- * @param end - The upper bound (exclusive) as i32
- * @returns A random i32 value within the bounds
+ * Returns a random `u64` value strictly less than `upperBound`.
  */
-declare function rngNextInRangeI32(rng: RandomNumberGenerator, start: number, end: number): number;
+declare function rngNextWithUpperBoundU64(rng: RandomNumberGenerator, upperBound: bigint): bigint;
 /**
- * Returns a random value within the specified range [start, end).
+ * Alias of `rngNextWithUpperBoundU64`. Kept for API backwards compatibility.
  *
- * @param rng - The random number generator to use
- * @param start - The lower bound (inclusive)
- * @param end - The upper bound (exclusive)
- * @returns A random value within the bounds of the range
+ * @deprecated Prefer the explicit-width name `rngNextWithUpperBoundU64`.
  */
-declare function rngNextInRange(rng: RandomNumberGenerator, start: bigint, end: bigint): bigint;
+declare const rngNextWithUpperBound: typeof rngNextWithUpperBoundU64;
+/** Random `u8` in the half-open range [start, end). */
+declare function rngNextInRangeU8(rng: RandomNumberGenerator, start: number, end: number): number;
+/** Random `u16` in the half-open range [start, end). */
+declare function rngNextInRangeU16(rng: RandomNumberGenerator, start: number, end: number): number;
+/** Random `u32` in the half-open range [start, end). */
+declare function rngNextInRangeU32(rng: RandomNumberGenerator, start: number, end: number): number;
+/** Random `u64` in the half-open range [start, end). */
+declare function rngNextInRangeU64(rng: RandomNumberGenerator, start: bigint, end: bigint): bigint;
 /**
- * Returns a random value within the specified closed range [start, end].
+ * Alias of `rngNextInRangeU64`. Kept for API backwards compatibility.
  *
- * @param rng - The random number generator to use
- * @param start - The lower bound (inclusive)
- * @param end - The upper bound (inclusive)
- * @returns A random value within the bounds of the range
+ * @deprecated Prefer the explicit-width name `rngNextInRangeU64`.
  */
-declare function rngNextInClosedRange(rng: RandomNumberGenerator, start: bigint, end: bigint): bigint;
+declare const rngNextInRange: typeof rngNextInRangeU64;
+/** Random `i8` in the half-open range [start, end). */
+declare function rngNextInRangeI8(rng: RandomNumberGenerator, start: number, end: number): number;
+/** Random `i16` in the half-open range [start, end). */
+declare function rngNextInRangeI16(rng: RandomNumberGenerator, start: number, end: number): number;
+/** Random `i32` in the half-open range [start, end). */
+declare function rngNextInRangeI32(rng: RandomNumberGenerator, start: number, end: number): number;
+/** Random `i64` in the half-open range [start, end). */
+declare function rngNextInRangeI64(rng: RandomNumberGenerator, start: bigint, end: bigint): bigint;
+/** Random `u8` in the closed range [start, end]. */
+declare function rngNextInClosedRangeU8(rng: RandomNumberGenerator, start: number, end: number): number;
+/** Random `u16` in the closed range [start, end]. */
+declare function rngNextInClosedRangeU16(rng: RandomNumberGenerator, start: number, end: number): number;
+/** Random `u32` in the closed range [start, end]. */
+declare function rngNextInClosedRangeU32(rng: RandomNumberGenerator, start: number, end: number): number;
+/** Random `u64` in the closed range [start, end]. */
+declare function rngNextInClosedRangeU64(rng: RandomNumberGenerator, start: bigint, end: bigint): bigint;
 /**
- * Returns a random value within the specified closed range [start, end] for i32 values.
- * Convenience function that handles signed 32-bit integers.
+ * Alias of `rngNextInClosedRangeU64`. Kept for API backwards compatibility.
  *
- * @param rng - The random number generator to use
- * @param start - The lower bound (inclusive) as i32
- * @param end - The upper bound (inclusive) as i32
- * @returns A random i32 value within the bounds of the range
+ * @deprecated Prefer the explicit-width name `rngNextInClosedRangeU64`.
  */
+declare const rngNextInClosedRange: typeof rngNextInClosedRangeU64;
+/** Random `i8` in the closed range [start, end]. */
+declare function rngNextInClosedRangeI8(rng: RandomNumberGenerator, start: number, end: number): number;
+/** Random `i16` in the closed range [start, end]. */
+declare function rngNextInClosedRangeI16(rng: RandomNumberGenerator, start: number, end: number): number;
+/** Random `i32` in the closed range [start, end]. */
 declare function rngNextInClosedRangeI32(rng: RandomNumberGenerator, start: number, end: number): number;
+/** Random `i64` in the closed range [start, end]. */
+declare function rngNextInClosedRangeI64(rng: RandomNumberGenerator, start: bigint, end: bigint): bigint;
 /**
- * Returns a fixed-size array of random bytes.
+ * Returns a random fixed-size byte array.
  *
- * @param rng - The random number generator to use
- * @param size - The size of the array to return
- * @returns A Uint8Array of the specified size filled with random bytes
+ * Mirrors Rust's `rng_random_array<const N: usize>()` but takes the size at
+ * runtime since JavaScript lacks const generics.
  */
 declare function rngRandomArray(rng: RandomNumberGenerator, size: number): Uint8Array;
 /**
- * Returns a random boolean value.
- *
- * @param rng - The random number generator to use
- * @returns A random boolean
+ * Returns a random boolean. Mirrors Rust's `rng_random_bool` which tests
+ * whether `next_u32()` is a multiple of 2.
  */
 declare function rngRandomBool(rng: RandomNumberGenerator): boolean;
 /**
  * Returns a random 32-bit unsigned integer.
- *
- * @param rng - The random number generator to use
- * @returns A random u32 value
  */
 declare function rngRandomU32(rng: RandomNumberGenerator): number;
 //#endregion
@@ -197,10 +198,6 @@ declare function randomData(size: number): Uint8Array;
  * Fill the given Uint8Array with cryptographically strong random bytes.
  */
 declare function fillRandomData(data: Uint8Array): void;
-/**
- * Returns the next cryptographically strong random 64-bit unsigned integer.
- */
-declare function nextU64(): bigint;
 /**
  * A random number generator that can be used as a source of
  * cryptographically-strong randomness.
@@ -211,6 +208,9 @@ declare function nextU64(): bigint;
 declare class SecureRandomNumberGenerator implements RandomNumberGenerator {
   /**
    * Returns the next random 32-bit unsigned integer.
+   *
+   * Mirrors Rust's `next_u32` impl which returns `next_u64() as u32` —
+   * the low 32 bits of a 64-bit draw.
    */
   nextU32(): number;
   /**
@@ -230,6 +230,13 @@ declare class SecureRandomNumberGenerator implements RandomNumberGenerator {
    */
   fillRandomData(data: Uint8Array): void;
 }
+/**
+ * Returns a thread-local cryptographically-strong RNG. Mirrors Rust's
+ * `thread_rng()`. In TypeScript there are no thread-locals, so this returns
+ * a fresh `SecureRandomNumberGenerator` — every instance backs onto the
+ * same Web Crypto source, so the effect is equivalent.
+ */
+declare function threadRng(): SecureRandomNumberGenerator;
 //#endregion
 //#region src/seeded-random.d.ts
 /**
@@ -258,13 +265,6 @@ declare class SeededRandomNumberGenerator implements RandomNumberGenerator {
    * @param seed - Array of 4 64-bit unsigned integers as bigints
    */
   constructor(seed: [bigint, bigint, bigint, bigint]);
-  /**
-   * Creates a new seeded random number generator from a seed array.
-   * Convenience method that accepts numbers and converts to bigints.
-   *
-   * @param seed - Array of 4 64-bit unsigned integers
-   */
-  static fromSeed(seed: [bigint, bigint, bigint, bigint]): SeededRandomNumberGenerator;
   /**
    * Returns the next random 64-bit unsigned integer as a bigint.
    */
@@ -293,10 +293,6 @@ declare class SeededRandomNumberGenerator implements RandomNumberGenerator {
    */
   fillRandomData(data: Uint8Array): void;
 }
-/**
- * The standard test seed used across all Blockchain Commons implementations.
- */
-declare const TEST_SEED: [bigint, bigint, bigint, bigint];
 /**
  * Creates a seeded random number generator with a fixed seed.
  * This is useful for reproducible testing across different platforms.
@@ -311,5 +307,5 @@ declare function makeFakeRandomNumberGenerator(): SeededRandomNumberGenerator;
  */
 declare function fakeRandomData(size: number): Uint8Array;
 //#endregion
-export { type RandomNumberGenerator, SecureRandomNumberGenerator, SeededRandomNumberGenerator, TEST_SEED, type WideMulResult, fakeRandomData, fillRandomData, fromMagnitude, fromMagnitude64, makeFakeRandomNumberGenerator, nextU64, randomData, rngFillRandomData, rngNextInClosedRange, rngNextInClosedRangeI32, rngNextInRange, rngNextInRangeI32, rngNextWithUpperBound, rngNextWithUpperBoundU32, rngRandomArray, rngRandomBool, rngRandomData, rngRandomU32, toMagnitude, toMagnitude64, wideMul, wideMulU16, wideMulU32, wideMulU64, wideMulU8 };
+export { type RandomNumberGenerator, SecureRandomNumberGenerator, SeededRandomNumberGenerator, type WideMulResult, fakeRandomData, fillRandomData, fromMagnitude, fromMagnitude64, makeFakeRandomNumberGenerator, randomData, rngFillRandomData, rngNextInClosedRange, rngNextInClosedRangeI16, rngNextInClosedRangeI32, rngNextInClosedRangeI64, rngNextInClosedRangeI8, rngNextInClosedRangeU16, rngNextInClosedRangeU32, rngNextInClosedRangeU64, rngNextInClosedRangeU8, rngNextInRange, rngNextInRangeI16, rngNextInRangeI32, rngNextInRangeI64, rngNextInRangeI8, rngNextInRangeU16, rngNextInRangeU32, rngNextInRangeU64, rngNextInRangeU8, rngNextWithUpperBound, rngNextWithUpperBoundU16, rngNextWithUpperBoundU32, rngNextWithUpperBoundU64, rngNextWithUpperBoundU8, rngRandomArray, rngRandomBool, rngRandomData, rngRandomU32, threadRng, toMagnitude, toMagnitude64, wideMul, wideMulU16, wideMulU32, wideMulU64, wideMulU8 };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/widening.ts","../src/magnitude.ts","../src/random-number-generator.ts","../src/secure-random.ts","../src/seeded-random.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/widening.ts","../src/magnitude.ts","../src/random-number-generator.ts","../src/secure-random.ts","../src/seeded-random.ts"],"mappings":"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"}