@pezkuwi/util 14.0.1

package/src/u8a/toBigInt.ts

@@ -0,0 +1,100 @@
+// Copyright 2017-2025 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ToBnOptions } from '../types.js';
+
+import { BigInt } from '@pezkuwi/x-bigint';
+
+import { _1n } from '../bi/consts.js';
+
+const U8_MAX = BigInt(256);
+const U16_MAX = BigInt(256 * 256);
+const U64_MAX = BigInt('0x10000000000000000');
+
+/**
+ * @name u8aToBigInt
+ * @summary Creates a BigInt from a Uint8Array object.
+ */
+export function u8aToBigInt (value: Uint8Array, { isLe = true, isNegative = false }: ToBnOptions = {}): bigint {
+  // slice + reverse is expensive, however SCALE is LE by default so this is the path
+  // we are most interested in (the BE is added for the sake of being comprehensive)
+  if (!isLe) {
+    value = value.slice().reverse();
+  }
+
+  const count = value.length;
+
+  if (isNegative && count && (value[count - 1] & 0x80)) {
+    switch (count) {
+      case 0:
+        return BigInt(0);
+
+      case 1:
+        return BigInt(((value[0] ^ 0x0000_00ff) * -1) - 1);
+
+      case 2:
+        return BigInt((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
+
+      case 4:
+        return BigInt((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
+    }
+
+    const dvI = new DataView(value.buffer, value.byteOffset);
+
+    if (count === 8) {
+      return dvI.getBigInt64(0, true);
+    }
+
+    let result = BigInt(0);
+    const mod = count % 2;
+
+    for (let i = count - 2; i >= mod; i -= 2) {
+      result = (result * U16_MAX) + BigInt(dvI.getUint16(i, true) ^ 0xffff);
+    }
+
+    if (mod) {
+      result = (result * U8_MAX) + BigInt(value[0] ^ 0xff);
+    }
+
+    return (result * -_1n) - _1n;
+  }
+
+  switch (count) {
+    case 0:
+      return BigInt(0);
+
+    case 1:
+      return BigInt(value[0]);
+
+    case 2:
+      return BigInt(value[0] + (value[1] << 8));
+
+    case 4:
+      return BigInt(value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00));
+  }
+
+  const dvI = new DataView(value.buffer, value.byteOffset);
+
+  switch (count) {
+    case 8:
+      return dvI.getBigUint64(0, true);
+
+    case 16:
+      return (dvI.getBigUint64(8, true) * U64_MAX) + dvI.getBigUint64(0, true);
+
+    default: {
+      let result = BigInt(0);
+      const mod = count % 2;
+
+      for (let i = count - 2; i >= mod; i -= 2) {
+        result = (result * U16_MAX) + BigInt(dvI.getUint16(i, true));
+      }
+
+      if (mod) {
+        result = (result * U8_MAX) + BigInt(value[0]);
+      }
+
+      return result;
+    }
+  }
+}

package/src/u8a/toBn.spec.ts

@@ -0,0 +1,106 @@
+// Copyright 2017-2025 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+import { TESTS } from '../bi/toU8a.spec.js';
+import { perf } from '../test/index.js';
+import { u8aToBn } from './index.js';
+
+// test-cases are the same as in u8aToBigInt
+describe('u8aToBn', (): void => {
+  it('converts little-endian by default', (): void => {
+    expect(
+      u8aToBn(
+        new Uint8Array([0x12, 0x34])
+      ).toString(16)
+    ).toBe('3412');
+  });
+
+  describe('empty creation', (): void => {
+    it('handles unsigned (le)', (): void => {
+      expect(
+        u8aToBn(
+          new Uint8Array(),
+          { isLe: true }
+        ).toString(16)
+      ).toBe('0');
+    });
+
+    it('handles signed (le)', (): void => {
+      expect(
+        u8aToBn(
+          new Uint8Array(),
+          { isLe: true, isNegative: true }
+        ).toString(16)
+      ).toBe('0');
+    });
+
+    it('handles unsigned (be)', (): void => {
+      expect(
+        u8aToBn(
+          new Uint8Array(),
+          { isLe: false }
+        ).toString(16)
+      ).toBe('0');
+    });
+
+    it('handles signed (be)', (): void => {
+      expect(
+        u8aToBn(
+          new Uint8Array(),
+          { isLe: false, isNegative: true }
+        ).toString(16)
+      ).toBe('0');
+    });
+  });
+
+  it('handles overflows correctly (little-endian)', (): void => {
+    expect(
+      u8aToBn(
+        new Uint8Array([0, 1, 0, 0, 0, 0, 0, 0]),
+        { isLe: true }
+      ).toNumber()
+    ).toBe(256);
+  });
+
+  describe('length tests', (): void => {
+    [true, false].forEach((isLe) => {
+      for (let i = 1; i < 32; i++) {
+        const tu8a = [0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78];
+        const tstr = tu8a.map((n) => n.toString(16));
+
+        it(`converts values with bitLength=${i * 8}, isLe=${isLe}`, (): void => {
+          expect(
+            u8aToBn(
+              new Uint8Array(tu8a.slice(0, i)),
+              { isLe }
+            ).toString(16)
+          ).toBe(
+            isLe
+              ? tstr.slice(0, i).reverse().join('')
+              : tstr.slice(0, i).join('')
+          );
+        });
+      }
+    });
+  });
+
+  describe('conversion tests', (): void => {
+    TESTS.forEach(([isLe, isNegative, numarr, strval], i): void => {
+      it(`#${i}: creates ${strval} (bitLength=${numarr.length * 8}, isLe=${isLe}, isNegative=${isNegative})`, (): void => {
+        expect(
+          u8aToBn(
+            new Uint8Array(numarr),
+            { isLe, isNegative }
+          ).toString()
+        ).toBe(strval);
+      });
+    });
+  });
+
+  perf('u8aToBn (i32)', 750_000, [[new Uint8Array([0x9c, 0x9c, 0x9c, 0x9c])]], (v: Uint8Array) => u8aToBn(v, { isNegative: true }));
+  perf('u8aToBn (u32)', 750_000, [[new Uint8Array([0x68, 0x65, 0x6c, 0x6c])]], u8aToBn);
+  perf('u8aToBn (u64)', 750_000, [[new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x68, 0x65, 0x6c, 0x6c])]], u8aToBn);
+  perf('u8aToBn (u128)', 750_000, [[new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x68, 0x65, 0x6c, 0x6c, 0x68, 0x65, 0x6c, 0x6c, 0x68, 0x65, 0x6c, 0x6c])]], u8aToBn);
+});

