@pezkuwi/util 14.0.1 → 14.0.4

package/bn/index.js

@@ -0,0 +1,11 @@
+/**
+ * @summary Utility methods to convert to and from `BN` objects
+ */
+export { BN } from './bn.js';
+export { bnFromHex } from './fromHex.js';
+export { bnMax, bnMin } from './min.js';
+export { bnSqrt } from './sqrt.js';
+export { bnToBn } from './toBn.js';
+export { bnToHex } from './toHex.js';
+export { bnToU8a } from './toU8a.js';
+export * from './consts.js';

package/bn/min.d.ts

@@ -0,0 +1,29 @@
+import type { BN } from './bn.js';
+/**
+ * @name bnMax
+ * @summary Finds and returns the highest value in an array of BNs.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { bnMax } from '@polkadot/util';
+ *
+ * bnMax([new BN(1), new BN(3), new BN(2)]).toString(); // => '3'
+ * ```
+ */
+export declare const bnMax: (...items: BN[]) => BN;
+/**
+ * @name bnMin
+ * @summary Finds and returns the smallest value in an array of BNs.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { bnMin } from '@polkadot/util';
+ *
+ * bnMin([new BN(1), new BN(3), new BN(2)]).toString(); // => '1'
+ * ```
+ */
+export declare const bnMin: (...items: BN[]) => BN;

package/{src/bn/min.ts → bn/min.js}

@@ -1,10 +1,4 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { BN } from './bn.js';
-
 import { createCmp } from '../bi/helpers.js';
-
 /**
  * @name bnMax
  * @summary Finds and returns the highest value in an array of BNs.
@@ -18,8 +12,7 @@ import { createCmp } from '../bi/helpers.js';
  * bnMax([new BN(1), new BN(3), new BN(2)]).toString(); // => '3'
  * ```
  */
-export const bnMax = /*#__PURE__*/ createCmp<BN>((a, b) => a.gt(b));
-
+export const bnMax = /*#__PURE__*/ createCmp((a, b) => a.gt(b));
 /**
  * @name bnMin
  * @summary Finds and returns the smallest value in an array of BNs.
@@ -33,4 +26,4 @@ export const bnMax = /*#__PURE__*/ createCmp<BN>((a, b) => a.gt(b));
  * bnMin([new BN(1), new BN(3), new BN(2)]).toString(); // => '1'
  * ```
  */
-export const bnMin = /*#__PURE__*/ createCmp<BN>((a, b) => a.lt(b));
+export const bnMin = /*#__PURE__*/ createCmp((a, b) => a.lt(b));

package/bn/sqrt.d.ts

@@ -0,0 +1,16 @@
+import type { ToBn } from '../types.js';
+import { BN } from './bn.js';
+/**
+ * @name bnSqrt
+ * @summary Calculates the integer square root of a BN
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { bnSqrt } from '@polkadot/util';
+ *
+ * bnSqrt(new BN(16)).toString(); // => '4'
+ * ```
+ */
+export declare function bnSqrt<ExtToBn extends ToBn>(value: ExtToBn | BN | bigint | string | number | null): BN;

package/bn/sqrt.js

@@ -0,0 +1,38 @@
+import { BN } from './bn.js';
+import { BN_MAX_INTEGER, BN_ONE, BN_SQRT_MAX_INTEGER } from './consts.js';
+import { bnToBn } from './toBn.js';
+/**
+ * @name bnSqrt
+ * @summary Calculates the integer square root of a BN
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { bnSqrt } from '@pezkuwi/util';
+ *
+ * bnSqrt(new BN(16)).toString(); // => '4'
+ * ```
+ */
+export function bnSqrt(value) {
+    const n = bnToBn(value);
+    if (n.isNeg()) {
+        throw new Error('square root of negative numbers is not supported');
+    }
+    // https://stackoverflow.com/questions/53683995/javascript-big-integer-square-root/
+    // shortcut <= 2^53 - 1 to use the JS utils
+    if (n.lte(BN_MAX_INTEGER)) {
+        // ~~ More performant version of Math.floor
+        return new BN(~~Math.sqrt(n.toNumber()));
+    }
+    // Use sqrt(MAX_SAFE_INTEGER) as starting point. since we already know the
+    // output will be larger than this, we expect this to be a safe start
+    let x0 = BN_SQRT_MAX_INTEGER.clone();
+    while (true) {
+        const x1 = n.div(x0).iadd(x0).ishrn(1);
+        if (x0.eq(x1) || x0.eq(x1.sub(BN_ONE))) {
+            return x0;
+        }
+        x0 = x1;
+    }
+}

