{"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`. 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` and `rng_next_in_closed_range`.\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::` 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()` 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);\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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"}