package/src/u8a/toBn.ts

@@ -0,0 +1,101 @@
+// Copyright 2017-2025 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ToBnOptions } from '../types.js';
+
+import { BN } from '../bn/bn.js';
+
+/**
+ * @name u8aToBn
+ * @summary Creates a BN from a Uint8Array object.
+ * @description
+ * `UInt8Array` input values return the actual BN. `null` or `undefined` values returns an `0x0` value.
+ * @param value The value to convert
+ * @param options Options to pass while converting
+ * @param options.isLe Convert using Little Endian (default)
+ * @param options.isNegative Convert using two's complement
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aToBn } from '@pezkuwi/util';
+ *
+ * u8aToHex(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0xf])); // 0x68656c0f
+ * ```
+ */
+export function u8aToBn (value: Uint8Array, { isLe = true, isNegative = false }: ToBnOptions = {}): BN {
+  // slice + reverse is expensive, however SCALE is LE by default so this is the path
+  // we are most interested in (the BE is added for the sake of being comprehensive)
+  if (!isLe) {
+    value = value.slice().reverse();
+  }
+
+  const count = value.length;
+
+  // shortcut for <= u48 values - in this case the manual conversion
+  // here seems to be more efficient than passing the full array
+  if (isNegative && count && (value[count - 1] & 0x80)) {
+    // Most common case i{8, 16, 32} default LE SCALE-encoded
+    // For <= 32, we also optimize the xor to a single op
+    switch (count) {
+      case 0:
+        return new BN(0);
+
+      case 1:
+        return new BN(((value[0] ^ 0x0000_00ff) * -1) - 1);
+
+      case 2:
+        return new BN((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
+
+      case 3:
+        return new BN((((value[0] + (value[1] << 8) + (value[2] << 16)) ^ 0x00ff_ffff) * -1) - 1);
+
+      case 4:
+        // 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 new BN((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
+
+      case 5:
+        return new BN(((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + ((value[4] ^ 0xff) * 0x1_00_00_00_00)) * -1) - 1);
+
+      case 6:
+        return new BN(((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + (((value[4] + (value[5] << 8)) ^ 0x0000_ffff) * 0x1_00_00_00_00)) * -1) - 1);
+
+      default:
+        return new BN(value, 'le').fromTwos(count * 8);
+    }
+  }
+
+  // Most common case - u{8, 16, 32} default LE SCALE-encoded
+  //
+  // There are some slight benefits in unrolling this specific loop,
+  // however it comes with diminishing returns since here the actual
+  // `new BN` does seem to take up the bulk of the time
+  switch (count) {
+    case 0:
+      return new BN(0);
+
+    case 1:
+      return new BN(value[0]);
+
+    case 2:
+      return new BN(value[0] + (value[1] << 8));
+
+    case 3:
+      return new BN(value[0] + (value[1] << 8) + (value[2] << 16));
+
+    case 4:
+      // 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 new BN(value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00));
+
+    case 5:
+      return new BN(value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8)) * 0x1_00_00_00));
+
+    case 6:
+      return new BN(value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8) + (value[5] << 16)) * 0x1_00_00_00));
+
+    default:
+      return new BN(value, 'le');
+  }
+}

