@pezkuwi/util 14.0.1 → 14.0.3

package/src/bn/toBn.spec.ts

@@ -1,53 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { BN, bnToBn } from './index.js';
-
-describe('bnToBn', (): void => {
-  it('converts null values to 0x00', (): void => {
-    expect(
-      bnToBn(null).toNumber()
-    ).toEqual(0);
-  });
-
-  it('converts BN values to BN', (): void => {
-    expect(
-      bnToBn(new BN(128)).toNumber()
-    ).toEqual(128);
-  });
-
-  it('converts BigInt values to BN', (): void => {
-    expect(
-      bnToBn(128821n).toNumber()
-    ).toEqual(128821);
-  });
-
-  it('converts number values to BN', (): void => {
-    expect(
-      bnToBn(128).toNumber()
-    ).toEqual(128);
-  });
-
-  it('converts string to BN', (): void => {
-    expect(
-      bnToBn('123').toNumber()
-    ).toEqual(123);
-  });
-
-  it('converts hex to BN', (): void => {
-    expect(
-      bnToBn('0x0123').toNumber()
-    ).toEqual(0x123);
-  });
-
-  it('converts Compact to BN', (): void => {
-    expect(
-      bnToBn({
-        something: 'test',
-        toBn: (): BN => new BN(1234)
-      }).toNumber()
-    ).toEqual(1234);
-  });
-});

package/src/bn/toHex.spec.ts

@@ -1,50 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { BN, bnToHex } from './index.js';
-
-describe('bnToHex', (): void => {
-  it('converts null values to 0x00', (): void => {
-    expect(
-      bnToHex(null)
-    ).toBe('0x00');
-  });
-
-  it('converts null values to 0x00000000 (with bitLength)', (): void => {
-    expect(
-      bnToHex(null, { bitLength: 32 })
-    ).toBe('0x00000000');
-  });
-
-  it('converts BN values to a prefixed hex representation', (): void => {
-    expect(
-      bnToHex(new BN(128))
-    ).toBe('0x80');
-  });
-
-  it('converts BN values to a prefixed hex representation (bitLength)', (): void => {
-    expect(
-      bnToHex(new BN(128), { bitLength: 16 })
-    ).toBe('0x0080');
-  });
-
-  it('converts BN values to a prefixed hex representation (LE)', (): void => {
-    expect(
-      bnToHex(new BN(128), { bitLength: 16, isLe: true })
-    ).toBe('0x8000');
-  });
-
-  it('handles negative numbers', (): void => {
-    expect(
-      bnToHex(new BN(-1234), { isNegative: true })
-    ).toBe('0xfb2e');
-  });
-
-  it('handles negative numbers (with bitLength)', (): void => {
-    expect(
-      bnToHex(new BN(-1234), { bitLength: 32, isNegative: true })
-    ).toBe('0xfffffb2e');
-  });
-});

package/src/bn/toU8a.spec.ts

@@ -1,60 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { arrayRange } from '../array/index.js';
-import { TESTS } from '../bi/toU8a.spec.js';
-import { perf } from '../test/index.js';
-import { BN, bnToU8a } from './index.js';
-
-const ptest = arrayRange(65536).map((v) => [v]);
-
-describe('bnToU8a', (): void => {
-  it('converts null values to 0x00', (): void => {
-    expect(
-      bnToU8a(null)
-    ).toEqual(new Uint8Array(1));
-  });
-
-  it('converts null values to 0x00000000 (bitLength)', (): void => {
-    expect(
-      bnToU8a(null, { bitLength: 32 })
-    ).toEqual(new Uint8Array([0, 0, 0, 0]));
-  });
-
-  it('converts BN values to a prefixed hex representation', (): void => {
-    expect(
-      bnToU8a(new BN(0x123456), { isLe: false })
-    ).toEqual(new Uint8Array([0x12, 0x34, 0x56]));
-  });
-
-  it('converts BN values to a prefixed hex representation (bitLength)', (): void => {
-    expect(
-      bnToU8a(new BN(0x123456), { bitLength: 32, isLe: false })
-    ).toEqual(new Uint8Array([0x00, 0x12, 0x34, 0x56]));
-  });
-
-  it('converts using little endian (as set)', (): void => {
-    expect(
-      bnToU8a(new BN(0x123456), { bitLength: 32, isLe: true })
-    ).toEqual(new Uint8Array([0x56, 0x34, 0x12, 0x00]));
-  });
-
-  describe('conversion tests', (): void => {
-    TESTS.forEach(([isLe, isNegative, numarr, strval], i): void => {
-      const bitLength = numarr.length * 8;
-
-      it(`#${i}: converts from ${strval} (bitLength=${bitLength}, isLe=${isLe}, isNegative=${isNegative})`, (): void => {
-        expect(
-          bnToU8a(
-            new BN(strval),
-            { bitLength, isLe, isNegative }
-          )
-        ).toEqual(new Uint8Array(numarr));
-      });
-    });
-  });
-
-  perf('bnToU8a', 250000, ptest, bnToU8a);
-});

