[CI Skip] release/stable 8.2.2

skip-checks: true
8.2.2
2021-12-19 07:02:52 +00:00 · 2021-12-19 08:58:36 +02:00 · 2021-12-19 06:54:36 +00:00 · 2021-12-19 08:50:43 +02:00 · 2021-12-19 08:17:43 +02:00 · 2021-12-19 06:02:04 +00:00
286 changed files with 3825 additions and 4965 deletions
@@ -18,4 +18,11 @@
 7.0.2
 7.0.3
 7.1.2
-7.8.2
+7.8.2
+7.9.2
+8.0.2
+8.0.3
+8.0.4
+8.0.5
+8.1.2
+8.2.2
@@ -1,5 +1,21 @@
+checks:
+  argument-count:
+    config:
+      threshold: 5
+  method-complexity:
+    config:
+      threshold: 7
+  method-count:
+    config:
+      threshold: 25
+  method-lines:
+    config:
+      threshold: 30
+
 exclude_patterns:
 - "**/*.spec.js"
 - "**/*.spec.ts"
 - "packages/networks/src/substrate.ts"
 - "packages/util/src/is/utf8.ts"
+- "packages/x-noble-hashes/src/**.ts"
+- "packages/x-noble-secp256k1/src/**.ts"
@@ -0,0 +1,2 @@
+packages/x-noble-hashes/**/*.ts
+packages/x-noble-secp256k1/**/*.ts
@@ -6,18 +6,12 @@ const base = require('@polkadot/dev/config/eslint.cjs');
 module.exports = {
  ...base,
  ignorePatterns: [
-    '.eslintrc.js',
-    '.github/**',
-    '.vscode/**',
-    '.yarn/**',
-    '**/build/*',
-    '**/coverage/*',
-    '**/node_modules/*'
+    ...base.ignorePatterns
  ],
  parserOptions: {
    ...base.parserOptions,
    project: [
-      './tsconfig.json'
+      './tsconfig.eslint.json'
    ]
  },
  rules: {
@@ -2,7 +2,7 @@ name: 'Lock Threads'

 on:
  schedule:
-    - cron: '30 1/2 * * *'
+    - cron: '15 1/3 * * *'

 jobs:
  lock:
@@ -1,7 +1,7 @@
 name: 'Close stale issues and PRs'
 on:
  schedule:
-    - cron: '30 2/2 * * *'
+    - cron: '50 1/3 * * *'

 jobs:
  stale:
@@ -11,7 +11,9 @@ tmp/
 .env.development.local
 .env.test.local
 .env.production.local
+.idea
 .npmrc
+.vscode
 .yarn/*
 !.yarn/releases
 !.yarn/plugins
@@ -24,5 +26,4 @@ yarn-debug.log*
 yarn-error.log*
 store.db
 store.db.compacted
-.idea
-.vscode
+tsconfig.*buildinfo
@@ -1,5 +1,105 @@
 # CHANGELOG

+## 8.2.2 Dec 19, 2021
+
+Contributed:
+
+- Add Bifrost Ledger capabilities (Thanks to https://github.com/awesomepan)
+- Add Sora genesisHash & Ledger capabilities (Thanks to https://github.com/NoodleSploder)
+
+Changes:
+
+- Add `isPromise` check utility function
+- Add `assertUnreachable` for codepaths that should not be followed
+- Preserve all-caps word splits in `stringCamelCase`
+- Adjust `x-*` fallbacks via `x-global/extractGlobal`
+- Sync with upstream Substrate ss58 registry
+- Additional tests for `bip39` wordlists
+- Maintainability cleanups
+- Update to latest Ledger dependencies
+- Swap to upstream `@noble` packages
+- Adjust tsconfig with references
+- 8.2.2 (8.2.1 failed CI due to incorrect CHANGELOG)
+
+
+## 8.1.2 Dec 5, 2021
+
+Changes:
+
+- Adjustment to non-full-word consecutive uppercase via `string{Camel, Pascal}Case`
+
+
+## 8.1.1 Dec 5, 2021
+
+Contributed:
+
+- Add Picasso genesisHash (Thanks to https://github.com/hussein-aitlahcen)
+
+Changes:
+
+- Allow for use of `secp256k1` from `@polkadot/wasm-crypto`
+- Adjust `isBigInt` to not do `instanceof` check
+- Ensure consequtive capitals in `stringCamelCase` are lowercased
+- Use `@polkadot/x-bigint` for `BigInt` constructor
+- Split `@noble/hashes` fork into `x-noble-hashes`
+- Add `@noble/secp256k1` fork into `x-noble-secp256k1`, replaces `elliptic`
+
+
+## 8.0.5 Dec 1, 2021
+
+Changes:
+
+- Adjust sha3 expectation of `BigInt` availability
+
+
+## 8.0.4 Nov 30, 2021
+
+Changes:
+
+- Adjust `stringCamelCase` with leading `_`
+
+
+## 8.0.3 Nov 30, 2021
+
+Changes:
+
+- Remove `Buffer` usage in `x-randomvalues`
+- Adjust `stringCamelCase` for all-caps parts
+
+
+## 8.0.2 Nov 26, 2021
+
+Changes:
+
+- Explicitly include BigInt patched versions
+
+
+## 8.0.1 Nov 26, 2021
+
+**Important** In the 8.0 version the hashing utilities have been consolidated around an optimized and audited version from `@noble/hashes`. As in the past the WASM hashing will be used by default if the environment is initialized.
+
+**Breaking change** The `schnorrkel*` functions have been renamed to `sr25519*`. Likewise the `ed25519` operations have been renamed from `nacl*` to `ed25519*`. Additionally the `{ed, sr, secp256k1}25519KeyPairFrom*` functions have been renamed to `{ed, sr, secp256k1}25519PairFrom*`.
+
+Changes:
+
+- Introduce `ed25519*` & `sr25519*` functions
+- Replace camelcase dep with simplified/optimized version
+- Replace (most) hashing operations with `@noble/hashes`
+- Replace JS fallback for `xxhash`
+- Adjust `BigInt` utility exports (with capability detection)
+- Previously added `bi*` functions renamed to `n*`
+- Extend performance tests with implementation compares
+- Remove non-significant Node Buffer concat fill
+
+
+## 7.9.2 Nov 22, 2021
+
+Changes:
+
+- Fix TS compiled definitions for `base*` types
+- Provide JS/Wasm interfaces for `hmacShaAsU8a`
+
+
 ## 7.9.1 Nov 21, 2021

 Contributed:
@@ -13,8 +13,7 @@ module.exports = Object.assign({}, config, {
    '@polkadot/util-(crypto)(.*)$': '<rootDir>/packages/util-$1/src/$2',
    // eslint-disable-next-line sort-keys
    '@polkadot/util(.*)$': '<rootDir>/packages/util/src/$1',
-    '@polkadot/x-(fetch|randomvalues|textdecoder|textencoder|ws)(.*)$': '<rootDir>/packages/x-$1/src/node',
-    '@polkadot/x-global(.*)$': '<rootDir>/packages/x-global/src/$1',
-    '@polkadot/x-rxjs(.*)$': '<rootDir>/packages/x-rxjs/src/$1'
+    '@polkadot/x-(bigint|global)(.*)$': '<rootDir>/packages/x-$1/src/$2',
+    '@polkadot/x-(fetch|randomvalues|textdecoder|textencoder|ws)(.*)$': '<rootDir>/packages/x-$1/src/node'
  }
 });
@@ -10,7 +10,7 @@
    "url": "https://github.com/polkadot-js/common.git"
  },
  "sideEffects": false,
-  "version": "7.9.1",
+  "version": "8.2.2",
  "workspaces": [
    "packages/*"
  ],
@@ -28,12 +28,12 @@
    "test:one": "polkadot-dev-run-test --runInBand"
  },
  "devDependencies": {
-    "@babel/core": "^7.16.0",
-    "@polkadot/dev": "^0.63.29",
-    "@polkadot/ts": "^0.4.14",
+    "@babel/core": "^7.16.5",
+    "@polkadot/dev": "^0.64.5",
+    "@polkadot/ts": "^0.4.20",
    "@types/jest": "^27.0.3"
  },
  "resolutions": {
-    "typescript": "^4.5.2"
+    "typescript": "^4.5.3"
  }
 }
@@ -16,17 +16,17 @@
  },
  "sideEffects": false,
  "type": "module",
-  "version": "7.9.1",
+  "version": "8.2.2",
  "browser": "browser.js",
  "main": "node.js",
  "react-native": "react-native.js",
  "dependencies": {
-    "@babel/runtime": "^7.16.3",
-    "@ledgerhq/hw-transport": "^6.11.2",
-    "@ledgerhq/hw-transport-webhid": "^6.11.2",
-    "@ledgerhq/hw-transport-webusb": "^6.11.2"
+    "@babel/runtime": "^7.16.5",
+    "@ledgerhq/hw-transport": "^6.20.0",
+    "@ledgerhq/hw-transport-webhid": "^6.20.0",
+    "@ledgerhq/hw-transport-webusb": "^6.20.0"
  },
  "optionalDependencies": {
-    "@ledgerhq/hw-transport-node-hid-singleton": "^6.11.2"
+    "@ledgerhq/hw-transport-node-hid-singleton": "^6.20.0"
  }
 }
@@ -3,4 +3,4 @@

 // Auto-generated by @polkadot/dev, do not edit

-export const packageInfo = { name: '@polkadot/hw-ledger-transports', version: '7.9.1' };
+export const packageInfo = { name: '@polkadot/hw-ledger-transports', version: '8.2.2' };
@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "references": []
+}
@@ -19,12 +19,12 @@
    "./detectPackage.cjs"
  ],
  "type": "module",
-  "version": "7.9.1",
+  "version": "8.2.2",
  "main": "index.js",
  "dependencies": {
-    "@babel/runtime": "^7.16.3",
-    "@polkadot/hw-ledger-transports": "7.9.1",
-    "@polkadot/util": "7.9.1",
-    "@zondax/ledger-substrate": "^0.18.0"
+    "@babel/runtime": "^7.16.5",
+    "@polkadot/hw-ledger-transports": "8.2.2",
+    "@polkadot/util": "8.2.2",
+    "@zondax/ledger-substrate": "^0.23.0"
  }
 }
@@ -1,24 +0,0 @@
-// Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { knownLedger } from '@polkadot/networks/defaults';
-
-import { ledgerApps } from './defaults';
-
-describe('defaults', (): void => {
-  it('has entries for each of the apps (hwledger -> networks)', (): void => {
-    expect(
-      Object.keys(knownLedger).filter((network) =>
-        !ledgerApps[network]
-      )
-    ).toEqual([]);
-  });
-
-  it('has entries for each of the apps (networks -> hwledger)', (): void => {
-    expect(
-      Object.keys(ledgerApps).filter((network) =>
-        !knownLedger[network]
-      )
-    ).toEqual([]);
-  });
-});
@@ -4,10 +4,11 @@
 import type Transport from '@ledgerhq/hw-transport';
 import type { SubstrateApp } from '@zondax/ledger-substrate';

-import { newCentrifugeApp, newDockApp, newEdgewareApp, newEquilibriumApp, newGenshiroApp, newKusamaApp, newNodleApp, newPolkadotApp, newPolymeshApp, newStatemineApp } from '@zondax/ledger-substrate';
+import { newBifrostApp, newCentrifugeApp, newDockApp, newEdgewareApp, newEquilibriumApp, newGenshiroApp, newKusamaApp, newNodleApp, newPolkadotApp, newPolymeshApp, newSoraApp, newStatemineApp } from '@zondax/ledger-substrate';

 // These match up with the keys of the knownLedger object in the @polkadot/networks/defaults.ts
 export const ledgerApps: Record<string, (transport: Transport) => SubstrateApp> = {
+  bifrost: newBifrostApp,
  centrifuge: newCentrifugeApp,
  'dock-mainnet': newDockApp,
  edgeware: newEdgewareApp,
@@ -17,5 +18,6 @@ export const ledgerApps: Record<string, (transport: Transport) => SubstrateApp>
  'nodle-chain': newNodleApp,
  polkadot: newPolkadotApp,
  polymesh: newPolymeshApp,
+  sora: newSoraApp,
  statemine: newStatemineApp
 };
@@ -3,4 +3,4 @@

 // Auto-generated by @polkadot/dev, do not edit

-export const packageInfo = { name: '@polkadot/hw-ledger', version: '7.9.1' };
+export const packageInfo = { name: '@polkadot/hw-ledger', version: '8.2.2' };
@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "references": [
+    { "path": "../hw-ledger-transports" },
+    { "path": "../util" }
+  ]
+}
@@ -20,15 +20,15 @@
    "./detectPackage.cjs"
  ],
  "type": "module",
-  "version": "7.9.1",
+  "version": "8.2.2",
  "main": "index.js",
  "dependencies": {
-    "@babel/runtime": "^7.16.3",
-    "@polkadot/util": "7.9.1",
-    "@polkadot/util-crypto": "7.9.1"
+    "@babel/runtime": "^7.16.5",
+    "@polkadot/util": "8.2.2",
+    "@polkadot/util-crypto": "8.2.2"
  },
  "peerDependencies": {
-    "@polkadot/util": "7.9.1",
-    "@polkadot/util-crypto": "7.9.1"
+    "@polkadot/util": "8.2.2",
+    "@polkadot/util-crypto": "8.2.2"
  }
 }
@@ -369,6 +369,14 @@ describe('keypair', (): void => {
      ).toEqual(ETH_ADDRESS_ONE);
    });

+    it('creates with dev phrase with derivation path specified - addFromUri with type', (): void => {
+      const keyringUntyped = new Keyring();
+
+      expect(
+        keyringUntyped.addFromUri(PHRASE, {}, 'ethereum').address
+      ).toEqual(ETH_ADDRESS_ONE);
+    });
+
    it('encodes a pair toJSON (and decodes)', (): void => {
      const pair = keyring.createFromUri(PHRASE);
      const json = pair.toJson('password');
@@ -5,17 +5,17 @@ import type { EncryptedJsonEncoding, Keypair, KeypairType } from '@polkadot/util
 import type { KeyringInstance, KeyringOptions, KeyringPair, KeyringPair$Json, KeyringPair$Meta } from './types';

 import { assert, hexToU8a, isHex, isUndefined, stringToU8a } from '@polkadot/util';
-import { base64Decode, decodeAddress, encodeAddress, ethereumEncode, hdEthereum, keyExtractSuri, keyFromPath, mnemonicToLegacySeed, mnemonicToMiniSecret, naclKeypairFromSeed as naclFromSeed, schnorrkelKeypairFromSeed as schnorrkelFromSeed, secp256k1KeypairFromSeed as secp256k1FromSeed } from '@polkadot/util-crypto';
+import { base64Decode, decodeAddress, ed25519PairFromSeed as ed25519FromSeed, encodeAddress, ethereumEncode, hdEthereum, keyExtractSuri, keyFromPath, mnemonicToLegacySeed, mnemonicToMiniSecret, secp256k1PairFromSeed as secp256k1FromSeed, sr25519PairFromSeed as sr25519FromSeed } from '@polkadot/util-crypto';

 import { DEV_PHRASE } from './defaults';
 import { createPair } from './pair';
 import { Pairs } from './pairs';

-const keypairFromSeed = {
+const PairFromSeed = {
  ecdsa: (seed: Uint8Array): Keypair => secp256k1FromSeed(seed),
-  ed25519: (seed: Uint8Array): Keypair => naclFromSeed(seed),
+  ed25519: (seed: Uint8Array): Keypair => ed25519FromSeed(seed),
  ethereum: (seed: Uint8Array): Keypair => secp256k1FromSeed(seed),
-  sr25519: (seed: Uint8Array): Keypair => schnorrkelFromSeed(seed)
+  sr25519: (seed: Uint8Array): Keypair => sr25519FromSeed(seed)
 };

 function pairToPublic ({ publicKey }: KeyringPair): Uint8Array {
@@ -142,7 +142,7 @@ export class Keyring implements KeyringInstance {
   */
  public addFromSeed (seed: Uint8Array, meta: KeyringPair$Meta = {}, type: KeypairType = this.type): KeyringPair {
    return this.addPair(
-      createPair({ toSS58: this.encodeAddress, type }, keypairFromSeed[type](seed), meta, null)
+      createPair({ toSS58: this.encodeAddress, type }, PairFromSeed[type](seed), meta, null)
    );
  }

@@ -224,9 +224,9 @@ export class Keyring implements KeyringInstance {

    const derived = type === 'ethereum'
      ? isPhraseHex
-        ? keypairFromSeed[type](seed) // for eth, if the private key is provided as suri, it must be derived only once
+        ? PairFromSeed[type](seed) // for eth, if the private key is provided as suri, it must be derived only once
        : hdEthereum(seed, derivePath.substring(1))
-      : keyFromPath(keypairFromSeed[type](seed), path, type);
+      : keyFromPath(PairFromSeed[type](seed), path, type);

    return createPair({ toSS58: this.encodeAddress, type }, derived, meta, null);
  }
@@ -3,4 +3,4 @@

 // Auto-generated by @polkadot/dev, do not edit

-export const packageInfo = { name: '@polkadot/keyring', version: '7.9.1' };
+export const packageInfo = { name: '@polkadot/keyring', version: '8.2.2' };
@@ -7,7 +7,7 @@ import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta, SignOptions } fro
 import type { PairInfo } from './types';

 import { assert, objectSpread, u8aConcat, u8aEmpty, u8aEq, u8aToHex, u8aToU8a } from '@polkadot/util';
-import { blake2AsU8a, convertPublicKeyToCurve25519, convertSecretKeyToCurve25519, ethereumEncode, keccakAsU8a, keyExtractPath, keyFromPath, naclKeypairFromSeed as naclFromSeed, naclOpen, naclSeal, naclSign, schnorrkelKeypairFromSeed as schnorrkelFromSeed, schnorrkelSign, schnorrkelVrfSign, schnorrkelVrfVerify, secp256k1Compress, secp256k1Expand, secp256k1KeypairFromSeed as secp256k1FromSeed, secp256k1Sign, signatureVerify } from '@polkadot/util-crypto';
+import { blake2AsU8a, convertPublicKeyToCurve25519, convertSecretKeyToCurve25519, ed25519PairFromSeed as ed25519FromSeed, ed25519Sign, ethereumEncode, keccakAsU8a, keyExtractPath, keyFromPath, naclOpen, naclSeal, secp256k1Compress, secp256k1Expand, secp256k1PairFromSeed as secp256k1FromSeed, secp256k1Sign, signatureVerify, sr25519PairFromSeed as sr25519FromSeed, sr25519Sign, sr25519VrfSign, sr25519VrfVerify } from '@polkadot/util-crypto';

 import { decodePair } from './decode';
 import { encodePair } from './encode';
@@ -22,9 +22,9 @@ const SIG_TYPE_NONE = new Uint8Array();

 const TYPE_FROM_SEED = {
  ecdsa: secp256k1FromSeed,
-  ed25519: naclFromSeed,
+  ed25519: ed25519FromSeed,
  ethereum: secp256k1FromSeed,
-  sr25519: schnorrkelFromSeed
+  sr25519: sr25519FromSeed
 };

 const TYPE_PREFIX = {
@@ -36,9 +36,9 @@ const TYPE_PREFIX = {

 const TYPE_SIGNATURE = {
  ecdsa: (m: Uint8Array, p: Partial<Keypair>) => secp256k1Sign(m, p, 'blake2'),
-  ed25519: naclSign,
+  ed25519: ed25519Sign,
  ethereum: (m: Uint8Array, p: Partial<Keypair>) => secp256k1Sign(m, p, 'keccak'),
-  sr25519: schnorrkelSign
+  sr25519: sr25519Sign
 };

 const TYPE_ADDRESS = {
@@ -215,7 +215,7 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
      assert(!isLocked(secretKey), 'Cannot sign with a locked key pair');

      if (type === 'sr25519') {
-        return schnorrkelVrfSign(message, { secretKey }, context, extra);
+        return sr25519VrfSign(message, { secretKey }, context, extra);
      }

      const proof = TYPE_SIGNATURE[type](u8aToU8a(message), { publicKey, secretKey });
@@ -224,7 +224,7 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
    },
    vrfVerify: (message: HexString | string | Uint8Array, vrfResult: Uint8Array, signerPublic: HexString | Uint8Array | string, context?: HexString | string | Uint8Array, extra?: HexString | string | Uint8Array): boolean => {
      if (type === 'sr25519') {
-        return schnorrkelVrfVerify(message, vrfResult, publicKey, context, extra);
+        return sr25519VrfVerify(message, vrfResult, publicKey, context, extra);
      }

      const result = signatureVerify(message, u8aConcat(TYPE_PREFIX[type], vrfResult.subarray(32)), TYPE_ADDRESS[type](u8aToU8a(signerPublic)));
@@ -4,7 +4,7 @@
 import type { KeyringPair } from '../types';

 import { u8aToHex } from '@polkadot/util';
-import { cryptoWaitReady, encodeAddress as toSS58, naclKeypairFromSeed, randomAsU8a, schnorrkelKeypairFromSeed, secp256k1KeypairFromSeed } from '@polkadot/util-crypto';
+import { cryptoWaitReady, ed25519PairFromSeed, encodeAddress as toSS58, randomAsU8a, secp256k1PairFromSeed, sr25519PairFromSeed } from '@polkadot/util-crypto';

 import { createPair } from '.';

@@ -19,9 +19,9 @@ describe('vrf', (): void => {
  beforeAll(async (): Promise<void> => {
    await cryptoWaitReady();

-    ecdsa = createPair({ toSS58, type: 'ecdsa' }, secp256k1KeypairFromSeed(randomAsU8a()));
-    ed25519 = createPair({ toSS58, type: 'ed25519' }, naclKeypairFromSeed(randomAsU8a()));
-    sr25519 = createPair({ toSS58, type: 'sr25519' }, schnorrkelKeypairFromSeed(randomAsU8a()));
+    ecdsa = createPair({ toSS58, type: 'ecdsa' }, secp256k1PairFromSeed(randomAsU8a()));
+    ed25519 = createPair({ toSS58, type: 'ed25519' }, ed25519PairFromSeed(randomAsU8a()));
+    sr25519 = createPair({ toSS58, type: 'sr25519' }, sr25519PairFromSeed(randomAsU8a()));
  });

  it('has deterministic signature values for ecdsa', (): void => {
@@ -3,7 +3,7 @@

 import type { KeyringInstance, KeyringOptions } from './types';

-import { hexToU8a } from '@polkadot/util';
+import { assert, hexToU8a } from '@polkadot/util';
 import { KeypairType } from '@polkadot/util-crypto/types';

 import { Keyring } from './keyring';
@@ -111,6 +111,15 @@ export const PAIRSETHEREUM: PairDef[] = [
  }
 ];

+function createMeta (name?: string, seed?: string) {
+  assert(name || seed, 'Testing pair should have either a name or a seed');
+
+  return {
+    isTesting: true,
+    name: name || (seed && seed.replace('//', '_').toLowerCase())
+  };
+}
+
 /**
 * @name testKeyring
 * @summary Create an instance of Keyring pre-populated with locked test accounts
@@ -119,17 +128,12 @@ export const PAIRSETHEREUM: PairDef[] = [
 */
 export function createTestKeyring (options: KeyringOptions = {}, isDerived = true): KeyringInstance {
  const keyring = new Keyring(options);
-  const pairs: PairDef[] = (options.type && options.type === 'ethereum') ? PAIRSETHEREUM : PAIRSSR25519;
+  const pairs = (options.type && options.type === 'ethereum')
+    ? PAIRSETHEREUM
+    : PAIRSSR25519;

  for (const { name, publicKey, secretKey, seed, type } of pairs) {
-    if (!name && !seed) {
-      throw new Error('Testing pair should have either a name or a seed');
-    }
-
-    const meta = {
-      isTesting: true,
-      name: name || (seed && seed.replace('//', '_').toLowerCase())
-    };
+    const meta = createMeta(name, seed);
    const pair = !isDerived && !name && seed
      ? keyring.addFromUri(seed, meta, options.type)
      : keyring.addPair(
@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "references": [
+    { "path": "../util" },
+    { "path": "../util-crypto" }
+  ]
+}
@@ -17,13 +17,14 @@
  },
  "sideEffects": false,
  "type": "module",
-  "version": "7.9.1",
+  "version": "8.2.2",
  "main": "index.js",
  "dependencies": {
-    "@babel/runtime": "^7.16.3"
+    "@babel/runtime": "^7.16.5"
  },
  "devDependencies": {
-    "@polkadot/util": "7.9.1",
-    "@polkadot/x-fetch": "7.9.1"
+    "@polkadot/hw-ledger": "8.2.2",
+    "@polkadot/util": "8.2.2",
+    "@polkadot/x-fetch": "8.2.2"
  }
 }
@@ -1,25 +1,46 @@
 // Copyright 2017-2021 @polkadot/networks authors & contributors
 // SPDX-License-Identifier: Apache-2.0

+import { ledgerApps } from '@polkadot/hw-ledger/defaults';
 import { isHex } from '@polkadot/util';

 import { knownGenesis, knownLedger } from './defaults';

 describe('defaults', (): void => {
-  it('has hex values for all genesis chains', (): void => {
-    expect(
-      Object.keys(knownGenesis).filter((network) =>
-        !knownGenesis[network].length ||
-        knownGenesis[network].some((g) => !isHex(g, 256))
-      )
-    ).toEqual([]);
+  describe('genesis', (): void => {
+    it('has hex values for all genesis chains', (): void => {
+      expect(
+        Object.keys(knownGenesis).filter((network) =>
+          !knownGenesis[network].length ||
+          knownGenesis[network].some((g) => !isHex(g, 256))
+        )
+      ).toEqual([]);
+    });
+
+    it('has genesis for all Ledger chains', (): void => {
+      expect(
+        Object.keys(knownLedger).filter((network) =>
+          !knownGenesis[network]
+        )
+      ).toEqual([]);
+    });
  });

-  it('has genesis for all Ledger chains', (): void => {
-    expect(
-      Object.keys(knownLedger).filter((network) =>
-        !knownGenesis[network]
-      )
-    ).toEqual([]);
+  describe('Ledger', (): void => {
+    it('has entries for each of the apps (hwledger -> networks)', (): void => {
+      expect(
+        Object.keys(knownLedger).filter((network) =>
+          !ledgerApps[network]
+        )
+      ).toEqual([]);
+    });
+
+    it('has entries for each of the apps (networks -> hwledger)', (): void => {
+      expect(
+        Object.keys(ledgerApps).filter((network) =>
+          !knownLedger[network]
+        )
+      ).toEqual([]);
+    });
  });
 });
@@ -51,6 +51,9 @@ export const knownGenesis: KnownGenesis = {
  'nodle-chain': [
    '0xa3d114c2b8d0627c1aa9b134eafcf7d05ca561fdc19fb388bb9457f81809fb23'
  ],
+  picasso: [
+    '0xe8e7f0f4c4f5a00720b4821dbfddefea7490bcf0b19009961cc46957984e2c1c'
+  ],
  plasm: [
    '0x3e86364d4b4894021cb2a0390bcf2feb5517d5292f2de2bb9404227e908b0b8b'
  ],
@@ -60,6 +63,9 @@ export const knownGenesis: KnownGenesis = {
  polymesh: [
    '0x6fbd74e5e1d0a61d52ccfe9d4adaed16dd3a7caa37c6bc4d0c2fa12e8b2f4063'
  ],
+  sora: [
+    '0x7e4e32d0feafd4f9c9414b0be86373f9a1efa904809b683453a9af6856d38ad5'
+  ],
  stafi: [
    '0x290a4149f09ea0e402c74c1c7e96ae4239588577fe78932f94f5404c68243d80'
  ],
@@ -76,6 +82,7 @@ export const knownIcon: KnownIcon = {
  centrifuge: 'polkadot',
  kusama: 'polkadot',
  polkadot: 'polkadot',
+  sora: 'polkadot',
  statemine: 'polkadot',
  statemint: 'polkadot',
  westmint: 'polkadot'
@@ -85,6 +92,7 @@ export const knownIcon: KnownIcon = {
 // and maps to the known slip44 (minus the `0x8` hard derivation flag)
 // NOTE: Any network here needs to have a genesisHash attached in the config above
 export const knownLedger: KnownLedger = {
+  bifrost: 0x00000314,
  centrifuge: 0x000002eb,
  'dock-mainnet': 0x00000252,
  edgeware: 0x0000020b,
@@ -94,6 +102,7 @@ export const knownLedger: KnownLedger = {
  'nodle-chain': 0x000003eb,
  polkadot: 0x00000162,
  polymesh: 0x00000253,
+  sora: 0x00000269,
  statemine: 0x000001b2 // common-good on Kusama, shares derivation
 };

@@ -3,4 +3,4 @@

 // Auto-generated by @polkadot/dev, do not edit

-export const packageInfo = { name: '@polkadot/networks', version: '7.9.1' };
+export const packageInfo = { name: '@polkadot/networks', version: '8.2.2' };
@@ -504,12 +504,21 @@ export const knownSubstrate: KnownSubstrate[] = [
    website: 'https://crust.network'
  },
  {
-    decimals: [0, 9, 9, 9, 9, 9, 9, 9],
-    displayName: 'Equilibrium Network',
-    network: 'equilibrium',
+    decimals: [9, 9, 9],
+    displayName: 'Genshiro Network',
+    network: 'genshiro',
    prefix: 67,
    standardAccount: '*25519',
-    symbols: ['Unknown', 'USD', 'EQ', 'ETH', 'BTC', 'EOS', 'DOT', 'CRV'],
+    symbols: ['GENS', 'EQD', 'LPT0'],
+    website: 'https://genshiro.equilibrium.io'
+  },
+  {
+    decimals: [9],
+    displayName: 'Equilibrium Network',
+    network: 'equilibrium',
+    prefix: 68,
+    standardAccount: '*25519',
+    symbols: ['EQ'],
    website: 'https://equilibrium.io'
  },
  {
@@ -531,12 +540,12 @@ export const knownSubstrate: KnownSubstrate[] = [
    website: 'https://zeitgeist.pm'
  },
  {
-    decimals: [12],
+    decimals: [18],
    displayName: 'Manta network',
    network: 'manta',
    prefix: 77,
    standardAccount: '*25519',
-    symbols: ['MA'],
+    symbols: ['MANTA'],
    website: 'https://manta.network'
  },
  {
@@ -665,6 +674,15 @@ export const knownSubstrate: KnownSubstrate[] = [
    symbols: ['NEER'],
    website: 'https://bit.country'
  },
+  {
+    decimals: [18],
+    displayName: 'Efinity',
+    network: 'efinity',
+    prefix: 1110,
+    standardAccount: 'Sr25519',
+    symbols: ['EFI'],
+    website: 'https://efinity.io/'
+  },
  {
    decimals: [18],
    displayName: 'Moonbeam',
@@ -692,6 +710,24 @@ export const knownSubstrate: KnownSubstrate[] = [
    symbols: ['KAPEX'],
    website: 'https://totemaccounting.com'
  },
+  {
+    decimals: [10],
+    displayName: 'Interlay',
+    network: 'interlay',
+    prefix: 2032,
+    standardAccount: '*25519',
+    symbols: ['INTR'],
+    website: 'https://interlay.io/'
+  },
+  {
+    decimals: [12],
+    displayName: 'Kintsugi',
+    network: 'kintsugi',
+    prefix: 2092,
+    standardAccount: '*25519',
+    symbols: ['KINT'],
+    website: 'https://interlay.io/'
+  },
  {
    decimals: [18],
    displayName: 'Subspace testnet',
@@ -723,7 +759,7 @@ export const knownSubstrate: KnownSubstrate[] = [
    decimals: [12],
    displayName: 'CESS Testnet',
    network: 'cess-testnet',
-    prefix: 10042,
+    prefix: 11330,
    standardAccount: '*25519',
    symbols: ['TCESS'],
    website: 'https://cess.cloud'
@@ -732,7 +768,7 @@ export const knownSubstrate: KnownSubstrate[] = [
    decimals: [12],
    displayName: 'CESS',
    network: 'cess',
-    prefix: 10043,
+    prefix: 11331,
    standardAccount: '*25519',
    symbols: ['CESS'],
    website: 'https://cess.cloud'
@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "references": [
+    { "path": "../hw-ledger" },
+    { "path": "../util" },
+    { "path": "../x-fetch" }
+  ]
+}
@@ -22,35 +22,29 @@
    "./detectPackage.cjs"
  ],
  "type": "module",
-  "version": "7.9.1",
+  "version": "8.2.2",
+  "browser": {
+    "crypto": false,
+    "stream": false
+  },
  "main": "index.js",
  "dependencies": {
-    "@babel/runtime": "^7.16.3",
-    "@polkadot/networks": "7.9.1",
-    "@polkadot/util": "7.9.1",
-    "@polkadot/wasm-crypto": "^4.3.1",
-    "@polkadot/x-randomvalues": "7.9.1",
-    "blakejs": "^1.1.1",
-    "bn.js": "^4.12.0",
-    "create-hash": "^1.2.0",
+    "@babel/runtime": "^7.16.5",
+    "@noble/hashes": "^0.4.5",
+    "@noble/secp256k1": "^1.3.4",
+    "@polkadot/networks": "8.2.2",
+    "@polkadot/util": "8.2.2",
+    "@polkadot/wasm-crypto": "^4.5.1",
+    "@polkadot/x-bigint": "8.2.2",
+    "@polkadot/x-randomvalues": "8.2.2",
    "ed2curve": "^0.3.0",
-    "elliptic": "^6.5.4",
-    "hash.js": "^1.1.7",
-    "js-sha3": "^0.8.0",
-    "micro-base": "^0.9.0",
-    "scryptsy": "^2.1.0",
-    "tweetnacl": "^1.0.3",
-    "xxhashjs": "^0.2.2"
+    "micro-base": "^0.10.0",
+    "tweetnacl": "^1.0.3"
  },
  "devDependencies": {
-    "@types/bn.js": "^4.11.6",
-    "@types/create-hash": "^1.2.2",
-    "@types/ed2curve": "^0.2.2",
-    "@types/elliptic": "^6.4.14",
-    "@types/scryptsy": "^2.0.0",
-    "@types/xxhashjs": "^0.2.2"
+    "@types/ed2curve": "^0.2.2"
  },
  "peerDependencies": {
-    "@polkadot/util": "7.9.1"
+    "@polkadot/util": "8.2.2"
  }
 }
@@ -3,21 +3,15 @@

 import { hexToU8a, stringToU8a, u8aToHex } from '@polkadot/util';

-import { createTestPairs, TestKeyringMap } from '../../../keyring/src/testingPairs';
+import { ALICE_PUBLIC_SR } from './encode.spec';
 import { decodeAddress } from '.';

 describe('decodeAddress', (): void => {
-  let keyring: TestKeyringMap;
-
-  beforeAll((): void => {
-    keyring = createTestPairs({ type: 'sr25519' });
-  });
-
  it('decodes an address', (): void => {
    expect(
      decodeAddress('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY')
    ).toEqual(
-      keyring.alice.publicKey
+      ALICE_PUBLIC_SR
    );
  });

@@ -8,7 +8,7 @@ import type { Prefix } from './types';
 import { assert } from '@polkadot/util';

 import { keyExtractPath } from '../key';
-import { schnorrkelDerivePublic } from '../schnorrkel';
+import { sr25519DerivePublic } from '../sr25519';
 import { decodeAddress } from './decode';
 import { encodeAddress } from './encode';

@@ -30,7 +30,7 @@ export function deriveAddress (who: HexString | Uint8Array | string, suri: strin
  let publicKey = decodeAddress(who);

  for (const { chainCode } of path) {
-    publicKey = schnorrkelDerivePublic(publicKey, chainCode);
+    publicKey = sr25519DerivePublic(publicKey, chainCode);
  }

  return encodeAddress(publicKey, ss58Format);
@@ -1,11 +1,11 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import { createTestPairs } from '@polkadot/keyring/testingPairs';
-
 import { encodeAddress } from '.';

-const keyring = createTestPairs({ type: 'ed25519' }, false);
+export const ALICE_PUBLIC_SR = new Uint8Array([212, 53, 147, 199, 21, 253, 211, 28, 97, 20, 26, 189, 4, 169, 159, 214, 130, 44, 133, 88, 133, 76, 205, 227, 154, 86, 132, 231, 165, 109, 162, 125]);
+
+export const ALICE_PUBLIC_ED = new Uint8Array([209, 114, 167, 76, 218, 76, 134, 89, 18, 195, 43, 160, 168, 10, 87, 174, 105, 171, 174, 65, 14, 92, 203, 89, 222, 232, 78, 47, 68, 50, 219, 79]);

 const SUBKEY = [
  {
@@ -69,7 +69,7 @@ const SUBKEY = [
 describe('encode', (): void => {
  it('encodes an address to a valid value', (): void => {
    expect(
-      keyring.alice.address
+      encodeAddress(ALICE_PUBLIC_ED)
    ).toEqual('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua');
  });

@@ -88,7 +88,7 @@ describe('encode', (): void => {
  it('fails when non-valid publicKey provided', (): void => {
    expect(
      (): string => encodeAddress(
-        keyring.alice.publicKey.slice(0, 30)
+        ALICE_PUBLIC_ED.slice(0, 30)
      )
    ).toThrow(/Expected a valid key/);
  });
@@ -141,7 +141,7 @@ describe('encode', (): void => {

  it('encodes with 2 byte prefix', (): void => {
    expect(
-      encodeAddress(keyring.alice.publicKey, 255)
+      encodeAddress(ALICE_PUBLIC_ED, 255)
    ).toEqual('yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k');
  });

@@ -155,19 +155,19 @@ describe('encode', (): void => {

  it('does not encode for > 16,383, < 0', (): void => {
    expect(
-      () => encodeAddress(keyring.alice.publicKey, -1)
+      () => encodeAddress(ALICE_PUBLIC_ED, -1)
    ).toThrow(/range ss58Format specified/);
    expect(
-      () => encodeAddress(keyring.alice.publicKey, 16384)
+      () => encodeAddress(ALICE_PUBLIC_ED, 16384)
    ).toThrow(/range ss58Format specified/);
  });

  it('does not encode reserved', (): void => {
    expect(
-      () => encodeAddress(keyring.alice.publicKey, 46)
+      () => encodeAddress(ALICE_PUBLIC_ED, 46)
    ).toThrow(/range ss58Format specified/);
    expect(
-      () => encodeAddress(keyring.alice.publicKey, 47)
+      () => encodeAddress(ALICE_PUBLIC_ED, 47)
    ).toThrow(/range ss58Format specified/);
  });
 });
@@ -1,8 +1,7 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import { createTestPairs } from '@polkadot/keyring/testingPairs';
-
+import { ALICE_PUBLIC_SR } from './encode.spec';
 import { addressEq } from '.';

 describe('addressEq', (): void => {
@@ -34,12 +33,10 @@ describe('addressEq', (): void => {
  });

  it('returns true for equal, address vs publicKey', (): void => {
-    const keyring = createTestPairs({ type: 'sr25519' });
-
    expect(
      addressEq(
        '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
-        keyring.alice.publicKey
+        ALICE_PUBLIC_SR
      )
    ).toEqual(true);
  });
@@ -5,9 +5,9 @@ import type { HexString } from '@polkadot/util/types';
 import type { HashType } from '../secp256k1/types';
 import type { Prefix } from './types';

-import { u8aConcat } from '@polkadot/util';
+import { assert, u8aConcat } from '@polkadot/util';

-import { secp256k1Hasher } from '../secp256k1/hasher';
+import { hasher } from '../secp256k1/hasher';
 import { encodeAddress } from './encode';

 /**
@@ -15,15 +15,9 @@ import { encodeAddress } from './encode';
 * @summary Converts an EVM address to its corresponding SS58 address.
 */
 export function evmToAddress (evmAddress: HexString | string | Uint8Array, ss58Format?: Prefix, hashType: HashType = 'blake2'): string {
-  const wrapError = (message: string) => `Converting ${evmAddress as string}: ${message}`;
-
  const message = u8aConcat('evm:', evmAddress);

-  if (message.length !== 24) {
-    throw new Error(wrapError('Invalid evm address length'));
-  }
+  assert(message.length === 24, () => `Converting ${evmAddress as string}: Invalid evm address length`);

-  const address = secp256k1Hasher(hashType, message);
-
-  return encodeAddress(address, ss58Format);
+  return encodeAddress(hasher(hashType, message), ss58Format);
 }
@@ -5,20 +5,20 @@ import { utils } from 'micro-base';

 import { createDecode, createEncode, createIs, createValidate } from './helpers';

-const BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
+const chars = 'abcdefghijklmnopqrstuvwxyz234567';

-const BASE32_CONFIG = {
-  alphabet: BASE32_ALPHABET,
+const config = {
+  chars,
  coder: utils.chain(
    // We define our own chain, the default base32 has padding
    utils.radix2(5),
-    utils.alphabet(BASE32_ALPHABET),
+    utils.alphabet(chars),
    {
      decode: (input: string) => input.split(''),
      encode: (input: string[]) => input.join('')
    }
  ),
-  ipfsChar: 'b',
+  ipfs: 'b',
  type: 'base32'
 };

@@ -28,7 +28,7 @@ const BASE32_CONFIG = {
 * @description
 * Validates that the supplied value is valid base32, throwing exceptions if not
 */
-export const base32Validate = createValidate(BASE32_CONFIG);
+export const base32Validate = createValidate(config);

 /**
 * @name isBase32
@@ -42,7 +42,7 @@ export const isBase32 = createIs(base32Validate);
 * @description
 * From the provided input, decode the base32 and return the result as an `Uint8Array`.
 */
-export const base32Decode = createDecode(BASE32_CONFIG, base32Validate);
+export const base32Decode = createDecode(config, base32Validate);

 /**
 * @name base32Encode
@@ -50,4 +50,4 @@ export const base32Decode = createDecode(BASE32_CONFIG, base32Validate);
 * @description
 * From the provided input, create the base32 and return the result as a string.
 */
-export const base32Encode = createEncode(BASE32_CONFIG);
+export const base32Encode = createEncode(config);
@@ -5,15 +5,18 @@ import type { U8aLike } from '@polkadot/util/types';

 import { assert, u8aToU8a } from '@polkadot/util';

+// re-export the type so *.d.ts files don't have ../src imports
+export type { U8aLike } from '@polkadot/util/types';
+
 interface Coder {
  decode: (value: string) => Uint8Array;
  encode: (value: Uint8Array) => string;
 }

 interface Config {
-  alphabet: string;
+  chars: string;
  coder: Coder;
-  ipfsChar?: string;
+  ipfs?: string;
  regex?: RegExp;
  type: string;
 }
@@ -24,24 +27,24 @@ type EncodeFn = (value: U8aLike, ipfsCompat?: boolean) => string;

 type ValidateFn = (value?: unknown, ipfsCompat?: boolean) => value is string;

-export function createDecode ({ coder, ipfsChar }: Config, validate: ValidateFn): DecodeFn {
+export function createDecode ({ coder, ipfs }: Config, validate: ValidateFn): DecodeFn {
  return (value: string, ipfsCompat?: boolean): Uint8Array => {
    validate(value, ipfsCompat);

    return coder.decode(
-      ipfsChar && ipfsCompat
+      ipfs && ipfsCompat
        ? value.substr(1)
        : value
    );
  };
 }

-export function createEncode ({ coder, ipfsChar }: Config): EncodeFn {
+export function createEncode ({ coder, ipfs }: Config): EncodeFn {
  return (value: U8aLike, ipfsCompat?: boolean): string => {
    const out = coder.encode(u8aToU8a(value));

-    return ipfsChar && ipfsCompat
-      ? `${ipfsChar}${out}`
+    return ipfs && ipfsCompat
+      ? `${ipfs}${out}`
      : out;
  };
 }
@@ -56,20 +59,24 @@ export function createIs (validate: ValidateFn): ValidateFn {
  };
 }

-export function createValidate ({ alphabet, ipfsChar, regex, type }: Config): ValidateFn {
+export function createValidate ({ chars, ipfs, type }: Config): ValidateFn {
  return (value?: unknown, ipfsCompat?: boolean): value is string => {
    assert(value && typeof value === 'string', () => `Expected non-null, non-empty ${type} string input`);

-    if (ipfsChar && ipfsCompat) {
-      assert(value[0] === ipfsChar, () => `Expected ipfs-compatible ${type} to start with '${ipfsChar}'`);
+    if (ipfs && ipfsCompat) {
+      assert(value[0] === ipfs, () => `Expected ipfs-compatible ${type} to start with '${ipfs}'`);
    }

-    if (regex) {
-      assert(regex.test(value), `Invalid ${type} encoding`);
-    } else {
-      for (let i = (ipfsCompat ? 1 : 0); i < value.length; i++) {
-        assert(alphabet.includes(value[i]), () => `Invalid ${type} character "${value[i]}" (0x${value.charCodeAt(i).toString(16)}) at index ${i}`);
-      }
+    for (let i = (ipfsCompat ? 1 : 0); i < value.length; i++) {
+      assert(
+        chars.includes(value[i]) || (
+          value[i] === '=' && (
+            (i === value.length - 1) ||
+            !chars.includes(value[i + 1])
+          )
+        ),
+        () => `Invalid ${type} character "${value[i]}" (0x${value.charCodeAt(i).toString(16)}) at index ${i}`
+      );
    }

    return true;
@@ -5,10 +5,10 @@ import { base58 } from 'micro-base';

 import { createDecode, createEncode, createIs, createValidate } from '../base32/helpers';

-const BASE58_CONFIG = {
-  alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz',
+const config = {
+  chars: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz',
  coder: base58,
-  ipfsChar: 'z',
+  ipfs: 'z',
  type: 'base58'
 };

@@ -18,7 +18,7 @@ const BASE58_CONFIG = {
 * @description
 * Validates that the supplied value is valid base58, throwing exceptions if not
 */
-export const base58Validate = createValidate(BASE58_CONFIG);
+export const base58Validate = createValidate(config);

 /**
 * @name base58Decode
@@ -26,7 +26,7 @@ export const base58Validate = createValidate(BASE58_CONFIG);
 * @description
 * From the provided input, decode the base58 and return the result as an `Uint8Array`.
 */
-export const base58Decode = createDecode(BASE58_CONFIG, base58Validate);
+export const base58Decode = createDecode(config, base58Validate);

 /**
 * @name base58Encode
@@ -34,7 +34,7 @@ export const base58Decode = createDecode(BASE58_CONFIG, base58Validate);
 * @description
 * From the provided input, create the base58 and return the result as a string.
 */
-export const base58Encode = createEncode(BASE58_CONFIG);
+export const base58Encode = createEncode(config);

 /**
 * @name isBase58
@@ -5,10 +5,9 @@ import { base64 } from 'micro-base';

 import { createDecode, createEncode, createIs, createValidate } from '../base32/helpers';

-const BASE64_CONFIG = {
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+const config = {
+  chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
  coder: base64,
-  regex: /^(?:[A-Za-z0-9+/]{2}[A-Za-z0-9+/]{2})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/,
  type: 'base64'
 };

@@ -18,7 +17,7 @@ const BASE64_CONFIG = {
 * @description
 * Validates that the supplied value is valid base64
 */
-export const base64Validate = createValidate(BASE64_CONFIG);
+export const base64Validate = createValidate(config);

 /**
 * @name isBase64
@@ -32,7 +31,7 @@ export const isBase64 = createIs(base64Validate);
 * @description
 * From the provided input, decode the base64 and return the result as an `Uint8Array`.
 */
-export const base64Decode = createDecode(BASE64_CONFIG, base64Validate);
+export const base64Decode = createDecode(config, base64Validate);

 /**
 * @name base64Encode
@@ -40,4 +39,4 @@ export const base64Decode = createDecode(BASE64_CONFIG, base64Validate);
 * @description
 * From the provided input, create the base64 and return the result as a string.
 */
-export const base64Encode = createEncode(BASE64_CONFIG);
+export const base64Encode = createEncode(config);
@@ -6,11 +6,27 @@ import { stringToU8a } from '@polkadot/util';
 import { base64Decode } from '.';

 describe('base64Decode', (): void => {
-  it('decodes a mixed base64 utf8 string', (): void => {
+  it('decodes a mixed base64 utf8 string (1)', (): void => {
    expect(
      base64Decode('aGVsbG8gd29ybGQg0J/RgNC40LLQtdGC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==')
    ).toEqual(
      stringToU8a('hello world Приветствую ми 你好')
    );
  });
+
+  it('decodes a mixed base64 utf8 string (2)', (): void => {
+    expect(
+      base64Decode('4pyTIMOgIGxhIG1vZGU=')
+    ).toEqual(
+      stringToU8a('✓ à la mode')
+    );
+  });
+
+  it('decodes a mixed base64 utf8 string (3)', (): void => {
+    expect(
+      base64Decode('SGVsbG8gV29ybGQh')
+    ).toEqual(
+      stringToU8a('Hello World!')
+    );
+  });
 });
@@ -7,6 +7,6 @@ describe('base64Validate', (): void => {
  it('validates a mixed base64 utf8 string', (): void => {
    expect(
      () => base64Validate('aGVsbG8gd29ybGQg0J/RgNC40LLQtd^GC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==')
-    ).toThrow(/Invalid base64 encoding/);
+    ).toThrow(/Invalid base64 character "\^" \(0x5e\) at index 30/);
  });
 });
@@ -1,28 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { HexString } from '@polkadot/util/types';
-
-import { u8aToHex } from '@polkadot/util';
-
-import { blake2AsU8a } from './asU8a';
-
-/**
- * @name blake2AsHex
- * @summary Creates a blake2b hex from the input.
- * @description
- * From a `Uint8Array` input, create the blake2b and return the result as a hex string with the specified `bitLength`.
- * @example
- * <BR>
- *
- * ```javascript
- * import { blake2AsHex } from '@polkadot/util-crypto';
- *
- * blake2AsHex('abc'); // => 0xba80a53f981c4d0d
- * ```
- */
-export function blake2AsHex (data: HexString | Uint8Array | string, bitLength = 256, key?: Uint8Array | null, onlyJs = false): HexString {
-  return u8aToHex(
-    blake2AsU8a(data, bitLength, key, onlyJs)
-  );
-}
@@ -4,7 +4,7 @@
 import { hexToU8a } from '@polkadot/util';
 import { waitReady } from '@polkadot/wasm-crypto';

-import { performanceTest } from '../../test/performance';
+import { performanceWasm } from '../test/performance';
 import { blake2AsU8a } from '.';

 describe('blake2AsU8a', (): void => {
@@ -61,7 +61,7 @@ describe('blake2AsU8a', (): void => {
  });

  describe.each([256, 512] as (256 | 512)[])('bitLength=$p', (bitLength): void => {
-    performanceTest(`blake2AsU8a, bitLength=${bitLength}`, 64000, (input, onlyJs) =>
+    performanceWasm(`blake2AsU8a, bitLength=${bitLength}`, 64000, (input, onlyJs) =>
      blake2AsU8a(input, bitLength, null, onlyJs)
    );
  });
@@ -3,11 +3,15 @@

 import type { HexString } from '@polkadot/util/types';

-import js from 'blakejs';
+import { blake2b as blake2bJs } from '@noble/hashes/lib/blake2b';

-import { u8aToU8a } from '@polkadot/util';
+import { hasBigInt, u8aToU8a } from '@polkadot/util';
 import { blake2b, isReady } from '@polkadot/wasm-crypto';

+import { createAsHex } from '../helpers';
+
+type BitLength = 64 | 128 | 256 | 384 | 512;
+
 /**
 * @name blake2AsU8a
 * @summary Creates a blake2b u8a from the input.
@@ -22,11 +26,17 @@ import { blake2b, isReady } from '@polkadot/wasm-crypto';
 * blake2AsU8a('abc'); // => [0xba, 0x80, 0xa5, 0x3f, 0x98, 0x1c, 0x4d, 0x0d]
 * ```
 */
-export function blake2AsU8a (data: HexString | Uint8Array | string, bitLength = 256, key?: Uint8Array | null, onlyJs = false): Uint8Array {
+export function blake2AsU8a (data: HexString | Uint8Array | string, bitLength: BitLength = 256, key?: Uint8Array | null, onlyJs?: boolean): Uint8Array {
  const byteLength = Math.ceil(bitLength / 8);
  const u8a = u8aToU8a(data);

-  return isReady() && !onlyJs
+  return !hasBigInt || (!onlyJs && isReady())
    ? blake2b(u8a, u8aToU8a(key), byteLength)
-    : js.blake2b(u8a, key || undefined, byteLength);
+    : blake2bJs(u8a, { dkLen: byteLength, key: key || undefined });
 }
+
+/**
+ * @name blake2AsHex
+ * @description Creates a blake2b hex from the input.
+ */
+export const blake2AsHex = createAsHex(blake2AsU8a);
@@ -5,5 +5,4 @@
 * @summary Create blake2b values with specified bitlengths
 */

-export { blake2AsHex } from './asHex';
-export { blake2AsU8a } from './asU8a';
+export { blake2AsHex, blake2AsU8a } from './asU8a';
@@ -1,6 +1,7 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

+export const BN_BE_OPTS = { isLe: false };
 export const BN_LE_OPTS = { isLe: true };

 export const BN_LE_16_OPTS = { bitLength: 16, isLe: true };
@@ -12,6 +12,7 @@ export * from './base58';
 export * from './base64';
 export * from './blake2';
 export * from './crypto';
+export * from './ed25519';
 export * from './ethereum';
 export * from './hd';
 export * from './hmac';
@@ -23,9 +24,9 @@ export * from './networks';
 export * from './nacl';
 export * from './pbkdf2';
 export * from './random';
-export * from './schnorrkel';
 export * from './scrypt';
 export * from './secp256k1';
 export * from './sha';
 export * from './signature';
+export * from './sr25519';
 export * from './xxhash';
@@ -1,7 +1,19 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

+import '@polkadot/x-bigint/shim';
+
+import { utils as utilsNobleSecp256k1 } from '@noble/secp256k1';
+
+import { u8aConcat } from '@polkadot/util';
+
 import { cryptoWaitReady } from './crypto';
+import { hmacSha256AsU8a } from './hmac';
+
+// Set overrides on the secp256k1 utils
+//   - hmacShaSync - This needs to be set, unset by default
+utilsNobleSecp256k1.hmacSha256Sync = (key: Uint8Array, ...messages: Uint8Array[]) =>
+  hmacSha256AsU8a(key, u8aConcat(...messages));

 // start init process immediately
 cryptoWaitReady().catch((): void => {
@@ -7,7 +7,7 @@ import { blake2AsU8a } from '../blake2/asU8a';

 const HDKD = compactAddLength(stringToU8a('Ed25519HDKD'));

-export function naclDeriveHard (seed: Uint8Array, chainCode: Uint8Array): Uint8Array {
+export function ed25519DeriveHard (seed: Uint8Array, chainCode: Uint8Array): Uint8Array {
  assert(isU8a(chainCode) && chainCode.length === 32, 'Invalid chainCode passed to derive');

  return blake2AsU8a(
@@ -0,0 +1,14 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @summary Implements ed25519 operations
+ */
+export { convertPublicKeyToCurve25519, convertSecretKeyToCurve25519 } from './convertKey';
+export { ed25519DeriveHard } from './deriveHard';
+export { ed25519PairFromRandom } from './pair/fromRandom';
+export { ed25519PairFromSecret } from './pair/fromSecret';
+export { ed25519PairFromSeed } from './pair/fromSeed';
+export { ed25519PairFromString } from './pair/fromString';
+export { ed25519Sign } from './sign';
+export { ed25519Verify } from './verify';
@@ -3,13 +3,13 @@

 import type { Keypair } from '../../types';

-import { naclKeypairFromRandom } from '..';
+import { ed25519PairFromRandom } from '..';

-describe('naclKeypairFromRandom', (): void => {
+describe('ed25519PairFromRandom', (): void => {
  let keypair: Keypair;

  beforeEach((): void => {
-    keypair = naclKeypairFromRandom();
+    keypair = ed25519PairFromRandom();
  });

  it('generates a valid publicKey', (): void => {
@@ -3,10 +3,11 @@

 import type { Keypair } from '../../types';

-import nacl from 'tweetnacl';
+import { randomAsU8a } from '../../random';
+import { ed25519PairFromSeed } from './fromSeed';

 /**
- * @name naclKeypairFromRandom
+ * @name ed25519PairFromRandom
 * @summary Creates a new public/secret keypair.
 * @description
 * Returns a new generate object containing a `publicKey` & `secretKey`.
@@ -14,11 +15,11 @@ import nacl from 'tweetnacl';
 * <BR>
 *
 * ```javascript
- * import { naclKeypairFromRandom } from '@polkadot/util-crypto';
+ * import { ed25519PairFromRandom } from '@polkadot/util-crypto';
 *
- * naclKeypairFromRandom(); // => { secretKey: [...], publicKey: [...] }
+ * ed25519PairFromRandom(); // => { secretKey: [...], publicKey: [...] }
 * ```
 */
-export function naclKeypairFromRandom (): Keypair {
-  return nacl.sign.keyPair();
+export function ed25519PairFromRandom (): Keypair {
+  return ed25519PairFromSeed(randomAsU8a());
 }
@@ -1,9 +1,9 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import { naclKeypairFromSecret } from '..';
+import { ed25519PairFromSecret } from '..';

-describe('naclKeypairFromSecret', (): void => {
+describe('ed25519PairFromSecret', (): void => {
  const secretKey = new Uint8Array([
    18, 52, 86, 120, 144, 18, 52, 86,
    120, 144, 18, 52, 86, 120, 144, 18,
@@ -17,7 +17,7 @@ describe('naclKeypairFromSecret', (): void => {

  it('generates a valid publicKey/secretKey pair', (): void => {
    expect(
-      naclKeypairFromSecret(secretKey)
+      ed25519PairFromSecret(secretKey)
    ).toEqual({
      publicKey: new Uint8Array([
        180, 114, 93, 155, 165, 255, 217, 82,
@@ -6,7 +6,7 @@ import type { Keypair } from '../../types';
 import nacl from 'tweetnacl';

 /**
- * @name naclKeypairFromSecret
+ * @name ed25519PairFromSecret
 * @summary Creates a new public/secret keypair from a secret.
 * @description
 * Returns a object containing a `publicKey` & `secretKey` generated from the supplied secret.
@@ -14,11 +14,11 @@ import nacl from 'tweetnacl';
 * <BR>
 *
 * ```javascript
- * import { naclKeypairFromSecret } from '@polkadot/util-crypto';
+ * import { ed25519PairFromSecret } from '@polkadot/util-crypto';
 *
- * naclKeypairFromSecret(...); // => { secretKey: [...], publicKey: [...] }
+ * ed25519PairFromSecret(...); // => { secretKey: [...], publicKey: [...] }
 * ```
 */
-export function naclKeypairFromSecret (secret: Uint8Array): Keypair {
+export function ed25519PairFromSecret (secret: Uint8Array): Keypair {
  return nacl.sign.keyPair.fromSecretKey(secret);
 }
@@ -4,9 +4,9 @@
 import { stringToU8a } from '@polkadot/util';
 import { waitReady } from '@polkadot/wasm-crypto';

-import { naclKeypairFromSeed } from '..';
+import { ed25519PairFromSeed } from '..';

-describe('naclKeypairFromSeed', (): void => {
+describe('ed25519PairFromSeed', (): void => {
  // NOTE: Aligned with Rust test, b"12345678901234567890123456789012"
  const TEST = stringToU8a('12345678901234567890123456789012');
  const RESULT = {
@@ -33,7 +33,7 @@ describe('naclKeypairFromSeed', (): void => {
  it('generates a valid publicKey/secretKey pair (u8a)', (): void => {
    [true, false].forEach((onlyJs): void => {
      expect(
-        naclKeypairFromSeed(TEST, onlyJs)
+        ed25519PairFromSeed(TEST, onlyJs)
      ).toEqual(RESULT);
    });
  });
@@ -8,7 +8,7 @@ import nacl from 'tweetnacl';
 import { ed25519KeypairFromSeed, isReady } from '@polkadot/wasm-crypto';

 /**
- * @name naclKeypairFromSeed
+ * @name ed25519PairFromSeed
 * @summary Creates a new public/secret keypair from a seed.
 * @description
 * Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
@@ -16,12 +16,12 @@ import { ed25519KeypairFromSeed, isReady } from '@polkadot/wasm-crypto';
 * <BR>
 *
 * ```javascript
- * import { naclKeypairFromSeed } from '@polkadot/util-crypto';
+ * import { ed25519PairFromSeed } from '@polkadot/util-crypto';
 *
- * naclKeypairFromSeed(...); // => { secretKey: [...], publicKey: [...] }
+ * ed25519PairFromSeed(...); // => { secretKey: [...], publicKey: [...] }
 * ```
 */
-export function naclKeypairFromSeed (seed: Uint8Array, onlyJs = false): Keypair {
+export function ed25519PairFromSeed (seed: Uint8Array, onlyJs?: boolean): Keypair {
  if (!onlyJs && isReady()) {
    const full = ed25519KeypairFromSeed(seed);

@@ -1,12 +1,12 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import { naclKeypairFromString } from '..';
+import { ed25519PairFromString } from '..';

-describe('naclKeypairFromSeed', (): void => {
+describe('ed25519PairFromSeed', (): void => {
  it('generates a valid publicKey/secretKey pair', (): void => {
    expect(
-      naclKeypairFromString('test')
+      ed25519PairFromString('test')
    ).toEqual({
      publicKey: new Uint8Array([188, 108, 179, 142, 36, 142, 76, 87, 77, 193, 147, 139, 254, 110, 196, 217, 117, 233, 167, 165, 250, 150, 247, 237, 198, 68, 129, 4, 211, 209, 136, 48]),
      secretKey: new Uint8Array([146, 139, 32, 54, 105, 67, 226, 175, 209, 30, 188, 14, 174, 46, 83, 169, 59, 241, 119, 164, 252, 243, 91, 204, 100, 213, 3, 112, 78, 101, 226, 2, 188, 108, 179, 142, 36, 142, 76, 87, 77, 193, 147, 139, 254, 110, 196, 217, 117, 233, 167, 165, 250, 150, 247, 237, 198, 68, 129, 4, 211, 209, 136, 48])
@@ -6,10 +6,10 @@ import type { Keypair } from '../../types';
 import { stringToU8a } from '@polkadot/util';

 import { blake2AsU8a } from '../../blake2/asU8a';
-import { naclKeypairFromSeed } from './fromSeed';
+import { ed25519PairFromSeed } from './fromSeed';

 /**
- * @name naclKeypairFromString
+ * @name ed25519PairFromString
 * @summary Creates a new public/secret keypair from a string.
 * @description
 * Returns a object containing a `publicKey` & `secretKey` generated from the supplied string. The string is hashed and the value used as the input seed.
@@ -17,16 +17,15 @@ import { naclKeypairFromSeed } from './fromSeed';
 * <BR>
 *
 * ```javascript
- * import { naclKeypairFromString } from '@polkadot/util-crypto';
+ * import { ed25519PairFromString } from '@polkadot/util-crypto';
 *
- * naclKeypairFromString('test'); // => { secretKey: [...], publicKey: [...] }
+ * ed25519PairFromString('test'); // => { secretKey: [...], publicKey: [...] }
 * ```
 */
-export function naclKeypairFromString (value: string): Keypair {
-  return naclKeypairFromSeed(
+export function ed25519PairFromString (value: string): Keypair {
+  return ed25519PairFromSeed(
    blake2AsU8a(
-      stringToU8a(value),
-      256
+      stringToU8a(value)
    )
  );
 }
@@ -4,14 +4,14 @@
 import { stringToU8a } from '@polkadot/util';
 import { waitReady } from '@polkadot/wasm-crypto';

-import { performanceTest } from '../../test/performance';
-import { naclKeypairFromSeed, naclSign } from '.';
+import { performanceWasm } from '../test/performance';
+import { ed25519PairFromSeed, ed25519Sign } from '.';

-const PAIR = naclKeypairFromSeed(
+const PAIR = ed25519PairFromSeed(
  stringToU8a('12345678901234567890123456789012')
 );

-describe('naclSign', (): void => {
+describe('ed25519Sign', (): void => {
  beforeEach(async (): Promise<void> => {
    await waitReady();
  });
@@ -19,7 +19,7 @@ describe('naclSign', (): void => {
  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
    it('returns a valid signature for the message', (): void => {
      expect(
-        naclSign(
+        ed25519Sign(
          new Uint8Array([0x61, 0x62, 0x63, 0x64]),
          PAIR,
          onlyJs
@@ -30,7 +30,7 @@ describe('naclSign', (): void => {
    });
  });

-  performanceTest('naclSign', 250, (input, onlyJs) =>
-    naclSign(input, PAIR, onlyJs)
+  performanceWasm('ed25519Sign', 250, (input, onlyJs) =>
+    ed25519Sign(input, PAIR, onlyJs)
  );
 });
@@ -7,10 +7,10 @@ import type { Keypair } from '../types';
 import nacl from 'tweetnacl';

 import { assert, u8aToU8a } from '@polkadot/util';
-import { ed25519Sign, isReady } from '@polkadot/wasm-crypto';
+import { ed25519Sign as wasmSign, isReady } from '@polkadot/wasm-crypto';

 /**
- * @name naclSign
+ * @name ed25519Sign
 * @summary Signs a message using the supplied secretKey
 * @description
 * Returns message signature of `message`, using the `secretKey`.
@@ -18,17 +18,17 @@ import { ed25519Sign, isReady } from '@polkadot/wasm-crypto';
 * <BR>
 *
 * ```javascript
- * import { naclSign } from '@polkadot/util-crypto';
+ * import { ed25519Sign } from '@polkadot/util-crypto';
 *
- * naclSign([...], [...]); // => [...]
+ * ed25519Sign([...], [...]); // => [...]
 * ```
 */
-export function naclSign (message: HexString | Uint8Array | string, { publicKey, secretKey }: Partial<Keypair>, onlyJs = false): Uint8Array {
+export function ed25519Sign (message: HexString | Uint8Array | string, { publicKey, secretKey }: Partial<Keypair>, onlyJs?: boolean): Uint8Array {
  assert(secretKey, 'Expected a valid secretKey');

  const messageU8a = u8aToU8a(message);

-  return isReady() && !onlyJs
-    ? ed25519Sign(publicKey as Uint8Array, secretKey.subarray(0, 32), messageU8a)
+  return !onlyJs && isReady()
+    ? wasmSign(publicKey as Uint8Array, secretKey.subarray(0, 32), messageU8a)
    : nacl.sign.detached(messageU8a, secretKey);
 }
@@ -4,16 +4,16 @@
 import { stringToU8a } from '@polkadot/util';
 import { waitReady } from '@polkadot/wasm-crypto';

-import { naclKeypairFromSeed, naclVerify } from '.';
+import { ed25519PairFromSeed, ed25519Verify } from '.';

-describe('naclVerify', (): void => {
+describe('ed25519Verify', (): void => {
  let publicKey: Uint8Array;
  let signature: Uint8Array;

  beforeEach(async (): Promise<void> => {
    await waitReady();

-    publicKey = naclKeypairFromSeed(
+    publicKey = ed25519PairFromSeed(
      stringToU8a('12345678901234567890123456789012')
    ).publicKey;
    signature = new Uint8Array([28, 58, 206, 239, 249, 70, 59, 191, 166, 40, 219, 218, 235, 170, 25, 79, 10, 94, 9, 197, 34, 126, 1, 150, 246, 68, 28, 238, 36, 26, 172, 163, 168, 90, 202, 211, 126, 246, 57, 212, 43, 24, 88, 197, 240, 113, 118, 76, 37, 81, 91, 110, 236, 50, 144, 134, 100, 223, 220, 238, 34, 185, 211, 7]);
@@ -22,7 +22,7 @@ describe('naclVerify', (): void => {
  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
    it('validates a correctly signed message', (): void => {
      expect(
-        naclVerify(
+        ed25519Verify(
          new Uint8Array([0x61, 0x62, 0x63, 0x64]),
          signature,
          publicKey,
@@ -33,7 +33,7 @@ describe('naclVerify', (): void => {

    it('fails a correctly signed message (message changed)', (): void => {
      expect(
-        naclVerify(
+        ed25519Verify(
          new Uint8Array([0x61, 0x62, 0x63, 0x64, 0x65]),
          signature,
          publicKey,
@@ -46,7 +46,7 @@ describe('naclVerify', (): void => {
      signature[0] = 0xff;

      expect(
-        naclVerify(
+        ed25519Verify(
          new Uint8Array([0x61, 0x62, 0x63, 0x64]),
          signature,
          publicKey,
@@ -57,7 +57,7 @@ describe('naclVerify', (): void => {

    it('throws error when publicKey lengths do not match', (): void => {
      expect(
-        () => naclVerify(
+        () => ed25519Verify(
          new Uint8Array([0x61, 0x62, 0x63, 0x64]),
          signature,
          new Uint8Array([1, 2]),
@@ -68,7 +68,7 @@ describe('naclVerify', (): void => {

    it('throws error when signature lengths do not match', (): void => {
      expect(
-        () => naclVerify(
+        () => ed25519Verify(
          new Uint8Array([0x61, 0x62, 0x63, 0x64]),
          new Uint8Array([1, 2]),
          publicKey,
@@ -6,10 +6,10 @@ import type { HexString } from '@polkadot/util/types';
 import nacl from 'tweetnacl';

 import { assert, u8aToU8a } from '@polkadot/util';
-import { ed25519Verify, isReady } from '@polkadot/wasm-crypto';
+import { ed25519Verify as wasmVerify, isReady } from '@polkadot/wasm-crypto';

 /**
- * @name naclSign
+ * @name ed25519Sign
 * @summary Verifies the signature on the supplied message.
 * @description
 * Verifies the `signature` on `message` with the supplied `publicKey`. Returns `true` on sucess, `false` otherwise.
@@ -17,12 +17,12 @@ import { ed25519Verify, isReady } from '@polkadot/wasm-crypto';
 * <BR>
 *
 * ```javascript
- * import { naclVerify } from '@polkadot/util-crypto';
+ * import { ed25519Verify } from '@polkadot/util-crypto';
 *
- * naclVerify([...], [...], [...]); // => true/false
+ * ed25519Verify([...], [...], [...]); // => true/false
 * ```
 */
-export function naclVerify (message: HexString | Uint8Array | string, signature: HexString | Uint8Array | string, publicKey: HexString | Uint8Array | string, onlyJs = false): boolean {
+export function ed25519Verify (message: HexString | Uint8Array | string, signature: HexString | Uint8Array | string, publicKey: HexString | Uint8Array | string, onlyJs?: boolean): boolean {
  const messageU8a = u8aToU8a(message);
  const publicKeyU8a = u8aToU8a(publicKey);
  const signatureU8a = u8aToU8a(signature);
@@ -30,7 +30,7 @@ export function naclVerify (message: HexString | Uint8Array | string, signature:
  assert(publicKeyU8a.length === 32, () => `Invalid publicKey, received ${publicKeyU8a.length}, expected 32`);
  assert(signatureU8a.length === 64, () => `Invalid signature, received ${signatureU8a.length} bytes, expected 64`);

-  return isReady() && !onlyJs
-    ? ed25519Verify(signatureU8a, messageU8a, publicKeyU8a)
+  return !onlyJs && isReady()
+    ? wasmVerify(signatureU8a, messageU8a, publicKeyU8a)
    : nacl.sign.detached.verify(messageU8a, signatureU8a, publicKeyU8a);
 }
@@ -6,8 +6,8 @@ import type { Keypair } from '../../types';
 import { assert, bnToU8a, stringToU8a, u8aConcat } from '@polkadot/util';

 import { BN_BE_32_OPTS } from '../../bn';
-import { hmacSha512 } from '../../hmac';
-import { secp256k1KeypairFromSeed, secp256k1PrivateKeyTweakAdd } from '../../secp256k1';
+import { hmacShaAsU8a } from '../../hmac';
+import { secp256k1PairFromSeed, secp256k1PrivateKeyTweakAdd } from '../../secp256k1';
 import { HARDENED, hdValidatePath } from '../validatePath';

 interface CodedKeypair extends Keypair {
@@ -19,7 +19,7 @@ const MASTER_SECRET = stringToU8a('Bitcoin seed');
 function createCoded (secretKey: Uint8Array, chainCode: Uint8Array): CodedKeypair {
  return {
    chainCode,
-    publicKey: secp256k1KeypairFromSeed(secretKey).publicKey,
+    publicKey: secp256k1PairFromSeed(secretKey).publicKey,
    secretKey
  };
 }
@@ -31,7 +31,7 @@ function deriveChild (hd: CodedKeypair, index: number): CodedKeypair {
    : u8aConcat(hd.publicKey, indexBuffer);

  try {
-    const I = hmacSha512(hd.chainCode, data);
+    const I = hmacShaAsU8a(hd.chainCode, data, 512);

    return createCoded(
      secp256k1PrivateKeyTweakAdd(hd.secretKey, I.slice(0, 32)),
@@ -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 I = hmacShaAsU8a(MASTER_SECRET, seed, 512);
  let hd = createCoded(I.slice(0, 32), I.slice(32));

  if (!path || path === 'm' || path === 'M' || path === "m'" || path === "M'") {
@@ -4,7 +4,7 @@
 import { BN_EIGHT, bnToU8a, u8aConcat, u8aToBn } from '@polkadot/util';

 import { BN_LE_32_OPTS, BN_LE_512_OPTS, BN_LE_OPTS } from '../../bn';
-import { hmacSha512 } from '../../hmac';
+import { hmacShaAsU8a } from '../../hmac';

 // performs hard-only derivation on the xprv
 export function ledgerDerivePrivate (xprv: Uint8Array, index: number): Uint8Array {
@@ -12,7 +12,7 @@ export function ledgerDerivePrivate (xprv: Uint8Array, index: number): Uint8Arra
  const kr = xprv.subarray(32, 64);
  const cc = xprv.subarray(64, 96);
  const data = u8aConcat([0], kl, kr, bnToU8a(index, BN_LE_32_OPTS));
-  const z = hmacSha512(cc, data);
+  const z = hmacShaAsU8a(cc, data, 512);

  data[0] = 0x01;

@@ -29,6 +29,6 @@ export function ledgerDerivePrivate (xprv: Uint8Array, index: number): Uint8Arra
      ),
      BN_LE_512_OPTS
    ).subarray(0, 32),
-    hmacSha512(cc, data).subarray(32, 64)
+    hmacShaAsU8a(cc, data, 512).subarray(32, 64)
  );
 }
@@ -5,8 +5,8 @@ import type { Keypair } from '../../types';

 import { assert } from '@polkadot/util';

+import { ed25519PairFromSeed } from '../../ed25519';
 import { mnemonicValidate } from '../../mnemonic';
-import { naclKeypairFromSeed } from '../../nacl';
 import { HARDENED, hdValidatePath } from '../validatePath';
 import { ledgerDerivePrivate } from './derivePrivate';
 import { ledgerMaster } from './master';
@@ -35,5 +35,5 @@ export function hdLedger (_mnemonic: string, path: string): Keypair {
    seed = ledgerDerivePrivate(seed, (n < HARDENED) ? (n + HARDENED) : n);
  }

-  return naclKeypairFromSeed(seed.slice(0, 32));
+  return ed25519PairFromSeed(seed.slice(0, 32));
 }
@@ -3,7 +3,7 @@

 import { u8aConcat } from '@polkadot/util';

-import { hmacSha256, hmacSha512 } from '../../hmac';
+import { hmacShaAsU8a } from '../../hmac';
 import { mnemonicToSeedSync } from '../../mnemonic/bip39';

 const ED25519_CRYPTO = 'ed25519 seed';
@@ -11,11 +11,11 @@ const ED25519_CRYPTO = 'ed25519 seed';
 // gets an xprv from a mnemonic
 export function ledgerMaster (mnemonic: string, password?: string): Uint8Array {
  const seed = mnemonicToSeedSync(mnemonic, password);
-  const chainCode = hmacSha256(ED25519_CRYPTO, new Uint8Array([1, ...seed]));
+  const chainCode = hmacShaAsU8a(ED25519_CRYPTO, new Uint8Array([1, ...seed]), 256);
  let priv;

  while (!priv || (priv[31] & 0b0010_0000)) {
-    priv = hmacSha512(ED25519_CRYPTO, priv || seed);
+    priv = hmacShaAsU8a(ED25519_CRYPTO, priv || seed, 512);
  }

  priv[0] &= 0b1111_1000;
@@ -0,0 +1,36 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { HexString } from '@polkadot/util/types';
+
+import { hasBigInt, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { isReady } from '@polkadot/wasm-crypto';
+
+// re-export so TS *.d.ts generation is correct
+export type { HexString } from '@polkadot/util/types';
+
+interface DualHash {
+  256: (u8a: Uint8Array) => Uint8Array;
+  512: (u8a: Uint8Array) => Uint8Array;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function createAsHex <T extends (...args: any[]) => Uint8Array> (fn: T): (...args: Parameters<T>) => HexString {
+  return (...args: Parameters<T>): HexString =>
+    u8aToHex(fn(...args));
+}
+
+export function createBitHasher <T> (bitLength: T, fn: (data: HexString | Buffer | Uint8Array | string, bitLength: T, onlyJs?: boolean) => Uint8Array): (data: HexString | Buffer | Uint8Array | string, onlyJs?: boolean) => Uint8Array {
+  return (data: HexString | Buffer | Uint8Array | string, onlyJs?: boolean): Uint8Array =>
+    fn(data, bitLength, onlyJs);
+}
+
+export function createDualHasher (wa: DualHash, js: DualHash): (value: HexString | Buffer | Uint8Array | string, bitLength?: 256 | 512, onlyJs?: boolean) => Uint8Array {
+  return (value: HexString | Buffer | Uint8Array | string, bitLength: 256 | 512 = 256, onlyJs?: boolean): Uint8Array => {
+    const u8a = u8aToU8a(value);
+
+    return !hasBigInt || (!onlyJs && isReady())
+      ? wa[bitLength](u8a)
+      : js[bitLength](u8a);
+  };
+}
@@ -1,5 +1,4 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-export { hmacSha256 } from './sha256';
-export { hmacSha512 } from './sha512';
+export { hmacShaAsU8a, hmacSha256AsU8a, hmacSha512AsU8a } from './shaAsU8a';
@@ -1,14 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import hash from 'hash.js';
-
-export function hmacSha (key: Uint8Array | string, data: Uint8Array, is512: boolean): Uint8Array {
-  return Uint8Array.from(
-    hash
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      .hmac(is512 ? hash.sha512 : hash.sha256, key)
-      .update(data)
-      .digest());
-}
@@ -1,21 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { stringToU8a, u8aToHex } from '@polkadot/util';
-
-import { hmacSha256 } from '.';
-
-describe('hmacSha256', (): void => {
-  it('has a known output', (): void => {
-    const key = stringToU8a('secret');
-    const data = stringToU8a('some message');
-
-    expect(
-      u8aToHex(
-        hmacSha256(key, data)
-      )
-    ).toEqual(
-      '0xf28a70b41263840e5c059a0a733336e0957efba87902aa8cca11441d4b0c96d7'
-    );
-  });
-});
@@ -1,8 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { hmacSha } from './sha';
-
-export function hmacSha256 (key: Uint8Array | string, data: Uint8Array): Uint8Array {
-  return hmacSha(key, data, false);
-}
@@ -1,21 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { stringToU8a, u8aToHex } from '@polkadot/util';
-
-import { hmacSha512 } from '.';
-
-describe('hmacSha512', (): void => {
-  it('has a known output', (): void => {
-    const key = stringToU8a('secret');
-    const data = stringToU8a('some message');
-
-    expect(
-      u8aToHex(
-        hmacSha512(key, data)
-      )
-    ).toEqual(
-      '0x295832e97ed77be75a9fa98029497e4a722c4b9a2f21b39d34f1befa931a39ec520fd24711d6f5c03501384ea66b83066a01a82c57a0460f8cd1f471fcce5841'
-    );
-  });
-});
@@ -1,8 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { hmacSha } from './sha';
-
-export function hmacSha512 (key: Uint8Array | string, data: Uint8Array): Uint8Array {
-  return hmacSha(key, data, true);
-}
@@ -0,0 +1,39 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { hexToU8a, stringToU8a } from '@polkadot/util';
+import { waitReady } from '@polkadot/wasm-crypto';
+
+import { performanceWasm } from '../test/performance';
+import { hmacShaAsU8a } from '.';
+
+describe('hmacShaAsU8a', (): void => {
+  beforeEach(async (): Promise<void> => {
+    await waitReady();
+  });
+
+  const key = stringToU8a('secret');
+  const data = stringToU8a('some message');
+  const output = {
+    256: hexToU8a(
+      '0xf28a70b41263840e5c059a0a733336e0957efba87902aa8cca11441d4b0c96d7'
+    ),
+    512: hexToU8a(
+      '0x295832e97ed77be75a9fa98029497e4a722c4b9a2f21b39d34f1befa931a39ec520fd24711d6f5c03501384ea66b83066a01a82c57a0460f8cd1f471fcce5841'
+    )
+  };
+
+  describe.each([256, 512] as (256 | 512)[])('bitLength=%p', (bitLength): void => {
+    describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
+      it('returns an hex representation (string)', (): void => {
+        expect(
+          hmacShaAsU8a(key, data, bitLength, onlyJs)
+        ).toEqual(output[bitLength]);
+      });
+    });
+
+    performanceWasm(`hmacShaAsU8a, bitLength=${bitLength}`, 16000, (input, onlyJs) =>
+      hmacShaAsU8a(input, input, bitLength, onlyJs)
+    );
+  });
+});
@@ -0,0 +1,50 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { hmac } from '@noble/hashes/lib/hmac';
+import { sha256 } from '@noble/hashes/lib/sha256';
+import { sha512 } from '@noble/hashes/lib/sha512';
+
+import { hasBigInt, u8aToU8a } from '@polkadot/util';
+import { hmacSha256, hmacSha512, isReady } from '@polkadot/wasm-crypto';
+
+type BitLength = 256 | 512;
+
+const JS_HASH = {
+  256: sha256,
+  512: sha512
+};
+
+const WA_MHAC = {
+  256: hmacSha256,
+  512: hmacSha512
+};
+
+function createSha (bitLength: BitLength): (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean) => Uint8Array {
+  return (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean): Uint8Array =>
+    hmacShaAsU8a(key, data, bitLength, onlyJs);
+}
+
+/**
+ * @name hmacShaAsU8a
+ * @description creates a Hmac Sha (256/512) Uint8Array from the key & data
+ */
+export function hmacShaAsU8a (key: Uint8Array | string, data: Uint8Array, bitLength: BitLength = 256, onlyJs?: boolean): Uint8Array {
+  const u8aKey = u8aToU8a(key);
+
+  return !hasBigInt || (!onlyJs && isReady())
+    ? WA_MHAC[bitLength](u8aKey, data)
+    : hmac(JS_HASH[bitLength], u8aKey, data);
+}
+
+/**
+ * @name hmacSha256AsU8a
+ * @description creates a Hmac Sha256 Uint8Array from the key & data
+ */
+export const hmacSha256AsU8a = createSha(256);
+
+/**
+ * @name hmacSha512AsU8a
+ * @description creates a Hmac Sha512 Uint8Array from the key & data
+ */
+export const hmacSha512AsU8a = createSha(512);
@@ -1,28 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { HexString } from '@polkadot/util/types';
-
-import { u8aToHex } from '@polkadot/util';
-
-import { keccakAsU8a } from './asU8a';
-
-/**
- * @name keccakAsHex
- * @summary Creates a keccak hex string from the input.
- * @description
- * From either a `string` or a `Buffer` input, create the keccak and return the result as a `0x` prefixed hex string.
- * @example
- * <BR>
- *
- * ```javascript
- * import { keccakAsHex } from '@polkadot/util-crypto';
- *
- * keccakAsHex('123'); // => 0x...
- * ```
- */
-export function keccakAsHex (value: HexString | Buffer | Uint8Array | string, bitLength?: 256 | 512): HexString {
-  return u8aToHex(
-    keccakAsU8a(value, bitLength)
-  );
-}
@@ -4,7 +4,7 @@
 import { hexToU8a, stringToU8a } from '@polkadot/util';
 import { waitReady } from '@polkadot/wasm-crypto';

-import { performanceTest } from '../../test/performance';
+import { performanceWasm } from '../test/performance';
 import { keccakAsU8a } from '.';

 describe('keccakAsU8a', (): void => {
@@ -43,7 +43,7 @@ describe('keccakAsU8a', (): void => {
      });
    });

-    performanceTest(`keccakAsU8a, bitLength=${bitLength}`, 128000, (input, onlyJs) =>
+    performanceWasm(`keccakAsU8a, bitLength=${bitLength}`, 128000, (input, onlyJs) =>
      keccakAsU8a(input, bitLength, onlyJs)
    );
  });
@@ -1,12 +1,11 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import type { HexString } from '@polkadot/util/types';
+import { keccak_256 as keccak256Js, keccak_512 as keccak512Js } from '@noble/hashes/lib/sha3';

-import js from 'js-sha3';
+import { keccak256, keccak512 } from '@polkadot/wasm-crypto';

-import { u8aToU8a } from '@polkadot/util';
-import { isReady, keccak256, keccak512 } from '@polkadot/wasm-crypto';
+import { createAsHex, createBitHasher, createDualHasher } from '../helpers';

 /**
 * @name keccakAsU8a
@@ -22,17 +21,26 @@ import { isReady, keccak256, keccak512 } from '@polkadot/wasm-crypto';
 * keccakAsU8a('123'); // => Uint8Array
 * ```
 */
-export function keccakAsU8a (value: HexString | Buffer | Uint8Array | string, bitLength: 256 | 512 = 256, onlyJs = false): Uint8Array {
-  const is256 = bitLength === 256;
-  const u8a = u8aToU8a(value);

-  return isReady() && !onlyJs
-    ? is256
-      ? keccak256(u8a)
-      : keccak512(u8a)
-    : new Uint8Array(
-      is256
-        ? js.keccak256.update(u8a).arrayBuffer()
-        : js.keccak512.update(u8a).arrayBuffer()
-    );
-}
+export const keccakAsU8a = createDualHasher(
+  { 256: keccak256, 512: keccak512 },
+  { 256: keccak256Js, 512: keccak512Js }
+);
+
+/**
+ * @name keccak256AsU8a
+ * @description Creates a keccak256 Uint8Array from the input.
+ */
+export const keccak256AsU8a = createBitHasher(256, keccakAsU8a);
+
+/**
+ * @name keccak512AsU8a
+ * @description Creates a keccak512 Uint8Array from the input.
+ */
+export const keccak512AsU8a = createBitHasher(512, keccakAsU8a);
+
+/**
+ * @name keccakAsHex
+ * @description Creates a keccak hex string from the input.
+ */
+export const keccakAsHex = createAsHex(keccakAsU8a);
@@ -5,5 +5,4 @@
 * @summary Create Keccak256/512 values as hex & Uint8Array output
 */

-export { keccakAsHex } from './asHex';
-export { keccakAsU8a } from './asU8a';
+export { keccakAsHex, keccakAsU8a, keccak256AsU8a, keccak512AsU8a } from './asU8a';
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 import { secp256k1DeriveHard } from '../secp256k1/deriveHard';
-import { secp256k1KeypairFromSeed } from '../secp256k1/keypair/fromSeed';
+import { secp256k1PairFromSeed } from '../secp256k1/pair/fromSeed';
 import { createSeedDeriveFn } from './hdkdDerive';

-export const keyHdkdEcdsa = createSeedDeriveFn(secp256k1KeypairFromSeed, secp256k1DeriveHard);
+export const keyHdkdEcdsa = createSeedDeriveFn(secp256k1PairFromSeed, secp256k1DeriveHard);
@@ -1,8 +1,7 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import { naclDeriveHard } from '../nacl/deriveHard';
-import { naclKeypairFromSeed } from '../nacl/keypair/fromSeed';
+import { ed25519DeriveHard, ed25519PairFromSeed } from '../ed25519';
 import { createSeedDeriveFn } from './hdkdDerive';

-export const keyHdkdEd25519 = createSeedDeriveFn(naclKeypairFromSeed, naclDeriveHard);
+export const keyHdkdEd25519 = createSeedDeriveFn(ed25519PairFromSeed, ed25519DeriveHard);
@@ -3,12 +3,12 @@

 import type { Keypair } from '../types';

-import { schnorrkelDeriveHard } from '../schnorrkel/deriveHard';
-import { schnorrkelDeriveSoft } from '../schnorrkel/deriveSoft';
+import { sr25519DeriveHard } from '../sr25519/deriveHard';
+import { sr25519DeriveSoft } from '../sr25519/deriveSoft';
 import { DeriveJunction } from './DeriveJunction';

 export function keyHdkdSr25519 (keypair: Keypair, { chainCode, isSoft }: DeriveJunction): Keypair {
  return isSoft
-    ? schnorrkelDeriveSoft(keypair, chainCode)
-    : schnorrkelDeriveHard(keypair, chainCode);
+    ? sr25519DeriveSoft(keypair, chainCode)
+    : sr25519DeriveHard(keypair, chainCode);
 }
@@ -0,0 +1,14 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import DEFAULT_WORDLIST from './bip39-en';
+
+describe('wordlist', (): void => {
+  it('has the correct number of words', (): void => {
+    expect(DEFAULT_WORDLIST).toHaveLength(2048);
+  });
+
+  it('has no empty words', (): void => {
+    expect(DEFAULT_WORDLIST.some((n) => !n.length || n.trim() !== n)).toEqual(false);
+  });
+});
@@ -1,6 +1,7 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

+import { hasBigInt } from '@polkadot/util';
 import { bip39Generate, isReady } from '@polkadot/wasm-crypto';

 import { generateMnemonic } from './bip39';
@@ -28,8 +29,8 @@ const STRENGTH_MAP = {
 * const mnemonic = mnemonicGenerate(); // => string
 * ```
 */
-export function mnemonicGenerate (numWords: WordCount = 12, onlyJs = false): string {
-  return isReady() && !onlyJs
+export function mnemonicGenerate (numWords: WordCount = 12, onlyJs?: boolean): string {
+  return !hasBigInt || (!onlyJs && isReady())
    ? bip39Generate(numWords)
    : generateMnemonic(STRENGTH_MAP[numWords]);
 }
@@ -3,7 +3,7 @@

 import { u8aToHex } from '@polkadot/util';

-import tests from '../schnorrkel/keypair/testing';
+import tests from '../sr25519/pair/testing.spec';
 import { cryptoWaitReady } from '..';
 import { mnemonicToEntropy } from './toEntropy';

@@ -1,12 +1,13 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

+import { hasBigInt } from '@polkadot/util';
 import { bip39ToEntropy, isReady } from '@polkadot/wasm-crypto';

 import { mnemonicToEntropy as jsToEntropy } from './bip39';

-export function mnemonicToEntropy (mnemonic: string, onlyJs = false): Uint8Array {
-  return isReady() && !onlyJs
+export function mnemonicToEntropy (mnemonic: string, onlyJs?: boolean): Uint8Array {
+  return !hasBigInt || (!onlyJs && isReady())
    ? bip39ToEntropy(mnemonic)
    : jsToEntropy(mnemonic);
 }
@@ -1,7 +1,7 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import { assert } from '@polkadot/util';
+import { assert, hasBigInt } from '@polkadot/util';
 import { bip39ToSeed, isReady } from '@polkadot/wasm-crypto';

 import { mnemonicToSeedSync } from './bip39';
@@ -24,17 +24,13 @@ import { mnemonicValidate } from './validate';
 * }
 * ```
 */
-export function mnemonicToLegacySeed (mnemonic: string, password = '', onlyJs = false, byteLength: 32 | 64 = 32): Uint8Array {
+export function mnemonicToLegacySeed (mnemonic: string, password = '', onlyJs?: boolean, byteLength: 32 | 64 = 32): Uint8Array {
  assert(mnemonicValidate(mnemonic), 'Invalid bip39 mnemonic specified');
  assert([32, 64].includes(byteLength), () => `Invalid seed length ${byteLength}, expected 32 or 64`);

-  if (byteLength === 32) {
-    return isReady() && !onlyJs
+  return byteLength === 32
+    ? !hasBigInt || (!onlyJs && isReady())
      ? bip39ToSeed(mnemonic, password)
-      : mnemonicToSeedSync(mnemonic, password).subarray(0, 32);
-  } else if (byteLength === 64) {
-    return mnemonicToSeedSync(mnemonic, password);
-  }
-
-  return new Uint8Array();
+      : mnemonicToSeedSync(mnemonic, password).subarray(0, 32)
+    : mnemonicToSeedSync(mnemonic, password);
 }
@@ -3,7 +3,7 @@

 import { u8aEq, u8aToHex } from '@polkadot/util';

-import tests from '../schnorrkel/keypair/testing';
+import tests from '../sr25519/pair/testing.spec';
 import { cryptoWaitReady } from '..';
 import { mnemonicToMiniSecret } from './toMiniSecret';

@@ -8,10 +8,10 @@ import { pbkdf2Encode } from '../pbkdf2';
 import { mnemonicToEntropy } from './toEntropy';
 import { mnemonicValidate } from './validate';

-export function mnemonicToMiniSecret (mnemonic: string, password = '', onlyJs = false): Uint8Array {
+export function mnemonicToMiniSecret (mnemonic: string, password = '', onlyJs?: boolean): Uint8Array {
  assert(mnemonicValidate(mnemonic), 'Invalid bip39 mnemonic specified');

-  if (isReady() && !onlyJs) {
+  if (!onlyJs && isReady()) {
    return bip39ToMiniSecret(mnemonic, password);
  }

@@ -3,7 +3,7 @@

 import { arrayRange, u8aEq } from '@polkadot/util';

-import { cryptoWaitReady, mnemonicGenerate, mnemonicToMiniSecret, naclKeypairFromSeed, schnorrkelKeypairFromSeed } from '..';
+import { cryptoWaitReady, ed25519PairFromSeed, mnemonicGenerate, mnemonicToMiniSecret, sr25519PairFromSeed } from '..';

 // NOTE: This basically controls how long stuff runs for, YMMV
 //
@@ -29,8 +29,8 @@ describe.each([true, false])('mnemonicToMiniSecret (compare), onlyJsMnemonic=%p'
        // do iterations to check and re-check that all matches
        it.concurrent.each(arrayRange(NUM_CHECKS))('check=%p', (count): void => {
          const minisecret = mnemonicToMiniSecret(mnemonic, count ? `${count}` : '', onlyJsMnemonic);
-          const edpub = naclKeypairFromSeed(minisecret).publicKey;
-          const srpub = schnorrkelKeypairFromSeed(minisecret).publicKey;
+          const edpub = ed25519PairFromSeed(minisecret).publicKey;
+          const srpub = sr25519PairFromSeed(minisecret).publicKey;

          const testmini = mnemonicToMiniSecret(mnemonic, count ? `${count}` : '', onlyJsMini);

@@ -41,13 +41,13 @@ describe.each([true, false])('mnemonicToMiniSecret (compare), onlyJsMnemonic=%p'

          // compare the sr25519 keypair generated
          expect(
-            u8aEq(srpub, schnorrkelKeypairFromSeed(testmini).publicKey)
+            u8aEq(srpub, sr25519PairFromSeed(testmini).publicKey)
          ).toEqual(true);

          // compare ed both in WASM and JS
          [true, false].forEach((onlyJsEd): void => {
            expect(
-              u8aEq(edpub, naclKeypairFromSeed(testmini, onlyJsEd).publicKey)
+              u8aEq(edpub, ed25519PairFromSeed(testmini, onlyJsEd).publicKey)
            ).toEqual(true);
          });
        });
@@ -1,6 +1,7 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

+import { hasBigInt } from '@polkadot/util';
 import { bip39Validate, isReady } from '@polkadot/wasm-crypto';

 import { validateMnemonic } from './bip39';
@@ -18,8 +19,8 @@ import { validateMnemonic } from './bip39';
 * const isValidMnemonic = mnemonicValidate(mnemonic); // => boolean
 * ```
 */
-export function mnemonicValidate (mnemonic: string, onlyJs = false): boolean {
-  return isReady() && !onlyJs
+export function mnemonicValidate (mnemonic: string, onlyJs?: boolean): boolean {
+  return !hasBigInt || (!onlyJs && isReady())
    ? bip39Validate(mnemonic)
    : validateMnemonic(mnemonic);
 }
@@ -1,9 +1,9 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import { naclBoxKeypairFromSecret } from '..';
+import { naclBoxPairFromSecret } from '..';

-describe('naclBoxKeypairFromSecret', (): void => {
+describe('naclBoxPairFromSecret', (): void => {
  const secretKey = new Uint8Array([
    18, 52, 86, 120, 144, 18, 52, 86,
    120, 144, 18, 52, 86, 120, 144, 18,
@@ -13,7 +13,7 @@ describe('naclBoxKeypairFromSecret', (): void => {

  it('generates a valid publicKey/secretKey pair', (): void => {
    expect(
-      naclBoxKeypairFromSecret(secretKey)
+      naclBoxPairFromSecret(secretKey)
    ).toEqual({
      publicKey: new Uint8Array([
        206, 110, 228, 222, 155, 43, 229, 254,
@@ -6,7 +6,7 @@ import type { Keypair } from '../../types';
 import nacl from 'tweetnacl';

 /**
- * @name naclBoxKeypairFromSecret
+ * @name naclBoxPairFromSecret
 * @summary Creates a new public/secret box keypair from a secret.
 * @description
 * Returns a object containing a box `publicKey` & `secretKey` generated from the supplied secret.
@@ -14,11 +14,11 @@ import nacl from 'tweetnacl';
 * <BR>
 *
 * ```javascript
- * import { naclBoxKeypairFromSecret } from '@polkadot/util-crypto';
+ * import { naclBoxPairFromSecret } from '@polkadot/util-crypto';
 *
- * naclBoxKeypairFromSecret(...); // => { secretKey: [...], publicKey: [...] }
+ * naclBoxPairFromSecret(...); // => { secretKey: [...], publicKey: [...] }
 * ```
 */
-export function naclBoxKeypairFromSecret (secret: Uint8Array): Keypair {
+export function naclBoxPairFromSecret (secret: Uint8Array): Keypair {
  return nacl.box.keyPair.fromSecretKey(secret.slice(0, 32));
 }
@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0

 /**
- * @summary Implements [NaCl](http://nacl.cr.yp.to/) secret-key authenticated encryption, public-key authenticated encryption, hashing, and public-key signatures
+ * @summary Implements [NaCl](http://nacl.cr.yp.to/) secret-key authenticated encryption, public-key authenticated encryption
 */
 export { naclDecrypt } from './decrypt';
 export { naclEncrypt } from './encrypt';
-export { naclKeypairFromRandom } from './keypair/fromRandom';
-export { naclKeypairFromSecret } from './keypair/fromSecret';
-export { naclKeypairFromSeed } from './keypair/fromSeed';
-export { naclKeypairFromString } from './keypair/fromString';
-export { naclSign } from './sign';
-export { naclVerify } from './verify';
-export { naclBoxKeypairFromSecret } from './box/fromSecret';
+export { naclBoxPairFromSecret } from './box/fromSecret';
 export { naclOpen } from './open';
 export { naclSeal } from './seal';
-export { convertSecretKeyToCurve25519, convertPublicKeyToCurve25519 } from './convertKey';
--- a/Show More
+++ b/Show More