package/bn/toBn.d.ts

@@ -0,0 +1,19 @@
+import type { ToBigInt, ToBn } from '../types.js';
+import { BN } from './bn.js';
+/**
+ * @name bnToBn
+ * @summary Creates a BN value from a BN, bigint, string (base 10 or hex) or number input.
+ * @description
+ * `null` inputs returns a `0x0` result, BN values returns the value, numbers returns a BN representation.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { bnToBn } from '@polkadot/util';
+ *
+ * bnToBn(0x1234); // => BN(0x1234)
+ * bnToBn(new BN(0x1234)); // => BN(0x1234)
+ * ```
+ */
+export declare function bnToBn<ExtToBn extends ToBigInt | ToBn>(value?: ExtToBn | BN | bigint | string | number | null): BN;

package/{src/bn/toBn.ts → bn/toBn.js}

@@ -1,15 +1,9 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { ToBigInt, ToBn } from '../types.js';
-
 import { hexToBn } from '../hex/toBn.js';
 import { isBigInt } from '../is/bigInt.js';
 import { isHex } from '../is/hex.js';
 import { isToBigInt } from '../is/toBigInt.js';
 import { isToBn } from '../is/toBn.js';
 import { BN } from './bn.js';
-
 /**
  * @name bnToBn
  * @summary Creates a BN value from a BN, bigint, string (base 10 or hex) or number input.
@@ -26,18 +20,18 @@ import { BN } from './bn.js';
  * bnToBn(new BN(0x1234)); // => BN(0x1234)
  * ```
  */