package/src/bn/toU8a.ts

@@ -1,45 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { NumberOptions, ToBn } from '../types.js';
-import type { BN } from './bn.js';
-
-import { bnToBn } from './toBn.js';
-
-const DEFAULT_OPTS: NumberOptions = { 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 <ExtToBn extends ToBn> (value?: ExtToBn | BN | bigint | number | null, { bitLength = -1, isLe = true, isNegative = false } = DEFAULT_OPTS): Uint8Array {
-  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/toU8a.spec.ts

@@ -1,20 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { bufferToU8a } from './index.js';
-
-describe('bufferToU8a', (): void => {
-  it('returns an empty buffer when null provided', (): void => {
-    expect(
-      bufferToU8a(null)
-    ).toEqual(new Uint8Array());
-  });
-
-  it('returns a Uint8Buffer with the correct values', (): void => {
-    expect(
-      bufferToU8a(Buffer.from([128, 0, 10]))
-    ).toEqual(new Uint8Array([128, 0, 10]));
-  });
-});

package/src/compact/addLength.spec.ts

@@ -1,14 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { compactAddLength } from './index.js';
-
-describe('compactAddLength', (): void => {
-  it('correctly adds the length prefix', (): void => {
-    expect(
-      compactAddLength(Uint8Array.from([12, 13]))
-    ).toEqual(Uint8Array.from([2 << 2, 12, 13]));
-  });
-});

package/src/compact/defaults.ts

@@ -1,7 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { BitLength } from './types.js';
-
-/** @internal */
-export const DEFAULT_BITLENGTH: BitLength = 32;

package/src/compact/fromU8a.spec.ts

@@ -1,84 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { BN } from '../bn/bn.js';
-import { hexToU8a } from '../hex/toU8a.js';
-import { perf } from '../test/index.js';
-import { compactFromU8a, compactFromU8aLim } from './index.js';
-
-describe('compactFromU8a', (): void => {
-  it('decoded u8 value', (): void => {
-    expect(
-      compactFromU8a(new Uint8Array([0b11111100]))
-    ).toEqual([1, new BN(63)]);
-  });
-
-  it('decodes from same u16 encoded value', (): void => {
-    expect(
-      compactFromU8a(new Uint8Array([0b11111101, 0b00000111])).toString()
-    ).toEqual(
-      [2, new BN(511)].toString()
-    );
-  });
-
-  it('decodes from same u32 encoded value (short)', (): void => {
-    expect(
-      compactFromU8a(new Uint8Array([254, 255, 3, 0])).toString()
-    ).toEqual(
-      [4, new BN(0xffff)].toString()
-    );
-  });
-
-  it('decodes from same u32 encoded value (short, max)', (): void => {
-    expect(
-      compactFromU8a(new Uint8Array([254, 255, 255, 255])).toString()
-    ).toEqual(
-      [4, new BN(1073741823)].toString()
-    );
-  });
-
-  it('decodes from same u32 encoded value (full)', (): void => {
-    expect(
-      compactFromU8a(new Uint8Array([3, 249, 255, 255, 255]))
-    ).toEqual([5, new BN(0xfffffff9)]);
-  });
-
-  it('decodes from same u32 as u64 encoded value (full, default)', (): void => {
-    expect(
-      compactFromU8a(new Uint8Array([3 + ((4 - 4) << 2), 249, 255, 255, 255]))
-    ).toEqual([5, new BN(0xfffffff9)]);
-  });
-
-  it('decodes an actual value', (): void => {
-    expect(
-      compactFromU8a(
-        hexToU8a('0x0b00407a10f35a')
-      )
-    ).toEqual([7, new BN('5af3107a4000', 16)]);
-  });
-
-  it('decodes an actual value (Buffer)', (): void => {
-    expect(
-      compactFromU8a(
-        Buffer.from('0b00407a10f35a', 'hex')
-      )
-    ).toEqual([7, new BN('5af3107a4000', 16)]);
-  });
-
-  it('decodes an actual value (100000000)', (): void => {
-    expect(
-      compactFromU8a(
-        hexToU8a('0x0284d717')
-      )[1].toString()
-    ).toEqual('100000000');
-  });
-
-  perf('compactFromU8a (u8)', 1_000_000, [[new Uint8Array([63 << 2])]], compactFromU8a);
-  perf('compactFromU8a (u16)', 1_000_000, [[new Uint8Array([0b11111101, 0b00000111])]], compactFromU8a);
-  perf('compactFromU8a (u32)', 1_000_000, [[new Uint8Array([254, 255, 3, 0])]], compactFromU8a);
-  perf('compactFromU8aLim (u32)', 1_000_000, [[new Uint8Array([254, 255, 3, 0])]], compactFromU8aLim);
-  perf('compactFromU8a (u48)', 1_000_000, [[hexToU8a('0x0b00407a10f35a')]], compactFromU8a);
-  perf('compactFromU8a (u96)', 250_000, [[new Uint8Array([23, 52, 0x40, 0x7a, 0x10, 0xf3, 0x5a, 0, 0, 18])]], compactFromU8a);
-});

package/src/compact/fromU8a.ts

@@ -1,109 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { U8aLike } from '../types.js';
-
-import { BN } from '../bn/index.js';
-import { u8aToBn, u8aToU8a } from '../u8a/index.js';
-
-/**
- * @name compactFromU8a
- * @description Retrives the offset and encoded length from a compact-prefixed value
- * @example
- * <BR>
- *
- * ```javascript
- * import { compactFromU8a } from '@pezkuwi/util';
- *
- * const [offset, length] = compactFromU8a(new Uint8Array([254, 255, 3, 0]));
- *
- * console.log('value offset=', offset, 'length=', length); // 4, 0xffff
- * ```
- */
-export function compactFromU8a (input: U8aLike): [number, BN] {
-  const u8a = u8aToU8a(input);
-
-  // The u8a is manually converted here for 1, 2 & 4 lengths, it is 2x faster
-  // than doing an additional call to u8aToBn (as with variable length)
-  switch (u8a[0] & 0b11) {
-    case 0b00:
-      return [1, new BN(u8a[0] >>> 2)];
-
-    case 0b01:
-      return [2, new BN((u8a[0] + (u8a[1] << 8)) >>> 2)];
-
-    case 0b10:
-      // for the 3rd byte, we don't << 24 - since JS converts all bitwise operators to
-      // 32-bit, in the case where the top-most bit is set this yields a negative value
-      return [4, new BN((u8a[0] + (u8a[1] << 8) + (u8a[2] << 16) + (u8a[3] * 0x1_00_00_00)) >>> 2)];
-
-    // 0b11
-    default: {
-      // add 5 to shifted (4 for base length, 1 for this byte)
-      const offset = (u8a[0] >>> 2) + 5;
-
-      // we unroll the loop
-      switch (offset) {
-        // there still could be 4 bytes data, similar to 0b10 above (with offsets)
-        case 5:
-          // for the 3rd byte, we don't << 24 - since JS converts all bitwise operators to
-          // 32-bit, in the case where the top-most bit is set this yields a negative value
-          return [5, new BN(u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + (u8a[4] * 0x1_00_00_00))];
-
-        case 6:
-          return [6, new BN(u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + ((u8a[4] + (u8a[5] << 8)) * 0x1_00_00_00))];
-
-        // 6 bytes data is the maximum, 48 bits (56 would overflow)
-        case 7:
-          return [7, new BN(u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + ((u8a[4] + (u8a[5] << 8) + (u8a[6] << 16)) * 0x1_00_00_00))];
-
-        // for anything else, use the non-unrolled version
-        default:
-          return [offset, u8aToBn(u8a.subarray(1, offset))];
-      }
-    }
-  }
-}
-
-/**
- * @name compactFromU8aLim
- * @description A limited version of [[compactFromU8a]], accepting only Uint8Array inputs for values <= 48 bits
- */
-export function compactFromU8aLim (u8a: Uint8Array): [number, number] {
-  // The u8a is manually converted here for 1, 2 & 4 lengths, it is 2x faster
-  // than doing an additional call to u8aToBn (as with variable length)
-  switch (u8a[0] & 0b11) {
-    case 0b00:
-      return [1, u8a[0] >>> 2];
-
-    case 0b01:
-      return [2, (u8a[0] + (u8a[1] << 8)) >>> 2];
-
-    case 0b10:
-      // for the 3rd byte, we don't << 24 - since JS converts all bitwise operators to
-      // 32-bit, in the case where the top-most bit is set this yields a negative value
-      return [4, (u8a[0] + (u8a[1] << 8) + (u8a[2] << 16) + (u8a[3] * 0x1_00_00_00)) >>> 2];
-
-    // 0b11
-    default: {
-      // add 5 to shifted (4 for base length, 1 for this byte)
-      // we unroll the loop
-      switch ((u8a[0] >>> 2) + 5) {
-        // there still could be 4 bytes data, similar to 0b10 above (with offsets)
-        case 5:
-          return [5, u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + (u8a[4] * 0x1_00_00_00)];
-
-        case 6:
-          return [6, u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + ((u8a[4] + (u8a[5] << 8)) * 0x1_00_00_00)];
-
-        // 6 bytes data is the maximum, 48 bits (56 would overflow)
-        case 7:
-          return [7, u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + ((u8a[4] + (u8a[5] << 8) + (u8a[6] << 16)) * 0x1_00_00_00)];
-
-        // for anything else, we are above the actual MAX_SAFE_INTEGER - bail out
-        default:
-          throw new Error('Compact input is > Number.MAX_SAFE_INTEGER');
-      }
-    }
-  }
-}

package/src/compact/stripLength.spec.ts

@@ -1,17 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { compactStripLength } from './index.js';
-
-describe('compactStripLength', (): void => {
-  it('correctly removes the length prefix', (): void => {
-    expect(
-      compactStripLength(Uint8Array.from([2 << 2, 12, 13]))
-    ).toEqual([
-      3,
-      Uint8Array.from([12, 13])
-    ]);
-  });
-});

package/src/compact/toU8a.spec.ts

@@ -1,59 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { BN } from '../bn/index.js';
-import { compactToU8a } from './index.js';
-
-const TESTS: [output: string | Uint8Array, input: BN | number][] = [
-  // Rust tests
-  // Copied from https://github.com/paritytech/parity-codec/blob/master/src/codec.rs
-  ['00', new BN('0')],
-  ['fc', new BN('63')],
-  ['01 01', new BN('64')],
-  ['fd ff', new BN('16383')],
-  ['02 00 01 00', new BN('16384')],
-  ['fe ff ff ff', new BN('1073741823')],
-  ['03 00 00 00 40', new BN('1073741824')],
-  ['03 ff ff ff ff', new BN(`${1}${'0'.repeat(32)}`, 2).subn(1)],
-  ['07 00 00 00 00 01', new BN(`${1}${'0'.repeat(32)}`, 2)],
-  ['0b 00 00 00 00 00 01', new BN(`${1}${'0'.repeat(40)}`, 2)],
-  ['0f 00 00 00 00 00 00 01', new BN(`${1}${'0'.repeat(48)}`, 2)],
-  ['0f ff ff ff ff ff ff ff', new BN(`${1}${'0'.repeat(56)}`, 2).subn(1)],
-  ['13 00 00 00 00 00 00 00 01', new BN(`${1}${'0'.repeat(56)}`, 2)],
-  ['13 ff ff ff ff ff ff ff ff', new BN(`${1}${'0'.repeat(64)}`, 2).subn(1)],
-  // own tests
-  [new Uint8Array([18 << 2]), 18],
-  [new Uint8Array([0b11111100]), 63],
-  [new Uint8Array([0xbd, 0x01]), 111],
-  [new Uint8Array([0b11111101, 0b00000111]), 511],
-  [new Uint8Array([253, 127]), 0x1fff],
-  [new Uint8Array([254, 255, 3, 0]), 0xffff],
-  [new Uint8Array([3 + ((4 - 4) << 2), 249, 255, 255, 255]), 0xfffffff9],
-  [new Uint8Array([3 + ((6 - 4) << 2), 0x00, 0x40, 0x7a, 0x10, 0xf3, 0x5a]), new BN('00005af3107a4000', 16)],
-  [new Uint8Array([23, 52, 0x40, 0x7a, 0x10, 0xf3, 0x5a, 0, 0, 18]), new BN('1200005af3107a4034', 16)]
-];
-
-describe('encode', (): void => {
-  it('does not modify the original', (): void => {
-    const original = new BN(123456);
-
-    expect(compactToU8a(original)).toEqual(new Uint8Array([2, 137, 7, 0]));
-    expect(original.toString()).toEqual('123456');
-  });
-
-  describe('conversion tests', (): void => {
-    TESTS.forEach(([output, input], i): void => {
-      it(`#${i}: encodes ${input.toString()}`, (): void => {
-        expect(
-          compactToU8a(input)
-        ).toEqual(
-          output instanceof Uint8Array
-            ? output
-            : Uint8Array.from(output.split(' ').map((s) => parseInt(s, 16)))
-        );
-      });
-    });
-  });
-});

package/src/compact/toU8a.ts

@@ -1,53 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { BN, BN_ONE, BN_TWO, bnToBn, bnToU8a } from '../bn/index.js';
-import { u8aConcatStrict } from '../u8a/index.js';
-
-const MAX_U8 = BN_TWO.pow(new BN(8 - 2)).isub(BN_ONE);
-const MAX_U16 = BN_TWO.pow(new BN(16 - 2)).isub(BN_ONE);
-const MAX_U32 = BN_TWO.pow(new BN(32 - 2)).isub(BN_ONE);
-const BL_16 = { bitLength: 16 };
-const BL_32 = { bitLength: 32 };
-
-/**
- * @name compactToU8a
- * @description Encodes a number into a compact representation
- * @example
- * <BR>
- *
- * ```javascript
- * import { compactToU8a } from '@pezkuwi/util';
- *
- * console.log(compactToU8a(511, 32)); // Uint8Array([0b11111101, 0b00000111])
- * ```
- */
-export function compactToU8a (value: BN | bigint | number): Uint8Array {
-  const bn = bnToBn(value);
-
-  if (bn.lte(MAX_U8)) {
-    return new Uint8Array([bn.toNumber() << 2]);
-  } else if (bn.lte(MAX_U16)) {
-    return bnToU8a(bn.shln(2).iadd(BN_ONE), BL_16);
-  } else if (bn.lte(MAX_U32)) {
-    return bnToU8a(bn.shln(2).iadd(BN_TWO), BL_32);
-  }
-
-  const u8a = bnToU8a(bn);
-  let length = u8a.length;
-
-  // adjust to the minimum number of bytes
-  while (u8a[length - 1] === 0) {
-    length--;
-  }
-
-  if (length < 4) {
-    throw new Error('Invalid length, previous checks match anything less than 2^30');
-  }
-
-  return u8aConcatStrict([
-    // subtract 4 as minimum (also catered for in decoding)
-    new Uint8Array([((length - 4) << 2) + 0b11]),
-    u8a.subarray(0, length)
-  ]);
-}

package/src/compact/types.ts

@@ -1,4 +0,0 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export type BitLength = 8 | 16 | 32 | 64 | 128 | 256;