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

package/dist/index.iife.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.iife.js","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.iife.js","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.mjs

@@ -51,10 +51,14 @@ function wideMulU64(a, b) {
 	const wide = (a & mask64) * (b & mask64);
 	return [wide & mask64, wide >> 64n];
 }
-
 //#endregion
 //#region src/magnitude.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.
 * For negative numbers, returns the absolute value (wrapping for MIN values).
@@ -107,10 +111,14 @@ function fromMagnitude64(magnitude) {
 	if ((maskedMag & signBit) !== 0n) return maskedMag - (1n << 64n);
 	return maskedMag;
 }
-
 //#endregion
 //#region src/random-number-generator.ts
 /**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+*/
+/**
 * Returns a Uint8Array of random bytes of the given size.
 */
 function rngRandomData(rng, size) {
@@ -125,121 +133,231 @@ function rngFillRandomData(rng, data) {
 	rng.fillRandomData(data);
 }
 /**
-* 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`.
 */
-function rngNextWithUpperBound(rng, upperBound) {
-	if (upperBound === 0n) throw new Error("upperBound must be non-zero");
-	const bitmask = 18446744073709551615n;
-	let random = rng.nextU64() & bitmask;
-	let m = wideMulU64(random, upperBound);
-	if (m[0] < upperBound) {
-		const t = (bitmask + 1n - upperBound & bitmask) % upperBound;
+function rngNextWithUpperBoundU8(rng, upperBound) {
+	if (upperBound === 0) throw new Error("upperBound must be non-zero");
+	const ub = upperBound & 255;
+	let random = Number(rng.nextU64() & 255n);
+	let m = wideMulU8(random, ub);
+	if (m[0] < ub) {
+		const t = (256 - ub & 255) % ub;
 		while (m[0] < t) {
-			random = rng.nextU64() & bitmask;
-			m = wideMulU64(random, upperBound);
+			random = Number(rng.nextU64() & 255n);
+			m = wideMulU8(random, ub);
 		}
 	}
 	return m[1];
 }
 /**
-* 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`.
+*/
+function rngNextWithUpperBoundU16(rng, upperBound) {
+	if (upperBound === 0) throw new Error("upperBound must be non-zero");
+	const ub = upperBound & 65535;
+	let random = Number(rng.nextU64() & 65535n);
+	let m = wideMulU16(random, ub);
+	if (m[0] < ub) {
+		const t = (65536 - ub & 65535) % ub;
+		while (m[0] < t) {
+			random = Number(rng.nextU64() & 65535n);
+			m = wideMulU16(random, ub);
+		}
+	}
+	return m[1];
+}
+/**
+* Returns a random `u32` value strictly less than `upperBound`.
 */
 function rngNextWithUpperBoundU32(rng, upperBound) {
 	if (upperBound === 0) throw new Error("upperBound must be non-zero");
-	const upperBoundU32 = upperBound >>> 0;
-	const bitmask = 4294967295;
-	let random = Number(rng.nextU64() & BigInt(bitmask));
-	let m = wideMulU32(random, upperBoundU32);
-	if (Number(m[0]) < upperBoundU32) {
-		const t = (bitmask + 1 - upperBoundU32 >>> 0) % upperBoundU32;
+	const ub = upperBound >>> 0;
+	let random = Number(rng.nextU64() & 4294967295n);
+	let m = wideMulU32(random, ub);
+	if (Number(m[0]) < ub) {
+		const t = (4294967296 - ub >>> 0) % ub;
 		while (Number(m[0]) < t) {
-			random = Number(rng.nextU64() & BigInt(bitmask));
-			m = wideMulU32(random, upperBoundU32);
+			random = Number(rng.nextU64() & 4294967295n);
+			m = wideMulU32(random, ub);
 		}
 	}
 	return Number(m[1]);
 }
 /**
-* 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`.
 */
-function rngNextInRangeI32(rng, start, end) {
-	if (start >= end) throw new Error("start must be less than end");
-	const startI32 = start | 0;
-	const delta = toMagnitude((end | 0) - startI32, 32);
-	if (delta === 4294967295) return rng.nextU32() | 0;
-	return startI32 + rngNextWithUpperBoundU32(rng, delta) | 0;
+function rngNextWithUpperBoundU64(rng, upperBound) {
+	if (upperBound === 0n) throw new Error("upperBound must be non-zero");
+	const mask64 = 18446744073709551615n;
+	const ub = upperBound & mask64;
+	let random = rng.nextU64() & mask64;
+	let m = wideMulU64(random, ub);
+	if (m[0] < ub) {
+		const t = (mask64 + 1n - ub & mask64) % ub;
+		while (m[0] < t) {
+			random = rng.nextU64() & mask64;
+			m = wideMulU64(random, ub);
+		}
+	}
+	return m[1];
 }
 /**
-* 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`.
 */
-function rngNextInRange(rng, start, end) {
+const rngNextWithUpperBound = rngNextWithUpperBoundU64;
+function fromU64ThrowsIfAbove(value, max) {
+	if (value > max) throw new Error("from_u64 conversion overflow");
+	return value;
+}
+/** Random `u8` in the half-open range [start, end). */
+function rngNextInRangeU8(rng, start, end) {
+	if (start >= end) throw new Error("start must be less than end");
+	const lo = start & 255;
+	const delta = (end & 255) - lo & 255;
+	if (delta === 255) return Number(fromU64ThrowsIfAbove(rng.nextU64(), 255n));
+	return lo + rngNextWithUpperBoundU8(rng, delta) & 255;
+}
+/** Random `u16` in the half-open range [start, end). */
+function rngNextInRangeU16(rng, start, end) {
+	if (start >= end) throw new Error("start must be less than end");
+	const lo = start & 65535;
+	const delta = (end & 65535) - lo & 65535;
+	if (delta === 65535) return Number(fromU64ThrowsIfAbove(rng.nextU64(), 65535n));
+	return lo + rngNextWithUpperBoundU16(rng, delta) & 65535;
+}
+/** Random `u32` in the half-open range [start, end). */
+function rngNextInRangeU32(rng, start, end) {
 	if (start >= end) throw new Error("start must be less than end");
-	const delta = end - start;
-	if (delta === 18446744073709551615n) return rng.nextU64();
-	return start + rngNextWithUpperBound(rng, delta);
+	const lo = start >>> 0;
+	const delta = (end >>> 0) - lo >>> 0;
+	if (delta === 4294967295) return Number(fromU64ThrowsIfAbove(rng.nextU64(), 4294967295n));
+	return lo + rngNextWithUpperBoundU32(rng, delta) >>> 0;
+}
+/** Random `u64` in the half-open range [start, end). */
+function rngNextInRangeU64(rng, start, end) {
+	if (start >= end) throw new Error("start must be less than end");
+	const mask64 = 18446744073709551615n;
+	const delta = end - start & mask64;
+	if (delta === mask64) return rng.nextU64();
+	return start + rngNextWithUpperBoundU64(rng, delta) & mask64;
 }
 /**
-* 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`.
 */
-function rngNextInClosedRange(rng, start, end) {
+const rngNextInRange = rngNextInRangeU64;
+/** Random `i8` in the half-open range [start, end). */
+function rngNextInRangeI8(rng, start, end) {
+	if (start >= end) throw new Error("start must be less than end");
+	const lo = start << 24 >> 24;
+	const delta = toMagnitude((end << 24 >> 24) - lo, 8);
+	if (delta === 255) return Number(fromU64ThrowsIfAbove(rng.nextU64(), 127n));
+	return lo + rngNextWithUpperBoundU8(rng, delta) << 24 >> 24;
+}
+/** Random `i16` in the half-open range [start, end). */
+function rngNextInRangeI16(rng, start, end) {
+	if (start >= end) throw new Error("start must be less than end");
+	const lo = start << 16 >> 16;
+	const delta = toMagnitude((end << 16 >> 16) - lo, 16);
+	if (delta === 65535) return Number(fromU64ThrowsIfAbove(rng.nextU64(), 32767n));
+	return lo + rngNextWithUpperBoundU16(rng, delta) << 16 >> 16;
+}
+/** Random `i32` in the half-open range [start, end). */
+function rngNextInRangeI32(rng, start, end) {
+	if (start >= end) throw new Error("start must be less than end");
+	const lo = start | 0;
+	const delta = toMagnitude((end | 0) - lo, 32);
+	if (delta === 4294967295) return Number(fromU64ThrowsIfAbove(rng.nextU64(), 2147483647n));
+	return lo + rngNextWithUpperBoundU32(rng, delta) | 0;
+}
+/** Random `i64` in the half-open range [start, end). */
+function rngNextInRangeI64(rng, start, end) {
+	if (start >= end) throw new Error("start must be less than end");
+	const delta = toMagnitude64(end - start);
+	const mask64 = 18446744073709551615n;
+	if (delta === mask64) return fromU64ThrowsIfAbove(rng.nextU64(), 9223372036854775807n);
+	const random = rngNextWithUpperBoundU64(rng, delta);
+	return fromMagnitude64(toMagnitude64(start) + random & mask64);
+}
+/** Random `u8` in the closed range [start, end]. */
+function rngNextInClosedRangeU8(rng, start, end) {
+	if (start > end) throw new Error("start must be less than or equal to end");
+	const lo = start & 255;
+	const delta = (end & 255) - lo & 255;
+	if (delta === 255) return Number(fromU64ThrowsIfAbove(rng.nextU64(), 255n));
+	return lo + rngNextWithUpperBoundU8(rng, delta + 1) & 255;
+}
+/** Random `u16` in the closed range [start, end]. */
+function rngNextInClosedRangeU16(rng, start, end) {
+	if (start > end) throw new Error("start must be less than or equal to end");
+	const lo = start & 65535;
+	const delta = (end & 65535) - lo & 65535;
+	if (delta === 65535) return Number(fromU64ThrowsIfAbove(rng.nextU64(), 65535n));
+	return lo + rngNextWithUpperBoundU16(rng, delta + 1) & 65535;
+}
+/** Random `u32` in the closed range [start, end]. */
+function rngNextInClosedRangeU32(rng, start, end) {
+	if (start > end) throw new Error("start must be less than or equal to end");
+	const lo = start >>> 0;
+	const delta = (end >>> 0) - lo >>> 0;
+	if (delta === 4294967295) return Number(fromU64ThrowsIfAbove(rng.nextU64(), 4294967295n));
+	return lo + rngNextWithUpperBoundU32(rng, delta + 1) >>> 0;
+}
+/** Random `u64` in the closed range [start, end]. */
+function rngNextInClosedRangeU64(rng, start, end) {
 	if (start > end) throw new Error("start must be less than or equal to end");
-	const delta = end - start;
-	if (delta === 18446744073709551615n) return rng.nextU64();
-	return start + rngNextWithUpperBound(rng, delta + 1n);
+	const mask64 = 18446744073709551615n;
+	const delta = end - start & mask64;
+	if (delta === mask64) return rng.nextU64();
+	return start + rngNextWithUpperBoundU64(rng, delta + 1n) & mask64;
 }
 /**
-* 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`.
 */
+const rngNextInClosedRange = rngNextInClosedRangeU64;
+/** Random `i8` in the closed range [start, end]. */
+function rngNextInClosedRangeI8(rng, start, end) {
+	if (start > end) throw new Error("start must be less than or equal to end");
+	const lo = start << 24 >> 24;
+	const delta = toMagnitude((end << 24 >> 24) - lo, 8);
+	if (delta === 255) return Number(fromU64ThrowsIfAbove(rng.nextU64(), 127n));
+	return lo + rngNextWithUpperBoundU8(rng, delta + 1) << 24 >> 24;
+}
+/** Random `i16` in the closed range [start, end]. */
+function rngNextInClosedRangeI16(rng, start, end) {
+	if (start > end) throw new Error("start must be less than or equal to end");
+	const lo = start << 16 >> 16;
+	const delta = toMagnitude((end << 16 >> 16) - lo, 16);
+	if (delta === 65535) return Number(fromU64ThrowsIfAbove(rng.nextU64(), 32767n));
+	return lo + rngNextWithUpperBoundU16(rng, delta + 1) << 16 >> 16;
+}
+/** Random `i32` in the closed range [start, end]. */
 function rngNextInClosedRangeI32(rng, start, end) {
 	if (start > end) throw new Error("start must be less than or equal to end");
-	const startI32 = start | 0;
-	const delta = toMagnitude((end | 0) - startI32, 32);
-	if (delta === 4294967295) return rng.nextU32() | 0;
-	return startI32 + rngNextWithUpperBoundU32(rng, delta + 1) | 0;
+	const lo = start | 0;
+	const delta = toMagnitude((end | 0) - lo, 32);
+	if (delta === 4294967295) return Number(fromU64ThrowsIfAbove(rng.nextU64(), 2147483647n));
+	return lo + rngNextWithUpperBoundU32(rng, delta + 1) | 0;
+}
+/** Random `i64` in the closed range [start, end]. */
+function rngNextInClosedRangeI64(rng, start, end) {
+	if (start > end) throw new Error("start must be less than or equal to end");
+	const delta = toMagnitude64(end - start);
+	const mask64 = 18446744073709551615n;
+	if (delta === mask64) return fromU64ThrowsIfAbove(rng.nextU64(), 9223372036854775807n);
+	const random = rngNextWithUpperBoundU64(rng, delta + 1n);
+	return fromMagnitude64(toMagnitude64(start) + random & mask64);
 }
 /**
-* 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.
 */
 function rngRandomArray(rng, size) {
 	const data = new Uint8Array(size);
@@ -247,33 +365,26 @@ function rngRandomArray(rng, size) {
 	return data;
 }
 /**
-* 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.
 */
 function rngRandomBool(rng) {
 	return (rng.nextU32() & 1) === 0;
 }
 /**
 * Returns a random 32-bit unsigned integer.
-*
-* @param rng - The random number generator to use
-* @returns A random u32 value
 */
 function rngRandomU32(rng) {
 	return rng.nextU32();
 }
-
 //#endregion
 //#region src/secure-random.ts
 /**
-* Detects the crypto API available in the current environment.
-* Works in both Node.js and browser environments.
+* Returns the Web Crypto API for the current environment. Available natively
+* in browsers and in Node.js >= 15 via `globalThis.crypto`.
 */
 function getCrypto() {
-	if (typeof globalThis !== "undefined" && globalThis.crypto !== null && globalThis.crypto !== void 0) return globalThis.crypto;
-	if (typeof globalThis.crypto !== "undefined") return globalThis.crypto;
+	if (typeof globalThis !== "undefined" && globalThis.crypto != null) return globalThis.crypto;
 	throw new Error("No crypto API available in this environment");
 }
 /**
@@ -292,6 +403,9 @@ function fillRandomData(data) {
 }
 /**
 * Returns the next cryptographically strong random 64-bit unsigned integer.
+*
+* This mirrors Rust's module-private `secure_random::next_u64()` and is not
+* re-exported from the package surface (matches Rust `lib.rs` behavior).
 */
 function nextU64() {
 	const data = new Uint8Array(8);
@@ -308,11 +422,12 @@ function nextU64() {
 var SecureRandomNumberGenerator = class {
 	/**
 	* 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() {
-		const data = new Uint8Array(4);
-		fillRandomData(data);
-		return new DataView(data.buffer).getUint32(0, true) >>> 0;
+		return Number(this.nextU64() & 4294967295n) >>> 0;
 	}
 	/**
 	* Returns the next random 64-bit unsigned integer as a bigint.
@@ -339,7 +454,15 @@ var SecureRandomNumberGenerator = class {
 		fillRandomData(data);
 	}
 };
-
+/**
+* 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.
+*/
+function threadRng() {
+	return new SecureRandomNumberGenerator();
+}
 //#endregion
 //#region src/seeded-random.ts
 /**
@@ -375,7 +498,7 @@ function xoshiro256StarStar(state) {
 * WARNING: This is NOT cryptographically secure and should only be used
 * for testing purposes.
 */
-var SeededRandomNumberGenerator = class SeededRandomNumberGenerator {
+var SeededRandomNumberGenerator = class {
 	state;
 	/**
 	* Creates a new seeded random number generator.
@@ -398,15 +521,6 @@ var SeededRandomNumberGenerator = class SeededRandomNumberGenerator {
 		};
 	}
 	/**
-	* 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) {
-		return new SeededRandomNumberGenerator(seed);
-	}
-	/**
 	* Returns the next random 64-bit unsigned integer as a bigint.
 	*/
 	nextU64() {
@@ -447,7 +561,8 @@ var SeededRandomNumberGenerator = class SeededRandomNumberGenerator {
 	}
 };
 /**
-* The standard test seed used across all Blockchain Commons implementations.
+* Standard test seed for `makeFakeRandomNumberGenerator`. Module-private to
+* mirror Rust where the equivalent constant lives inside `mod tests`.
 */
 const TEST_SEED = [
 	17295166580085024720n,
@@ -472,7 +587,7 @@ function makeFakeRandomNumberGenerator() {
 function fakeRandomData(size) {
 	return makeFakeRandomNumberGenerator().randomData(size);
 }
-
 //#endregion
-export { SecureRandomNumberGenerator, SeededRandomNumberGenerator, TEST_SEED, 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 { SecureRandomNumberGenerator, SeededRandomNumberGenerator, 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.mjs.map