package/src/u8a/toBuffer.spec.ts

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

package/src/u8a/toBuffer.ts

@@ -0,0 +1,28 @@
+// Copyright 2017-2025 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { BufferClass, BufferObject } from '../types.js';
+
+import { xglobal } from '@pezkuwi/x-global';
+
+import { hasBuffer } from '../has.js';
+
+/**
+ * @name u8aToBuffer
+ * @summary Creates a Buffer object from a hex string.
+ * @description
+ * `null` inputs returns an empty `Buffer` result. `UInt8Array` input values return the actual bytes value converted to a `Buffer`. Anything that is not a `UInt8Array` throws an error.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aToBuffer } from '@pezkuwi/util';
+ *
+ * console.log('Buffer', u8aToBuffer(new Uint8Array([1, 2, 3])));
+ * ```
+ */
+export function u8aToBuffer <T = BufferObject> (value?: Uint8Array | null): T {
+  return hasBuffer
+    ? (xglobal.Buffer as unknown as BufferClass).from(value || [])
+    : new Uint8Array(value || []) as T;
+}

package/src/u8a/toFloat.spec.ts

@@ -0,0 +1,86 @@
+// Copyright 2017-2025 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+import { hexToU8a } from '../hex/index.js';
+import { u8aToFloat } from './index.js';
+
+describe('u8aToFloat', (): void => {
+  it('throws on invalid bitLength', (): void => {
+    expect(
+      () => u8aToFloat(hexToU8a('0x00000000'), { bitLength: 48 as 32 })
+    ).toThrow();
+  });
+
+  it('throws on invalid input length', (): void => {
+    expect(
+      () => u8aToFloat(new Uint8Array())
+    ).toThrow();
+  });
+
+  describe('32-bit', (): void => {
+    it('correctly decodes +0.0', (): void => {
+      expect(
+        u8aToFloat(hexToU8a('0x00000000'))
+      ).toEqual(+0.0);
+    });
+
+    it('correctly decodes -0.0', (): void => {
+      expect(
+        u8aToFloat(hexToU8a('0x00000080'))
+      ).toEqual(-0.0);
+    });
+
+    it('correctly decodes -0.0 (BE)', (): void => {
+      expect(
+        u8aToFloat(hexToU8a('0x80000000'), { isLe: false })
+      ).toEqual(-0.0);
+    });
+
+    it('decoded NaN', (): void => {
+      expect(
+        u8aToFloat(hexToU8a('0x0000c07f'))
+      ).toEqual(Number.NaN);
+    });
+
+    // https://www.h-schmidt.net/FloatConverter/IEEE754.html
+    it('decodes a known number', (): void => {
+      expect(
+        u8aToFloat(hexToU8a('0x79e9f642')).toFixed(3)
+      ).toEqual('123.456');
+    });
+
+    it('decodes a known number (BE)', (): void => {
+      expect(
+        u8aToFloat(hexToU8a('0x42f6e979'), { isLe: false }).toFixed(3)
+      ).toEqual('123.456');
+    });
+  });
+
+  describe('64-bit', (): void => {
+    it('correctly decodes +0.0', (): void => {
+      expect(
+        u8aToFloat(hexToU8a('0x0000000000000000'), { bitLength: 64 })
+      ).toEqual(+0.0);
+    });
+
+    it('correctly decodes -0.0', (): void => {
+      expect(
+        u8aToFloat(hexToU8a('0x0000000000000080'), { bitLength: 64 })
+      ).toEqual(-0.0);
+    });
+
+    it('correctly decodes -0.0 (BE)', (): void => {
+      expect(
+        u8aToFloat(hexToU8a('0x8000000000000000'), { bitLength: 64, isLe: false })
+      ).toEqual(-0.0);
+    });
+
+    it('correctly decodes NaN', (): void => {
+      expect(
+        u8aToFloat(hexToU8a('0x000000000000f87f'), { bitLength: 64 })
+      ).toEqual(Number.NaN);
+    });
+  });
+});