-export function bnToBn <ExtToBn extends ToBigInt | ToBn> (value?: ExtToBn | BN | bigint | string | number | null): BN {
-  return value
-    ? BN.isBN(value)
-      ? value
-      : isHex(value)
-        ? hexToBn(value.toString())
-        : isBigInt(value)
-          ? new BN(value.toString())
-          : isToBn(value)
-            ? value.toBn()
-            : isToBigInt(value)
-              ? new BN(value.toBigInt().toString())
-              : new BN(value)
-    : new BN(0);
+export function bnToBn(value) {
+    return value
+        ? BN.isBN(value)
+            ? value
+            : isHex(value)
+                ? hexToBn(value.toString())
+                : isBigInt(value)
+                    ? new BN(value.toString())
+                    : isToBn(value)
+                        ? value.toBn()
+                        : isToBigInt(value)
+                            ? new BN(value.toBigInt().toString())
+                            : new BN(value)
+        : new BN(0);
 }

package/bn/toHex.d.ts

@@ -0,0 +1,18 @@
+import type { HexString, NumberOptions, ToBn } from '../types.js';
+import type { BN } from './bn.js';
+/**
+ * @name bnToHex
+ * @summary Creates a hex value from a BN.js bignumber object.
+ * @description
+ * `null` inputs returns a `0x` result, BN values return the actual value as a `0x` prefixed hex value. Anything that is not a BN object throws an error. With `bitLength` set, it fixes the number to the specified length.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { bnToHex } from '@polkadot/util';
+ *
+ * bnToHex(new BN(0x123456)); // => '0x123456'
+ * ```
+ */
+export declare function bnToHex<ExtToBn extends ToBn>(value?: ExtToBn | BN | bigint | number | null, { bitLength, isLe, isNegative }?: NumberOptions): HexString;

package/{src/bn/toHex.ts → bn/toHex.js}

@@ -1,12 +1,5 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { HexString, NumberOptions, ToBn } from '../types.js';
-import type { BN } from './bn.js';
-
 import { u8aToHex } from '../u8a/index.js';
 import { bnToU8a } from './toU8a.js';
-
 /**
  * @name bnToHex
  * @summary Creates a hex value from a BN.js bignumber object.
@@ -22,6 +15,6 @@ import { bnToU8a } from './toU8a.js';
  * bnToHex(new BN(0x123456)); // => '0x123456'
  * ```
  */
-export function bnToHex <ExtToBn extends ToBn> (value?: ExtToBn | BN | bigint | number | null, { bitLength = -1, isLe = false, isNegative = false }: NumberOptions = {}): HexString {
-  return u8aToHex(bnToU8a(value, { bitLength, isLe, isNegative }));
+export function bnToHex(value, { bitLength = -1, isLe = false, isNegative = false } = {}) {
+    return u8aToHex(bnToU8a(value, { bitLength, isLe, isNegative }));
 }

package/bn/toU8a.d.ts

@@ -0,0 +1,17 @@
+import type { NumberOptions, ToBn } from '../types.js';
+import type { BN } from './bn.js';
+/**
+ * @name bnToU8a
+ * @summary Creates a Uint8Array object from a BN.
+ * @description
+ * `null`/`undefined`/`NaN` inputs returns an empty `Uint8Array` result. `BN` input values return the actual bytes value converted to a `Uint8Array`. Optionally convert using little-endian format if `isLE` is set.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { bnToU8a } from '@polkadot/util';
+ *
+ * bnToU8a(new BN(0x1234)); // => [0x12, 0x34]
+ * ```
+ */
+export declare function bnToU8a<ExtToBn extends ToBn>(value?: ExtToBn | BN | bigint | number | null, { bitLength, isLe, isNegative }?: NumberOptions): Uint8Array;

package/bn/toU8a.js

@@ -0,0 +1,33 @@
+import { bnToBn } from './toBn.js';
+const DEFAULT_OPTS = { bitLength: -1, isLe: true, isNegative: false };
+/**
+ * @name bnToU8a
+ * @summary Creates a Uint8Array object from a BN.
+ * @description
+ * `null`/`undefined`/`NaN` inputs returns an empty `Uint8Array` result. `BN` input values return the actual bytes value converted to a `Uint8Array`. Optionally convert using little-endian format if `isLE` is set.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { bnToU8a } from '@pezkuwi/util';
+ *
+ * bnToU8a(new BN(0x1234)); // => [0x12, 0x34]
+ * ```
+ */
+export function bnToU8a(value, { bitLength = -1, isLe = true, isNegative = false } = DEFAULT_OPTS) {
+    const valueBn = bnToBn(value);
+    const byteLength = bitLength === -1
+        ? Math.ceil(valueBn.bitLength() / 8)
+        : Math.ceil((bitLength || 0) / 8);
+    if (!value) {
+        return bitLength === -1
+            ? new Uint8Array(1)
+            : new Uint8Array(byteLength);
+    }
+    const output = new Uint8Array(byteLength);
+    const bn = isNegative
+        ? valueBn.toTwos(byteLength * 8)
+        : valueBn;
+    output.set(bn.toArray(isLe ? 'le' : 'be', byteLength), 0);
+    return output;
+}

package/{src/buffer/index.ts → buffer/index.d.ts}

@@ -1,8 +1,4 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 /**
  * @summary Utility methods to convert to and from `Buffer` objects
  */
-
 export { bufferToU8a } from './toU8a.js';

package/buffer/index.js

@@ -0,0 +1,4 @@
+/**
+ * @summary Utility methods to convert to and from `Buffer` objects
+ */
+export { bufferToU8a } from './toU8a.js';

package/buffer/toU8a.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name bufferToU8a
+ * @summary Creates a Uint8Array value from a Buffer object.
+ * @description
+ * `null` inputs returns an empty result, `Buffer` values return the actual value as a `Uint8Array`. Anything that is not a `Buffer` object throws an error.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { bufferToU8a } from '@polkadot/util';
+ *
+ * bufferToU8a(Buffer.from([1, 2, 3]));
+ * ```
+ */
+export declare function bufferToU8a(buffer?: Uint8Array | number[] | null): Uint8Array;

package/{src/buffer/toU8a.ts → buffer/toU8a.js}

@@ -1,6 +1,3 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 /**
  * @name bufferToU8a
  * @summary Creates a Uint8Array value from a Buffer object.
@@ -15,6 +12,6 @@
  * bufferToU8a(Buffer.from([1, 2, 3]));
  * ```
  */
-export function bufferToU8a (buffer?: Uint8Array | number[] | null): Uint8Array {
-  return new Uint8Array(buffer || []);
+export function bufferToU8a(buffer) {
+    return new Uint8Array(buffer || []);
 }