@bcts/rand 1.0.0-alpha.10

package/LICENSE

@@ -0,0 +1,48 @@
+Copyright © 2023 Blockchain Commons, LLC
+Copyright © 2025 Leonardo Amoroso Custodio
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+Subject to the terms and conditions of this license, each copyright holder and
+contributor hereby grants to those receiving rights under this license a
+perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+(except for failure to satisfy the conditions of this license) patent license to
+make, have made, use, offer to sell, sell, import, and otherwise transfer this
+software, where such license applies only to those patent claims, already
+acquired or hereafter acquired, licensable by such copyright holder or
+contributor that are necessarily infringed by:
+
+    (a) their Contribution(s) (the licensed copyrights of copyright holders and
+    non-copyrightable additions of contributors, in source or binary form)
+    alone; or
+
+    (b) combination of their Contribution(s) with the work of authorship to
+    which such Contribution(s) was added by such copyright holder or
+    contributor, if, at the time the Contribution is added, such addition causes
+    such combination to be necessarily infringed. The patent license shall not
+    apply to any other combinations which include the Contribution.
+
+Except as expressly stated above, no rights or licenses from any copyright
+holder or contributor is granted under this license, whether expressly, by
+implication, estoppel or otherwise.
+
+DISCLAIMER
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,13 @@
+# Blockchain Commons Random Number Utilities for TypeScript
+
+> Disclaimer: This package is under active development and APIs may change.
+
+## Introduction
+
+`rand` exposes a uniform API for the random number primitives used in higher-level [Blockchain Commons](https://blockchaincommons.com) projects, including a cryptographically strong random number generator and a deterministic random number generator.
+
+The crate also includes several convenience functions for generating secure and deterministic random numbers.
+
+## Rust Reference Implementation
+
+This TypeScript implementation is based on [bc-rand-rust](https://github.com/BlockchainCommons/bc-rand-rust) **v0.5.0** ([commit](https://github.com/BlockchainCommons/bc-rand-rust/tree/8f53717e35300933e9ca1bc6c51bddc0854cfb9e)).

package/dist/index.cjs

@@ -0,0 +1,506 @@
+
+//#region src/widening.ts
+/**
+* Performs wide multiplication for unsigned integers.
+* Returns (low, high) parts of the full-width result.
+*
+* This is equivalent to Rust's widening_mul for unsigned types.
+*/
+function wideMul(a, b, bits) {
+	const mask = (1n << BigInt(bits)) - 1n;
+	const wide = (a & mask) * (b & mask);
+	return [wide & mask, wide >> BigInt(bits)];
+}
+/**
+* Wide multiplication for 8-bit unsigned integers.
+* @param a - First 8-bit value
+* @param b - Second 8-bit value
+* @returns Tuple of (low 8 bits, high 8 bits)
+*/
+function wideMulU8(a, b) {
+	const wide = (a & 255) * (b & 255);
+	return [wide & 255, wide >> 8 & 255];
+}
+/**
+* Wide multiplication for 16-bit unsigned integers.
+* @param a - First 16-bit value
+* @param b - Second 16-bit value
+* @returns Tuple of (low 16 bits, high 16 bits)
+*/
+function wideMulU16(a, b) {
+	const wide = (a & 65535) * (b & 65535);
+	return [wide & 65535, wide >>> 16 & 65535];
+}
+/**
+* Wide multiplication for 32-bit unsigned integers.
+* @param a - First 32-bit value
+* @param b - Second 32-bit value
+* @returns Tuple of (low 32 bits, high 32 bits) as bigints
+*/
+function wideMulU32(a, b) {
+	const wide = BigInt(a >>> 0) * BigInt(b >>> 0);
+	return [wide & 4294967295n, wide >> 32n];
+}
+/**
+* Wide multiplication for 64-bit unsigned integers.
+* @param a - First 64-bit value as bigint
+* @param b - Second 64-bit value as bigint
+* @returns Tuple of (low 64 bits, high 64 bits) as bigints
+*/
+function wideMulU64(a, b) {
+	const mask64 = 18446744073709551615n;
+	const wide = (a & mask64) * (b & mask64);
+	return [wide & mask64, wide >> 64n];
+}
+
+//#endregion
+//#region src/magnitude.ts
+/**
+* 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).
+*
+* This matches Rust's wrapping_abs() behavior.
+*/
+function toMagnitude(value, bits) {
+	switch (bits) {
+		case 8: {
+			const i8Value = value << 24 >> 24;
+			return Math.abs(i8Value) & 255;
+		}
+		case 16: {
+			const i16Value = value << 16 >> 16;
+			return Math.abs(i16Value) & 65535;
+		}
+		case 32: {
+			const i32Value = value | 0;
+			if (i32Value === -2147483648) return 2147483648;
+			return Math.abs(i32Value) >>> 0;
+		}
+	}
+}
+/**
+* Converts a signed bigint to its unsigned magnitude for 64-bit values.
+*/
+function toMagnitude64(value) {
+	const mask = 18446744073709551615n;
+	if (value < 0n) return -value & mask;
+	return value & mask;
+}
+/**
+* Converts an unsigned magnitude back to a signed value.
+* Simply reinterprets the bits.
+*/
+function fromMagnitude(magnitude, bits) {
+	switch (bits) {
+		case 8: return magnitude << 24 >> 24;
+		case 16: return magnitude << 16 >> 16;
+		case 32: return magnitude | 0;
+	}
+}
+/**
+* Converts an unsigned 64-bit magnitude back to a signed bigint.
+*/
+function fromMagnitude64(magnitude) {
+	const mask = 18446744073709551615n;
+	const signBit = 1n << 63n;
+	const maskedMag = magnitude & mask;
+	if ((maskedMag & signBit) !== 0n) return maskedMag - (1n << 64n);
+	return maskedMag;
+}
+
+//#endregion
+//#region src/random-number-generator.ts
+/**
+* Returns a Uint8Array of random bytes of the given size.
+*/
+function rngRandomData(rng, size) {
+	const data = new Uint8Array(size);
+	rng.fillRandomData(data);
+	return data;
+}
+/**
+* Fills the given Uint8Array with random bytes.
+*/
+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.
+*/
+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;
+		while (m[0] < t) {
+			random = rng.nextU64() & bitmask;
+			m = wideMulU64(random, upperBound);
+		}
+	}
+	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).
+*/
+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;
+		while (Number(m[0]) < t) {
+			random = Number(rng.nextU64() & BigInt(bitmask));
+			m = wideMulU32(random, upperBoundU32);
+		}
+	}
+	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
+*/
+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;
+}
+/**
+* Returns a random value within the specified range [start, end).
+*
+* @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
+*/
+function rngNextInRange(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);
+}
+/**
+* Returns a random value within the specified closed range [start, end].
+*
+* @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
+*/
+function rngNextInClosedRange(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);
+}
+/**
+* Returns a random value within the specified closed range [start, end] for i32 values.
+* Convenience function that handles signed 32-bit integers.
+*
+* @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
+*/
+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;
+}
+/**
+* Returns a fixed-size array of random bytes.
+*
+* @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
+*/
+function rngRandomArray(rng, size) {
+	const data = new Uint8Array(size);
+	rng.fillRandomData(data);
+	return data;
+}
+/**
+* Returns a random boolean value.
+*
+* @param rng - The random number generator to use
+* @returns A random boolean
+*/
+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.
+*/
+function getCrypto() {
+	if (typeof globalThis !== "undefined" && globalThis.crypto !== null && globalThis.crypto !== void 0) return globalThis.crypto;
+	if (typeof globalThis.crypto !== "undefined") return globalThis.crypto;
+	throw new Error("No crypto API available in this environment");
+}
+/**
+* Generate a Uint8Array of cryptographically strong random bytes of the given size.
+*/
+function randomData(size) {
+	const data = new Uint8Array(size);
+	fillRandomData(data);
+	return data;
+}
+/**
+* Fill the given Uint8Array with cryptographically strong random bytes.
+*/
+function fillRandomData(data) {
+	getCrypto().getRandomValues(data);
+}
+/**
+* Returns the next cryptographically strong random 64-bit unsigned integer.
+*/
+function nextU64() {
+	const data = new Uint8Array(8);
+	fillRandomData(data);
+	return new DataView(data.buffer).getBigUint64(0, true);
+}
+/**
+* A random number generator that can be used as a source of
+* cryptographically-strong randomness.
+*
+* Uses the Web Crypto API (crypto.getRandomValues) which is available
+* in both browsers and Node.js >= 15.
+*/
+var SecureRandomNumberGenerator = class {
+	/**
+	* Returns the next random 32-bit unsigned integer.
+	*/
+	nextU32() {
+		const data = new Uint8Array(4);
+		fillRandomData(data);
+		return new DataView(data.buffer).getUint32(0, true) >>> 0;
+	}
+	/**
+	* Returns the next random 64-bit unsigned integer as a bigint.
+	*/
+	nextU64() {
+		return nextU64();
+	}
+	/**
+	* Fills the given Uint8Array with random bytes.
+	*/
+	fillBytes(dest) {
+		fillRandomData(dest);
+	}
+	/**
+	* Returns a Uint8Array of random bytes of the given size.
+	*/
+	randomData(size) {
+		return randomData(size);
+	}
+	/**
+	* Fills the given Uint8Array with random bytes.
+	*/
+	fillRandomData(data) {
+		fillRandomData(data);
+	}
+};
+
+//#endregion
+//#region src/seeded-random.ts
+/**
+* Rotate left for 64-bit bigint
+*/
+function rotl(x, k) {
+	return (x << BigInt(k) | x >> BigInt(64 - k)) & 18446744073709551615n;
+}
+/**
+* Xoshiro256** PRNG implementation
+* This is the same algorithm used by rand_xoshiro in Rust
+*/
+function xoshiro256StarStar(state) {
+	const mask = 18446744073709551615n;
+	const result = rotl(state.s1 * 5n & mask, 7) * 9n & mask;
+	const t = state.s1 << 17n & mask;
+	state.s2 ^= state.s0;
+	state.s3 ^= state.s1;
+	state.s1 ^= state.s2;
+	state.s0 ^= state.s3;
+	state.s2 ^= t;
+	state.s3 = rotl(state.s3, 45);
+	return result;
+}
+/**
+* A random number generator that can be used as a source of deterministic
+* pseudo-randomness for testing purposes.
+*
+* Uses the Xoshiro256** algorithm, which is the same algorithm used by
+* rand_xoshiro in Rust. This ensures cross-platform compatibility with
+* the Rust implementation.
+*
+* WARNING: This is NOT cryptographically secure and should only be used
+* for testing purposes.
+*/
+var SeededRandomNumberGenerator = class SeededRandomNumberGenerator {
+	state;
+	/**
+	* Creates a new seeded random number generator.
+	*
+	* The seed should be a 256-bit value, represented as an array of 4 64-bit
+	* integers (as bigints). For the output distribution to look random, the seed
+	* should not have any obvious patterns, like all zeroes or all ones.
+	*
+	* This is not cryptographically secure, and should only be used for
+	* testing purposes.
+	*
+	* @param seed - Array of 4 64-bit unsigned integers as bigints
+	*/
+	constructor(seed) {
+		this.state = {
+			s0: seed[0] & 18446744073709551615n,
+			s1: seed[1] & 18446744073709551615n,
+			s2: seed[2] & 18446744073709551615n,
+			s3: seed[3] & 18446744073709551615n
+		};
+	}
+	/**
+	* 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() {
+		return xoshiro256StarStar(this.state);
+	}
+	/**
+	* Returns the next random 32-bit unsigned integer.
+	*/
+	nextU32() {
+		return Number(this.nextU64() & 4294967295n) >>> 0;
+	}
+	/**
+	* Fills the given Uint8Array with random bytes.
+	*
+	* Note: This implementation matches the Rust behavior exactly -
+	* it uses one nextU64() call per byte (taking only the low byte),
+	* which matches the Swift version's behavior.
+	*/
+	fillBytes(dest) {
+		for (let i = 0; i < dest.length; i++) dest[i] = Number(this.nextU64() & 255n);
+	}
+	/**
+	* Returns a Uint8Array of random bytes of the given size.
+	*
+	* This might not be the most efficient implementation,
+	* but it works the same as the Swift version.
+	*/
+	randomData(size) {
+		const data = new Uint8Array(size);
+		for (let i = 0; i < size; i++) data[i] = Number(this.nextU64() & 255n);
+		return data;
+	}
+	/**
+	* Fills the given Uint8Array with random bytes.
+	*/
+	fillRandomData(data) {
+		this.fillBytes(data);
+	}
+};
+/**
+* The standard test seed used across all Blockchain Commons implementations.
+*/
+const TEST_SEED = [
+	17295166580085024720n,
+	422929670265678780n,
+	5577237070365765850n,
+	7953171132032326923n
+];
+/**
+* Creates a seeded random number generator with a fixed seed.
+* This is useful for reproducible testing across different platforms.
+*/
+function makeFakeRandomNumberGenerator() {
+	return new SeededRandomNumberGenerator(TEST_SEED);
+}
+/**
+* Creates a Uint8Array of random data with a fixed seed.
+* This is useful for reproducible testing.
+*
+* @param size - The number of bytes to generate
+* @returns A Uint8Array of pseudo-random bytes
+*/
+function fakeRandomData(size) {
+	return makeFakeRandomNumberGenerator().randomData(size);
+}
+
+//#endregion
+exports.SecureRandomNumberGenerator = SecureRandomNumberGenerator;
+exports.SeededRandomNumberGenerator = SeededRandomNumberGenerator;
+exports.TEST_SEED = TEST_SEED;
+exports.fakeRandomData = fakeRandomData;
+exports.fillRandomData = fillRandomData;
+exports.fromMagnitude = fromMagnitude;
+exports.fromMagnitude64 = fromMagnitude64;
+exports.makeFakeRandomNumberGenerator = makeFakeRandomNumberGenerator;
+exports.nextU64 = nextU64;
+exports.randomData = randomData;
+exports.rngFillRandomData = rngFillRandomData;
+exports.rngNextInClosedRange = rngNextInClosedRange;
+exports.rngNextInClosedRangeI32 = rngNextInClosedRangeI32;
+exports.rngNextInRange = rngNextInRange;
+exports.rngNextInRangeI32 = rngNextInRangeI32;
+exports.rngNextWithUpperBound = rngNextWithUpperBound;
+exports.rngNextWithUpperBoundU32 = rngNextWithUpperBoundU32;
+exports.rngRandomArray = rngRandomArray;
+exports.rngRandomBool = rngRandomBool;
+exports.rngRandomData = rngRandomData;
+exports.rngRandomU32 = rngRandomU32;
+exports.toMagnitude = toMagnitude;
+exports.toMagnitude64 = toMagnitude64;
+exports.wideMul = wideMul;
+exports.wideMulU16 = wideMulU16;
+exports.wideMulU32 = wideMulU32;
+exports.wideMulU64 = wideMulU64;
+exports.wideMulU8 = wideMulU8;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["TEST_SEED: [bigint, bigint, bigint, bigint]"],"sources":["../src/widening.ts","../src/magnitude.ts","../src/random-number-generator.ts","../src/secure-random.ts","../src/seeded-random.ts"],"sourcesContent":["// The below is so we don't have to use #![feature(bigint_helper_methods)]\n// Ported from bc-rand-rust/src/widening.rs\n\n/**\n * Wide multiplication result type - returns (low, high) parts.\n * For a multiplication of two N-bit values, the result is 2N bits\n * split into two N-bit parts.\n */\nexport type WideMulResult = [bigint, bigint];\n\n/**\n * Performs wide multiplication for unsigned integers.\n * Returns (low, high) parts of the full-width result.\n *\n * This is equivalent to Rust's widening_mul for unsigned types.\n */\nexport function wideMul(a: bigint, b: bigint, bits: number): WideMulResult {\n  const mask = (1n << BigInt(bits)) - 1n;\n  const wide = (a & mask) * (b & mask);\n  const low = wide & mask;\n  const high = wide >> BigInt(bits);\n  return [low, high];\n}\n\n/**\n * Wide multiplication for 8-bit unsigned integers.\n * @param a - First 8-bit value\n * @param b - Second 8-bit value\n * @returns Tuple of (low 8 bits, high 8 bits)\n */\nexport function wideMulU8(a: number, b: number): [number, number] {\n  const wide = (a & 0xff) * (b & 0xff);\n  return [wide & 0xff, (wide >> 8) & 0xff];\n}\n\n/**\n * Wide multiplication for 16-bit unsigned integers.\n * @param a - First 16-bit value\n * @param b - Second 16-bit value\n * @returns Tuple of (low 16 bits, high 16 bits)\n */\nexport function wideMulU16(a: number, b: number): [number, number] {\n  const wide = (a & 0xffff) * (b & 0xffff);\n  return [wide & 0xffff, (wide >>> 16) & 0xffff];\n}\n\n/**\n * Wide multiplication for 32-bit unsigned integers.\n * @param a - First 32-bit value\n * @param b - Second 32-bit value\n * @returns Tuple of (low 32 bits, high 32 bits) as bigints\n */\nexport function wideMulU32(a: number, b: number): [bigint, bigint] {\n  const aBig = BigInt(a >>> 0);\n  const bBig = BigInt(b >>> 0);\n  const wide = aBig * bBig;\n  return [wide & 0xffffffffn, wide >> 32n];\n}\n\n/**\n * Wide multiplication for 64-bit unsigned integers.\n * @param a - First 64-bit value as bigint\n * @param b - Second 64-bit value as bigint\n * @returns Tuple of (low 64 bits, high 64 bits) as bigints\n */\nexport function wideMulU64(a: bigint, b: bigint): [bigint, bigint] {\n  const mask64 = 0xffffffffffffffffn;\n  const wide = (a & mask64) * (b & mask64);\n  return [wide & mask64, wide >> 64n];\n}\n","// Ported from bc-rand-rust/src/magnitude.rs\n\n/**\n * Converts a signed integer to its unsigned magnitude.\n * For positive numbers, returns the number unchanged.\n * For negative numbers, returns the absolute value (wrapping for MIN values).\n *\n * This matches Rust's wrapping_abs() behavior.\n */\nexport function toMagnitude(value: number, bits: 8 | 16 | 32): number {\n  switch (bits) {\n    case 8: {\n      // i8 to u8: wrapping_abs\n      const i8Value = (value << 24) >> 24; // Sign extend to i8\n      return Math.abs(i8Value) & 0xff;\n    }\n    case 16: {\n      // i16 to u16: wrapping_abs\n      const i16Value = (value << 16) >> 16; // Sign extend to i16\n      return Math.abs(i16Value) & 0xffff;\n    }\n    case 32: {\n      // i32 to u32: wrapping_abs\n      const i32Value = value | 0; // Force to i32\n      // Handle MIN_VALUE specially (wrapping behavior)\n      if (i32Value === -2147483648) {\n        return 2147483648; // Returns as positive\n      }\n      return Math.abs(i32Value) >>> 0; // Convert to unsigned\n    }\n  }\n}\n\n/**\n * Converts a signed bigint to its unsigned magnitude for 64-bit values.\n */\nexport function toMagnitude64(value: bigint): bigint {\n  const mask = 0xffffffffffffffffn;\n  // Handle negative values\n  if (value < 0n) {\n    // Wrapping absolute value\n    const absValue = -value;\n    return absValue & mask;\n  }\n  return value & mask;\n}\n\n/**\n * Converts an unsigned magnitude back to a signed value.\n * Simply reinterprets the bits.\n */\nexport function fromMagnitude(magnitude: number, bits: 8 | 16 | 32): number {\n  switch (bits) {\n    case 8:\n      return (magnitude << 24) >> 24; // Sign extend from u8 to i8\n    case 16:\n      return (magnitude << 16) >> 16; // Sign extend from u16 to i16\n    case 32:\n      return magnitude | 0; // Reinterpret as i32\n  }\n}\n\n/**\n * Converts an unsigned 64-bit magnitude back to a signed bigint.\n */\nexport function fromMagnitude64(magnitude: bigint): bigint {\n  const mask = 0xffffffffffffffffn;\n  const signBit = 1n << 63n;\n  const maskedMag = magnitude & mask;\n  if ((maskedMag & signBit) !== 0n) {\n    // Negative value - convert from two's complement\n    return maskedMag - (1n << 64n);\n  }\n  return maskedMag;\n}\n","// Ported from bc-rand-rust/src/random_number_generator.rs\n\nimport { wideMulU32, wideMulU64 } from \"./widening.js\";\nimport {\n  toMagnitude,\n  toMagnitude64 as _toMagnitude64,\n  fromMagnitude as _fromMagnitude,\n  fromMagnitude64 as _fromMagnitude64,\n} from \"./magnitude.js\";\n\n/**\n * Interface for random number generators.\n * This is the TypeScript equivalent of Rust's RandomNumberGenerator trait\n * which extends RngCore + CryptoRng.\n *\n * This is compatible with the RandomNumberGenerator Swift protocol used\n * in MacOS and iOS, which is important for cross-platform testing.\n */\nexport interface RandomNumberGenerator {\n  /**\n   * Returns the next random 32-bit unsigned integer.\n   */\n  nextU32(): number;\n\n  /**\n   * Returns the next random 64-bit unsigned integer as a bigint.\n   */\n  nextU64(): bigint;\n\n  /**\n   * Fills the given Uint8Array with random bytes.\n   */\n  fillBytes(dest: Uint8Array): void;\n\n  /**\n   * Returns a Uint8Array of random bytes of the given size.\n   */\n  randomData(size: number): Uint8Array;\n\n  /**\n   * Fills the given Uint8Array with random bytes.\n   * Alias for fillBytes for compatibility.\n   */\n  fillRandomData(data: Uint8Array): void;\n}\n\n/**\n * Returns a Uint8Array of random bytes of the given size.\n */\nexport function rngRandomData(rng: RandomNumberGenerator, size: number): Uint8Array {\n  const data = new Uint8Array(size);\n  rng.fillRandomData(data);\n  return data;\n}\n\n/**\n * Fills the given Uint8Array with random bytes.\n */\nexport function rngFillRandomData(rng: RandomNumberGenerator, data: Uint8Array): void {\n  rng.fillRandomData(data);\n}\n\n/**\n * Returns a random value that is less than the given upper bound.\n *\n * Uses Lemire's \"nearly divisionless\" method for generating random\n * integers in an interval. For a detailed explanation, see:\n * https://arxiv.org/abs/1805.10941\n *\n * @param rng - The random number generator to use\n * @param upperBound - The upper bound for the randomly generated value. Must be non-zero.\n * @returns A random value in the range [0, upperBound). Every value in the range is equally likely.\n */\nexport function rngNextWithUpperBound(rng: RandomNumberGenerator, upperBound: bigint): bigint {\n  if (upperBound === 0n) {\n    throw new Error(\"upperBound must be non-zero\");\n  }\n\n  // We use Lemire's \"nearly divisionless\" method for generating random\n  // integers in an interval. For a detailed explanation, see:\n  // https://arxiv.org/abs/1805.10941\n\n  const bitmask = 0xffffffffffffffffn; // u64 max\n  let random = rng.nextU64() & bitmask;\n  let m = wideMulU64(random, upperBound);\n\n  if (m[0] < upperBound) {\n    // t = (0 - upperBound) % upperBound\n    const negUpperBound = (bitmask + 1n - upperBound) & bitmask;\n    const t = negUpperBound % upperBound;\n    while (m[0] < t) {\n      random = rng.nextU64() & bitmask;\n      m = wideMulU64(random, upperBound);\n    }\n  }\n\n  return m[1];\n}\n\n/**\n * Returns a random 32-bit value that is less than the given upper bound.\n * This matches Rust's behavior when called with u32 type.\n *\n * Uses Lemire's \"nearly divisionless\" method with 32-bit arithmetic.\n *\n * @param rng - The random number generator to use\n * @param upperBound - The upper bound for the randomly generated value. Must be non-zero and fit in u32.\n * @returns A random u32 value in the range [0, upperBound).\n */\nexport function rngNextWithUpperBoundU32(rng: RandomNumberGenerator, upperBound: number): number {\n  if (upperBound === 0) {\n    throw new Error(\"upperBound must be non-zero\");\n  }\n\n  const upperBoundU32 = upperBound >>> 0;\n  const bitmask = 0xffffffff;\n\n  // Get random and mask to 32 bits (matches Rust behavior)\n  let random = Number(rng.nextU64() & BigInt(bitmask));\n  let m = wideMulU32(random, upperBoundU32);\n\n  if (Number(m[0]) < upperBoundU32) {\n    // t = (0 - upperBound) % upperBound (wrapping subtraction)\n    const t = ((bitmask + 1 - upperBoundU32) >>> 0) % upperBoundU32;\n    while (Number(m[0]) < t) {\n      random = Number(rng.nextU64() & BigInt(bitmask));\n      m = wideMulU32(random, upperBoundU32);\n    }\n  }\n\n  return Number(m[1]);\n}\n\n/**\n * Returns a random value within the specified range [start, end) using 32-bit arithmetic.\n * This matches Rust's behavior when called with i32 types.\n *\n * @param rng - The random number generator to use\n * @param start - The lower bound (inclusive) as i32\n * @param end - The upper bound (exclusive) as i32\n * @returns A random i32 value within the bounds\n */\nexport function rngNextInRangeI32(rng: RandomNumberGenerator, start: number, end: number): number {\n  if (start >= end) {\n    throw new Error(\"start must be less than end\");\n  }\n\n  const startI32 = start | 0;\n  const endI32 = end | 0;\n  const delta = toMagnitude(endI32 - startI32, 32);\n\n  if (delta === 0xffffffff) {\n    return rng.nextU32() | 0;\n  }\n\n  const random = rngNextWithUpperBoundU32(rng, delta);\n  return (startI32 + random) | 0;\n}\n\n/**\n * Returns a random value within the specified range [start, end).\n *\n * @param rng - The random number generator to use\n * @param start - The lower bound (inclusive)\n * @param end - The upper bound (exclusive)\n * @returns A random value within the bounds of the range\n */\nexport function rngNextInRange(rng: RandomNumberGenerator, start: bigint, end: bigint): bigint {\n  if (start >= end) {\n    throw new Error(\"start must be less than end\");\n  }\n\n  const delta = end - start;\n\n  // If delta covers the entire range, just return a random value\n  const maxU64 = 0xffffffffffffffffn;\n  if (delta === maxU64) {\n    return rng.nextU64();\n  }\n\n  const random = rngNextWithUpperBound(rng, delta);\n  return start + random;\n}\n\n/**\n * Returns a random value within the specified closed range [start, end].\n *\n * @param rng - The random number generator to use\n * @param start - The lower bound (inclusive)\n * @param end - The upper bound (inclusive)\n * @returns A random value within the bounds of the range\n */\nexport function rngNextInClosedRange(\n  rng: RandomNumberGenerator,\n  start: bigint,\n  end: bigint,\n): bigint {\n  if (start > end) {\n    throw new Error(\"start must be less than or equal to end\");\n  }\n\n  const delta = end - start;\n\n  // If delta covers the entire range, just return a random value\n  const maxU64 = 0xffffffffffffffffn;\n  if (delta === maxU64) {\n    return rng.nextU64();\n  }\n\n  const random = rngNextWithUpperBound(rng, delta + 1n);\n  return start + random;\n}\n\n/**\n * Returns a random value within the specified closed range [start, end] for i32 values.\n * Convenience function that handles signed 32-bit integers.\n *\n * @param rng - The random number generator to use\n * @param start - The lower bound (inclusive) as i32\n * @param end - The upper bound (inclusive) as i32\n * @returns A random i32 value within the bounds of the range\n */\nexport function rngNextInClosedRangeI32(\n  rng: RandomNumberGenerator,\n  start: number,\n  end: number,\n): number {\n  if (start > end) {\n    throw new Error(\"start must be less than or equal to end\");\n  }\n\n  // Convert to i32\n  const startI32 = start | 0;\n  const endI32 = end | 0;\n\n  // Calculate delta as u32 magnitude\n  const delta = toMagnitude(endI32 - startI32, 32);\n\n  // If delta covers the entire u32 range, just return a random value\n  if (delta === 0xffffffff) {\n    return rng.nextU32() | 0;\n  }\n\n  const random = rngNextWithUpperBoundU32(rng, delta + 1);\n  return (startI32 + random) | 0;\n}\n\n/**\n * Returns a fixed-size array of random bytes.\n *\n * @param rng - The random number generator to use\n * @param size - The size of the array to return\n * @returns A Uint8Array of the specified size filled with random bytes\n */\nexport function rngRandomArray(rng: RandomNumberGenerator, size: number): Uint8Array {\n  const data = new Uint8Array(size);\n  rng.fillRandomData(data);\n  return data;\n}\n\n/**\n * Returns a random boolean value.\n *\n * @param rng - The random number generator to use\n * @returns A random boolean\n */\nexport function rngRandomBool(rng: RandomNumberGenerator): boolean {\n  return (rng.nextU32() & 1) === 0;\n}\n\n/**\n * Returns a random 32-bit unsigned integer.\n *\n * @param rng - The random number generator to use\n * @returns A random u32 value\n */\nexport function rngRandomU32(rng: RandomNumberGenerator): number {\n  return rng.nextU32();\n}\n","// Ported from bc-rand-rust/src/secure_random.rs\n\nimport type { RandomNumberGenerator } from \"./random-number-generator.js\";\n\n/**\n * Detects the crypto API available in the current environment.\n * Works in both Node.js and browser environments.\n */\nfunction getCrypto(): Crypto {\n  // Browser environment\n  if (\n    typeof globalThis !== \"undefined\" &&\n    globalThis.crypto !== null &&\n    globalThis.crypto !== undefined\n  ) {\n    return globalThis.crypto;\n  }\n  // Node.js environment - globalThis.crypto is also available in Node.js >= 15\n  if (typeof globalThis.crypto !== \"undefined\") {\n    return globalThis.crypto;\n  }\n  throw new Error(\"No crypto API available in this environment\");\n}\n\n/**\n * Generate a Uint8Array of cryptographically strong random bytes of the given size.\n */\nexport function randomData(size: number): Uint8Array {\n  const data = new Uint8Array(size);\n  fillRandomData(data);\n  return data;\n}\n\n/**\n * Fill the given Uint8Array with cryptographically strong random bytes.\n */\nexport function fillRandomData(data: Uint8Array): void {\n  const crypto = getCrypto();\n  crypto.getRandomValues(data);\n}\n\n/**\n * Returns the next cryptographically strong random 64-bit unsigned integer.\n */\nexport function nextU64(): bigint {\n  const data = new Uint8Array(8);\n  fillRandomData(data);\n  const view = new DataView(data.buffer);\n  return view.getBigUint64(0, true); // little-endian\n}\n\n/**\n * A random number generator that can be used as a source of\n * cryptographically-strong randomness.\n *\n * Uses the Web Crypto API (crypto.getRandomValues) which is available\n * in both browsers and Node.js >= 15.\n */\nexport class SecureRandomNumberGenerator implements RandomNumberGenerator {\n  /**\n   * Returns the next random 32-bit unsigned integer.\n   */\n  nextU32(): number {\n    const data = new Uint8Array(4);\n    fillRandomData(data);\n    const view = new DataView(data.buffer);\n    return view.getUint32(0, true) >>> 0; // little-endian, unsigned\n  }\n\n  /**\n   * Returns the next random 64-bit unsigned integer as a bigint.\n   */\n  nextU64(): bigint {\n    return nextU64();\n  }\n\n  /**\n   * Fills the given Uint8Array with random bytes.\n   */\n  fillBytes(dest: Uint8Array): void {\n    fillRandomData(dest);\n  }\n\n  /**\n   * Returns a Uint8Array of random bytes of the given size.\n   */\n  randomData(size: number): Uint8Array {\n    return randomData(size);\n  }\n\n  /**\n   * Fills the given Uint8Array with random bytes.\n   */\n  fillRandomData(data: Uint8Array): void {\n    fillRandomData(data);\n  }\n}\n","// Ported from bc-rand-rust/src/seeded_random.rs\n\nimport type { RandomNumberGenerator } from \"./random-number-generator.js\";\n\n/**\n * Xoshiro256** state\n * Based on xoshiro256** 1.0 by David Blackman and Sebastiano Vigna\n * https://prng.di.unimi.it/\n */\ninterface Xoshiro256State {\n  s0: bigint;\n  s1: bigint;\n  s2: bigint;\n  s3: bigint;\n}\n\n/**\n * Rotate left for 64-bit bigint\n */\nfunction rotl(x: bigint, k: number): bigint {\n  const mask = 0xffffffffffffffffn;\n  return ((x << BigInt(k)) | (x >> BigInt(64 - k))) & mask;\n}\n\n/**\n * Xoshiro256** PRNG implementation\n * This is the same algorithm used by rand_xoshiro in Rust\n */\nfunction xoshiro256StarStar(state: Xoshiro256State): bigint {\n  const mask = 0xffffffffffffffffn;\n\n  // result = rotl(s1 * 5, 7) * 9\n  const result = (rotl((state.s1 * 5n) & mask, 7) * 9n) & mask;\n\n  // t = s1 << 17\n  const t = (state.s1 << 17n) & mask;\n\n  // Update state\n  state.s2 ^= state.s0;\n  state.s3 ^= state.s1;\n  state.s1 ^= state.s2;\n  state.s0 ^= state.s3;\n\n  state.s2 ^= t;\n  state.s3 = rotl(state.s3, 45);\n\n  return result;\n}\n\n/**\n * A random number generator that can be used as a source of deterministic\n * pseudo-randomness for testing purposes.\n *\n * Uses the Xoshiro256** algorithm, which is the same algorithm used by\n * rand_xoshiro in Rust. This ensures cross-platform compatibility with\n * the Rust implementation.\n *\n * WARNING: This is NOT cryptographically secure and should only be used\n * for testing purposes.\n */\nexport class SeededRandomNumberGenerator implements RandomNumberGenerator {\n  private readonly state: Xoshiro256State;\n\n  /**\n   * Creates a new seeded random number generator.\n   *\n   * The seed should be a 256-bit value, represented as an array of 4 64-bit\n   * integers (as bigints). For the output distribution to look random, the seed\n   * should not have any obvious patterns, like all zeroes or all ones.\n   *\n   * This is not cryptographically secure, and should only be used for\n   * testing purposes.\n   *\n   * @param seed - Array of 4 64-bit unsigned integers as bigints\n   */\n  constructor(seed: [bigint, bigint, bigint, bigint]) {\n    this.state = {\n      s0: seed[0] & 0xffffffffffffffffn,\n      s1: seed[1] & 0xffffffffffffffffn,\n      s2: seed[2] & 0xffffffffffffffffn,\n      s3: seed[3] & 0xffffffffffffffffn,\n    };\n  }\n\n  /**\n   * Creates a new seeded random number generator from a seed array.\n   * Convenience method that accepts numbers and converts to bigints.\n   *\n   * @param seed - Array of 4 64-bit unsigned integers\n   */\n  static fromSeed(seed: [bigint, bigint, bigint, bigint]): SeededRandomNumberGenerator {\n    return new SeededRandomNumberGenerator(seed);\n  }\n\n  /**\n   * Returns the next random 64-bit unsigned integer as a bigint.\n   */\n  nextU64(): bigint {\n    return xoshiro256StarStar(this.state);\n  }\n\n  /**\n   * Returns the next random 32-bit unsigned integer.\n   */\n  nextU32(): number {\n    return Number(this.nextU64() & 0xffffffffn) >>> 0;\n  }\n\n  /**\n   * Fills the given Uint8Array with random bytes.\n   *\n   * Note: This implementation matches the Rust behavior exactly -\n   * it uses one nextU64() call per byte (taking only the low byte),\n   * which matches the Swift version's behavior.\n   */\n  fillBytes(dest: Uint8Array): void {\n    for (let i = 0; i < dest.length; i++) {\n      dest[i] = Number(this.nextU64() & 0xffn);\n    }\n  }\n\n  /**\n   * Returns a Uint8Array of random bytes of the given size.\n   *\n   * This might not be the most efficient implementation,\n   * but it works the same as the Swift version.\n   */\n  randomData(size: number): Uint8Array {\n    const data = new Uint8Array(size);\n    for (let i = 0; i < size; i++) {\n      data[i] = Number(this.nextU64() & 0xffn);\n    }\n    return data;\n  }\n\n  /**\n   * Fills the given Uint8Array with random bytes.\n   */\n  fillRandomData(data: Uint8Array): void {\n    this.fillBytes(data);\n  }\n}\n\n/**\n * The standard test seed used across all Blockchain Commons implementations.\n */\nexport const TEST_SEED: [bigint, bigint, bigint, bigint] = [\n  17295166580085024720n,\n  422929670265678780n,\n  5577237070365765850n,\n  7953171132032326923n,\n];\n\n/**\n * Creates a seeded random number generator with a fixed seed.\n * This is useful for reproducible testing across different platforms.\n */\nexport function makeFakeRandomNumberGenerator(): SeededRandomNumberGenerator {\n  return new SeededRandomNumberGenerator(TEST_SEED);\n}\n\n/**\n * Creates a Uint8Array of random data with a fixed seed.\n * This is useful for reproducible testing.\n *\n * @param size - The number of bytes to generate\n * @returns A Uint8Array of pseudo-random bytes\n */\nexport function fakeRandomData(size: number): Uint8Array {\n  return makeFakeRandomNumberGenerator().randomData(size);\n}\n"],"mappings":"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"}