Adjust base library usage of for vs reduce/map (#1151)

* Adjust base library usage of `for` vs `reduce/map`

* Additional

* Adjust

packages/util-crypto/src/address/derive.ts

@@ -7,7 +7,6 @@ import type { Prefix } from './types';
 import { assert } from '@polkadot/util';
 
 import { keyExtractPath } from '../key';
-import { DeriveJunction } from '../key/DeriveJunction';
 import { schnorrkelDerivePublic } from '../schnorrkel';
 import { decodeAddress } from './decode';
 import { encodeAddress } from './encode';
@@ -21,9 +20,13 @@ import { encodeAddress } from './encode';
 export function deriveAddress (who: HexString | Uint8Array | string, suri: string, ss58Format?: Prefix): string {
   const { path } = keyExtractPath(suri);
 
-  assert(path.length && !path.some((path) => path.isHard), 'Expected suri to contain a combination of non-hard paths');
+  assert(path.length && !path.some((p) => p.isHard), 'Expected suri to contain a combination of non-hard paths');
 
-  return encodeAddress(path.reduce((publicKey: Uint8Array, path: DeriveJunction): Uint8Array => {
-    return schnorrkelDerivePublic(publicKey, path.chainCode);
-  }, decodeAddress(who)), ss58Format);
+  let publicKey = decodeAddress(who);
+
+  for (const { chainCode } of path) {
+    publicKey = schnorrkelDerivePublic(publicKey, chainCode);
+  }
+
+  return encodeAddress(publicKey, ss58Format);
 }

packages/util-crypto/src/hd/ethereum/index.ts

@@ -44,7 +44,7 @@ function deriveChild (hd: CodedKeypair, index: number): CodedKeypair {
 
 export function hdEthereum (seed: Uint8Array, path = ''): Keypair {
   const I = hmacSha512(MASTER_SECRET, seed);
-  const hd = createCoded(I.slice(0, 32), I.slice(32));
+  let hd = createCoded(I.slice(0, 32), I.slice(32));
 
   if (!path || path === 'm' || path === 'M' || path === "m'" || path === "M'") {
     return hd;
@@ -52,16 +52,15 @@ export function hdEthereum (seed: Uint8Array, path = ''): Keypair {
 
   assert(hdValidatePath(path), 'Invalid derivation path');
 
-  return path
-    .split('/')
-    .slice(1)
-    .reduce((hd: CodedKeypair, c): CodedKeypair =>
-      deriveChild(
-        hd, parseInt(c, 10) + (
-          (c.length > 1) && c.endsWith("'")
-            ? HARDENED
-            : 0
-        )
-      ), hd
-    );
+  const parts = path.split('/').slice(1);
+
+  for (const p of parts) {
+    hd = deriveChild(hd, parseInt(p, 10) + (
+      (p.length > 1) && p.endsWith("'")
+        ? HARDENED
+        : 0
+    ));
+  }
+
+  return hd;
 }

packages/util-crypto/src/hd/ledger/index.ts

@@ -12,27 +12,28 @@ import { ledgerDerivePrivate } from './derivePrivate';
 import { ledgerMaster } from './master';
 
 export function hdLedger (_mnemonic: string, path: string): Keypair {
-  const parts = _mnemonic
+  const words = _mnemonic
     .split(' ')
     .map((s) => s.trim())
     .filter((s) => s);
 
-  assert([12, 24, 25].includes(parts.length), 'Expected a mnemonic with 24 words (or 25 including a password)');
+  assert([12, 24, 25].includes(words.length), 'Expected a mnemonic with 24 words (or 25 including a password)');
 
-  const [mnemonic, password] = parts.length === 25
-    ? [parts.slice(0, 24).join(' '), parts[24]]
-    : [parts.join(' '), ''];
+  const [mnemonic, password] = words.length === 25
+    ? [words.slice(0, 24).join(' '), words[24]]
+    : [words.join(' '), ''];
 
   assert(mnemonicValidate(mnemonic), 'Invalid mnemonic passed to ledger derivation');
   assert(hdValidatePath(path), 'Invalid derivation path');
 
-  return naclKeypairFromSeed(
-    path
-      .split('/')
-      .slice(1)
-      .map((n) => parseInt(n.replace(/'$/, ''), 10))
-      .map((n) => (n < HARDENED) ? (n + HARDENED) : n)
-      .reduce((x, n) => ledgerDerivePrivate(x, n), ledgerMaster(mnemonic, password))
-      .slice(0, 32)
-  );
+  const parts = path.split('/').slice(1);
+  let seed = ledgerMaster(mnemonic, password);
+
+  for (const p of parts) {
+    const n = parseInt(p.replace(/'$/, ''), 10);
+
+    seed = ledgerDerivePrivate(seed, (n < HARDENED) ? (n + HARDENED) : n);
+  }
+
+  return naclKeypairFromSeed(seed.slice(0, 32));
 }

packages/util-crypto/src/hd/validatePath.ts

@@ -10,9 +10,15 @@ export function hdValidatePath (path: string): boolean {
 
   const parts = path.split('/').slice(1);
 
-  return parts.every((n) => /^\d+'?$/.test(n)) && (
-    !parts
-      .map((n) => parseInt(n.replace(/'$/, ''), 10))
-      .some((n) => isNaN(n) || (n >= HARDENED) || (n < 0))
-  );
+  for (const p of parts) {
+    const n = /^\d+'?$/.test(p)
+      ? parseInt(p.replace(/'$/, ''), 10)
+      : Number.NaN;
+
+    if (isNaN(n) || (n >= HARDENED) || (n < 0)) {
+      return false;
+    }
+  }
+
+  return true;
 }

packages/util-crypto/src/key/extractPath.ts

@@ -23,9 +23,9 @@ export function keyExtractPath (derivePath: string): ExtractResult {
   if (parts) {
     constructed = parts.join('');
 
-    parts.forEach((value: string): void => {
-      path.push(DeriveJunction.from(value.substr(1)));
-    });
+    for (const p of parts) {
+      path.push(DeriveJunction.from(p.substr(1)));
+    }
   }
 
   assert(constructed === derivePath, () => `Re-constructed path "${constructed}" does not match input`);

packages/util-crypto/src/key/fromPath.ts

@@ -18,8 +18,11 @@ const generators = {
 
 export function keyFromPath (pair: Keypair, path: DeriveJunction[], type: KeypairType): Keypair {
   const keyHdkd = generators[type];
+  let result = pair;
 
-  return path.reduce((pair, junction): Keypair => {
-    return keyHdkd(pair, junction);
-  }, pair);
+  for (const junction of path) {
+    result = keyHdkd(result, junction);
+  }
+
+  return result;
 }