package/src/u8a/toFloat.ts

@@ -0,0 +1,26 @@
+// Copyright 2017-2025 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+interface Options {
+  bitLength?: 32 | 64;
+  isLe?: boolean;
+}
+
+/**
+ * @name u8aToFloat
+ * @description Converts a Uint8Array value into the float (either 32 or 64-bit)
+ * representation.
+ */
+export function u8aToFloat (value: Uint8Array, { bitLength = 32, isLe = true }: Options = {}): number {
+  if (bitLength !== 32 && bitLength !== 64) {
+    throw new Error('Invalid bitLength provided, expected 32 or 64');
+  } else if (value.length < (bitLength / 8)) {
+    throw new Error(`Invalid input buffer provided, expected at least ${bitLength / 8} bytes, found ${value.length}`);
+  }
+
+  const dv = new DataView(value.buffer, value.byteOffset);
+
+  return bitLength === 32
+    ? dv.getFloat32(0, isLe)
+    : dv.getFloat64(0, isLe);
+}

package/src/u8a/toHex.spec.ts

@@ -0,0 +1,94 @@
+// Copyright 2017-2025 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+import { perfCmp } from '../test/index.js';
+import { u8aToHex } from './index.js';
+import { u8aToHex as u8aToHexBuffer } from './toHexBuffer.js';
+
+const ptest32k = new Uint8Array(32768);
+const ptest256 = new Uint8Array(256);
+
+for (let i = 0, count = ptest32k.length; i < count; i++) {
+  if (i < ptest256.length) {
+    ptest256[1] = i % 256;
+  }
+
+  ptest32k[i] = i % 256;
+}
+
+describe('u8aToHex', (): void => {
+  it('returns empty as 0x', (): void => {
+    expect(
+      u8aToHex()
+    ).toEqual('0x');
+  });
+
+  it('returns empty as "" (unprefixed)', (): void => {
+    expect(
+      u8aToHex(null, -1, false)
+    ).toEqual('');
+  });
+
+  it('returns the hex value for the array', (): void => {
+    expect(
+      u8aToHex(
+        new Uint8Array([128, 0, 10])
+      )
+    ).toEqual('0x80000a');
+  });
+
+  it('returns the hex value for the array (unprefixed)', (): void => {
+    expect(
+      u8aToHex(
+        new Uint8Array([128, 0, 10]),
+        -1,
+        false
+      )
+    ).toEqual('80000a');
+  });
+
+  it('handles starting zeros correctly', (): void => {
+    expect(
+      u8aToHex(
+        new Uint8Array([0, 1, 0, 0, 0, 0, 0, 0])
+      )
+    ).toEqual('0x0001000000000000');
+  });
+
+  it('returns the hex value where allowed < max', (): void => {
+    expect(
+      u8aToHex(
+        new Uint8Array(Uint8Array.from([128, 0, 10, 11]), 64)
+      )
+    ).toEqual('0x80000a0b');
+  });
+
+  it('returns the trimmed hex value where allowed >= max', (): void => {
+    expect(
+      u8aToHex(
+        new Uint8Array([128, 0, 10, 11, 12, 13]),
+        32
+      )
+    ).toEqual('0x8000…0c0d');
+  });
+
+  it('converts known bytes to their correct values', (): void => {
+    expect(
+      // hello world
+      u8aToHex(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64]))
+    ).toEqual('0x68656c6c6f20776f726c64');
+  });
+
+  perfCmp('u8aToHex (32k)', ['u8aToHexBuffer', 'u8aToHex'], 1000, [[ptest32k]], (s: Uint8Array, isSecond) =>
+    isSecond
+      ? u8aToHex(s)
+      : u8aToHexBuffer(s)
+  );
+  perfCmp('u8aToHex (128)', ['u8aToHexBuffer', 'u8aToHex'], 200_000, [[ptest256]], (s: Uint8Array, isSecond) =>
+    isSecond
+      ? u8aToHex(s)
+      : u8aToHexBuffer(s)
+  );
+});

