Flatten calls (#1200)

packages/util/src/array/shuffle.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export function arrayShuffle <T> (input: T[]): T[] {
-  const result = [...input];
+  const result = input.slice();
   let curr = result.length;
 
   if (curr === 1) {

packages/util/src/compact/fromU8a.ts

@@ -20,24 +20,24 @@ import { u8aToBn, u8aToU8a } from '../u8a';
  * console.log('value offset=', offset, 'length=', length); // 4, 0xffff
  * ```
  */
-export function compactFromU8a (_input: U8aLike): [number, BN] {
-  const input = u8aToU8a(_input);
-  const flag = input[0] & 0b11;
+export function compactFromU8a (input: U8aLike): [number, BN] {
+  const u8a = u8aToU8a(input);
+  const flag = u8a[0] & 0b11;
 
   if (flag === 0b00) {
-    return [1, new BN(input[0]).ishrn(2)];
+    return [1, new BN(u8a[0]).ishrn(2)];
   } else if (flag === 0b01) {
-    return [2, u8aToBn(input.subarray(0, 2), true).ishrn(2)];
+    return [2, u8aToBn(u8a.subarray(0, 2), true).ishrn(2)];
   } else if (flag === 0b10) {
-    return [4, u8aToBn(input.subarray(0, 4), true).ishrn(2)];
+    return [4, u8aToBn(u8a.subarray(0, 4), true).ishrn(2)];
   }
 
   const offset = 1 + (
-    new BN(input[0])
+    new BN(u8a[0])
       .ishrn(2) // clear flag
       .iadd(BN_FOUR) // add 4 for base length
       .toNumber()
   );
 
-  return [offset, u8aToBn(input.subarray(1, offset), true)];
+  return [offset, u8aToBn(u8a.subarray(1, offset), true)];
 }

packages/util/src/compact/toU8a.ts

@@ -21,18 +21,18 @@ const MAX_U32 = BN_TWO.pow(new BN(32 - 2)).isub(BN_ONE);
  * console.log(compactToU8a(511, 32)); // Uint8Array([0b11111101, 0b00000111])
  * ```
  */
-export function compactToU8a (_value: BN | bigint | number): Uint8Array {
-  const value = bnToBn(_value);
+export function compactToU8a (value: BN | bigint | number): Uint8Array {
+  const bn = bnToBn(value);
 
-  if (value.lte(MAX_U8)) {
-    return new Uint8Array([value.toNumber() << 2]);
-  } else if (value.lte(MAX_U16)) {
-    return bnToU8a(value.shln(2).iadd(BN_ONE), 16, true);
-  } else if (value.lte(MAX_U32)) {
-    return bnToU8a(value.shln(2).iadd(BN_TWO), 32, true);
+  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), 16, true);
+  } else if (bn.lte(MAX_U32)) {
+    return bnToU8a(bn.shln(2).iadd(BN_TWO), 32, true);
   }
 
-  const u8a = bnToU8a(value);
+  const u8a = bnToU8a(bn);
   let length = u8a.length;
 
   // adjust to the minimum number of bytes

packages/util/src/u8a/cmp.ts

@@ -5,33 +5,6 @@ import type { HexString } from '../types';
 
 import { u8aToU8a } from './toU8a';
 
-function compare (a: Uint8Array, b: Uint8Array): number {
-  let i = 0;
-
-  while (true) {
-    const overA = i >= a.length;
-    const overB = i >= b.length;
-
-    if (overA && overB) {
-      // both ends reached
-      return 0;
-    } else if (overA) {
-      // a has no more data, b has data
-      return -1;
-    } else if (overB) {
-      // b has no more data, a has data
-      return 1;
-    } else if (a[i] !== b[i]) {
-      // the number in this index doesn't match
-      return a[i] > b[i]
-        ? 1
-        : -1;
-    }
-
-    i++;
-  }
-}
-
 /**
  * @name u8aCmp
  * @summary Compares two Uint8Arrays for sorting.
@@ -49,5 +22,30 @@ function compare (a: Uint8Array, b: Uint8Array): number {
  * ```
  */
 export function u8aCmp (a: HexString | Uint8Array | string, b: HexString | Uint8Array | string): number {
-  return compare(u8aToU8a(a), u8aToU8a(b));
+  const u8aa = u8aToU8a(a);
+  const u8ab = u8aToU8a(b);
+  let i = 0;
+
+  while (true) {
+    const overA = i >= u8aa.length;
+    const overB = i >= u8ab.length;
+
+    if (overA && overB) {
+      // both ends reached
+      return 0;
+    } else if (overA) {
+      // a has no more data, b has data
+      return -1;
+    } else if (overB) {
+      // b has no more data, a has data
+      return 1;
+    } else if (u8aa[i] !== u8ab[i]) {
+      // the number in this index doesn't match
+      return u8aa[i] > u8ab[i]
+        ? 1
+        : -1;
+    }
+
+    i++;
+  }
 }

packages/util/src/u8a/eq.ts

@@ -5,31 +5,6 @@ import type { HexString } from '../types';
 
 import { u8aToU8a } from './toU8a';
 
-function equals (a: Uint8Array, b: Uint8Array): boolean {
-  if (a.length === b.length) {
-    const dvA = new DataView(a.buffer, a.byteOffset);
-    const dvB = new DataView(b.buffer, b.byteOffset);
-    const mod = a.length % 4;
-    const length = a.length - mod;
-
-    for (let i = 0; i < length; i += 4) {
-      if (dvA.getUint32(i) !== dvB.getUint32(i)) {
-        return false;
-      }
-    }
-
-    for (let i = length; i < a.length; i++) {
-      if (a[i] !== b[i]) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  return false;
-}
-
 /**
  * @name u8aEq
  * @summary Compares two Uint8Arrays for equality.
@@ -45,5 +20,29 @@ function equals (a: Uint8Array, b: Uint8Array): boolean {
  * ```
  */
 export function u8aEq (a: HexString | Uint8Array | string, b: HexString | Uint8Array | string): boolean {
-  return equals(u8aToU8a(a), u8aToU8a(b));
+  const u8aa = u8aToU8a(a);
+  const u8ab = u8aToU8a(b);
+
+  if (u8aa.length === u8ab.length) {
+    const dvA = new DataView(u8aa.buffer, u8aa.byteOffset);
+    const dvB = new DataView(u8ab.buffer, u8ab.byteOffset);
+    const mod = u8aa.length % 4;
+    const length = u8aa.length - mod;
+
+    for (let i = 0; i < length; i += 4) {
+      if (dvA.getUint32(i) !== dvB.getUint32(i)) {
+        return false;
+      }
+    }
+
+    for (let i = length; i < u8aa.length; i++) {
+      if (u8aa[i] !== u8ab[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  return false;
 }