package/src/u8a/toHex.ts

@@ -0,0 +1,68 @@
+// Copyright 2017-2025 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { HexString } from '../types.js';
+
+const U8 = new Array<string>(256);
+const U16 = new Array<string>(256 * 256);
+
+for (let n = 0; n < 256; n++) {
+  U8[n] = n.toString(16).padStart(2, '0');
+}
+
+for (let i = 0; i < 256; i++) {
+  const s = i << 8;
+
+  for (let j = 0; j < 256; j++) {
+    U16[s | j] = U8[i] + U8[j];
+  }
+}
+
+/** @internal */
+function hex (value: Uint8Array, result: HexString): HexString {
+  const mod = (value.length % 2) | 0;
+  const length = (value.length - mod) | 0;
+
+  for (let i = 0; i < length; i += 2) {
+    result += U16[(value[i] << 8) | value[i + 1]];
+  }
+
+  if (mod) {
+    result += U8[value[length] | 0];
+  }
+
+  return result;
+}
+
+/**
+ * @name u8aToHex
+ * @summary Creates a hex string from a Uint8Array object.
+ * @description
+ * `UInt8Array` input values return the actual hex string. `null` or `undefined` values returns an `0x` string.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aToHex } from '@pezkuwi/util';
+ *
+ * u8aToHex(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0xf])); // 0x68656c0f
+ * ```
+ */
+export function u8aToHex (value?: Uint8Array | null, bitLength = -1, isPrefixed = true): HexString {
+  // this is not 100% correct sinmce we support isPrefixed = false....
+  const empty = isPrefixed
+    ? '0x'
+    : '' as HexString;
+
+  if (!value?.length) {
+    return empty;
+  } else if (bitLength > 0) {
+    const length = Math.ceil(bitLength / 8);
+
+    if (value.length > length) {
+      return `${hex(value.subarray(0, length / 2), empty)}…${hex(value.subarray(value.length - length / 2), '' as HexString)}`;
+    }
+  }
+
+  return hex(value, empty);
+}

package/src/u8a/toHexBuffer.spec.ts

@@ -0,0 +1,63 @@
+// Copyright 2017-2025 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+import { u8aToHex } from './toHexBuffer.js';
+
+describe('u8aToHex', (): void => {
+  it('returns empty as 0x', (): void => {
+    expect(
+      u8aToHex()
+    ).toEqual('0x');
+  });
+
+  it('returns empty as "" (unprefixed)', (): void => {
+    expect(
+      u8aToHex(null, -1, false)
+    ).toEqual('');
+  });
+
+  it('returns the hex value for the array', (): void => {
+    expect(
+      u8aToHex(
+        new Uint8Array([128, 0, 10])
+      )
+    ).toEqual('0x80000a');
+  });
+
+  it('returns the hex value for the array (unprefixed)', (): void => {
+    expect(
+      u8aToHex(
+        new Uint8Array([128, 0, 10]),
+        -1,
+        false
+      )
+    ).toEqual('80000a');
+  });
+
+  it('handles starting zeros correctly', (): void => {
+    expect(
+      u8aToHex(
+        new Uint8Array([0, 1, 0, 0, 0, 0, 0, 0])
+      )
+    ).toEqual('0x0001000000000000');
+  });
+
+  it('returns the hex value where allowed < max', (): void => {
+    expect(
+      u8aToHex(
+        new Uint8Array(Uint8Array.from([128, 0, 10, 11]), 64)
+      )
+    ).toEqual('0x80000a0b');
+  });
+
+  it('returns the trimmed hex value where allowed >= max', (): void => {
+    expect(
+      u8aToHex(
+        new Uint8Array([128, 0, 10, 11, 12, 13]),
+        32
+      )
+    ).toEqual('0x8000…0c0d');
+  });
+});