[CI Skip] release/stable 7.0.2

skip-checks: true

.123trigger

@@ -14,3 +14,5 @@
 6.0.3
 6.0.4
 6.0.5
+
+7.0.2

CHANGELOG.md

@@ -1,5 +1,63 @@
 # CHANGELOG
 
+## 7.0.2 Jul 19, 2021
+
+Changes:
+
+- Added `isCompact` utility for check on compact-like types
+- Sync with upstream Substrate ss58 registry
+
+
+## 7.0.1 Jul 11, 2021
+
+- **Breaking change** The `@polkadot/x-rxjs` package has been removed. In `rxjs` 7.2.0 the compatibility issues at the base layer has been solved.
+- **Breaking change** The named exports in `@polkadot/networks` has been changed
+
+Contributed:
+
+- Add Ledger config for Centrifuge (Thanks to https://github.com/mikiquantum)
+
+Changes:
+
+- Adjust `@polkadot/networks` to fully-descriptive exports
+- Remove `@polkadot/x-rxjs`, direct import from `rxjs >= 7.2.0` required
+- Allow building as a completely stand-alone browser bundle (experimental)
+- Sync with upstream Substrate ss58 registry
+
+
+## 6.11.1 Jul 5, 2021
+
+Changes:
+
+- Cleanup unneeded dependencies for `@polkadot/x-global`
+- Sync with upstream Substrate ss58 registry
+- Bump Zondax dependencies (Statemine slip44 fix)
+
+
+## 6.10.1 Jun 26, 2021
+
+Contributed:
+
+- Add Karura genesisHash (Thanks to https://github.com/ntduan)
+
+Changes:
+
+- `isHex(value)` will now check for only `string` types (No `String` classes)
+- Added `arrayShuffle(array)` to shuffle an array into a new output
+- Added Statemine Ledger app information
+- Simplify tests to use `{describe|it}.each` where applicable
+- Sync with upstream Substrate ss58 registry
+
+
+## 6.9.1 Jun 19, 2021
+
+Changes:
+
+- Added `u8aCmp(a, b)` to do sorting compares
+- Added `arrayRange(size, startAt = 0)` to create a range of numbers
+- Added extensive mnemonic compare test (optional, skipped)
+
+
 ## 6.8.1 Jun 14, 2021
 
 Contributed:

package.json

@@ -7,24 +7,26 @@
     "packages/*"
   ],
   "resolutions": {
-    "typescript": "^4.3.2"
+    "typescript": "^4.3.5"
   },
   "scripts": {
     "build": "polkadot-dev-build-ts",
     "build:release": "polkadot-ci-ghact-build",
+    "build:rollup": "polkadot-exec-rollup --config",
     "lint": "polkadot-dev-run-lint",
     "clean": "polkadot-dev-clean-build",
     "networks:crosscheck": "polkadot-dev-run-test packages/networks/src/crosscheck",
     "networks:sync": "node packages/networks/scripts/fromSubstrate.mjs",
     "postinstall": "polkadot-dev-yarn-only",
-    "test": "polkadot-dev-run-test --coverage --runInBand --testPathIgnorePatterns crosscheck",
-    "test:one": "polkadot-dev-run-test"
+    "test": "polkadot-dev-run-test --coverage --runInBand --testPathIgnorePatterns crosscheck --testPathIgnorePatterns toMiniSecretCmp",
+    "test:mnemonicCmp": "polkadot-dev-run-test packages/util-crypto/src/mnemonic/toMiniSecretCmp.spec.ts",
+    "test:one": "polkadot-dev-run-test --runInBand"
   },
   "devDependencies": {
-    "@babel/core": "^7.14.5",
-    "@polkadot/dev": "^0.62.42",
-    "@polkadot/ts": "^0.3.90",
-    "@types/jest": "^26.0.23"
+    "@babel/core": "^7.14.6",
+    "@polkadot/dev": "^0.62.57",
+    "@polkadot/ts": "^0.4.4",
+    "@types/jest": "^26.0.24"
   },
-  "version": "6.8.1"
+  "version": "7.0.2"
 }

packages/hw-ledger-transports/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/hw-ledger-transports",
-  "version": "6.8.1",
+  "version": "7.0.2",
   "type": "module",
   "repository": "github:polkadot-js/common",
   "author": "Jaco Greeff <jacogr@gmail.com>",
@@ -15,15 +15,12 @@
     "node": ">=14.0.0"
   },
   "dependencies": {
-    "@babel/runtime": "^7.14.5",
-    "@ledgerhq/hw-transport-webhid": "^5.51.1",
-    "@ledgerhq/hw-transport-webusb": "^5.53.1"
-  },
-  "devDependencies": {
-    "@types/ledgerhq__hw-transport-node-hid": "^4.22.2",
-    "@types/ledgerhq__hw-transport-webusb": "^4.70.1"
+    "@babel/runtime": "^7.14.6",
+    "@ledgerhq/hw-transport": "^6.1.0",
+    "@ledgerhq/hw-transport-webhid": "^6.1.0",
+    "@ledgerhq/hw-transport-webusb": "^6.1.0"
   },
   "optionalDependencies": {
-    "@ledgerhq/hw-transport-node-hid-singleton": "^5.51.1"
+    "@ledgerhq/hw-transport-node-hid-singleton": "^6.1.0"
   }
 }

packages/hw-ledger-transports/src/ledgerhq-node.d.ts

@@ -1,15 +0,0 @@
-// Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-declare module '@ledgerhq/hw-transport-node-hid-noevents' {
-  import Transport from '@ledgerhq/hw-transport';
-
-  export default class TransportNodeHidNoEvents extends Transport {}
-  export function getDevices(): Array<unknown>
-}
-
-declare module '@ledgerhq/hw-transport-node-hid-singleton' {
-  import TransportNodeHidNoEvents from '@ledgerhq/hw-transport-node-hid-noevents';
-
-  export default class TransportNodeHid extends TransportNodeHidNoEvents { }
-}

packages/hw-ledger-transports/src/ledgerhq-web.d.ts

@@ -1,8 +0,0 @@
-// Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-declare module '@ledgerhq/hw-transport-webhid' {
-  import Transport from '@ledgerhq/hw-transport';
-
-  export default class TransportWebHid extends Transport {}
-}

packages/hw-ledger-transports/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/hw-ledger-transports', version: '6.8.1' };
+export const packageInfo = { name: '@polkadot/hw-ledger-transports', version: '7.0.2' };

packages/hw-ledger/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/hw-ledger",
-  "version": "6.8.1",
+  "version": "7.0.2",
   "type": "module",
   "repository": "github:polkadot-js/common",
   "author": "Jaco Greeff <jacogr@gmail.com>",
@@ -16,9 +16,9 @@
     "node": ">=14.0.0"
   },
   "dependencies": {
-    "@babel/runtime": "^7.14.5",
-    "@polkadot/hw-ledger-transports": "6.8.1",
-    "@polkadot/util": "^6.8.1",
-    "@zondax/ledger-polkadot": "^0.14.0"
+    "@babel/runtime": "^7.14.6",
+    "@polkadot/hw-ledger-transports": "7.0.2",
+    "@polkadot/util": "^7.0.2",
+    "@zondax/ledger-substrate": "^0.16.2"
   }
 }

packages/hw-ledger/src/bundle.ts

@@ -0,0 +1,103 @@
+// Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ResponseBase, SubstrateApp } from '@zondax/ledger-substrate';
+import type { AccountOptions, LedgerAddress, LedgerSignature, LedgerTypes, LedgerVersion } from './types';
+
+import { transports } from '@polkadot/hw-ledger-transports';
+import { assert, u8aToBuffer } from '@polkadot/util';
+
+import { LEDGER_DEFAULT_ACCOUNT, LEDGER_DEFAULT_CHANGE, LEDGER_DEFAULT_INDEX, LEDGER_SUCCESS_CODE } from './constants';
+import { ledgerApps } from './defaults';
+
+export { packageInfo } from './packageInfo';
+
+type Chain = keyof typeof ledgerApps;
+
+// A very basic wrapper for a ledger app -
+//  - it connects automatically, creating an app as required
+//  - Promises return errors (instead of wrapper errors)
+export class Ledger {
+  #app: SubstrateApp | null = null;
+
+  #chain: Chain;
+
+  #transport: LedgerTypes;
+
+  constructor (transport: LedgerTypes, chain: Chain) {
+    // u2f is deprecated
+    assert(['hid', 'webusb'].includes(transport), () => `Unsupported transport ${transport}`);
+    assert(Object.keys(ledgerApps).includes(chain), () => `Unsupported chain ${chain}`);
+
+    this.#chain = chain;
+    this.#transport = transport;
+  }
+
+  public async getAddress (confirm = false, accountOffset = 0, addressOffset = 0, { account = LEDGER_DEFAULT_ACCOUNT, addressIndex = LEDGER_DEFAULT_INDEX, change = LEDGER_DEFAULT_CHANGE }: Partial<AccountOptions> = {}): Promise<LedgerAddress> {
+    return this.#withApp(async (app: SubstrateApp): Promise<LedgerAddress> => {
+      const { address, pubKey } = await this.#wrapError(app.getAddress(account + accountOffset, change, addressIndex + addressOffset, confirm));
+
+      return {
+        address,
+        publicKey: `0x${pubKey}`
+      };
+    });
+  }
+
+  public async getVersion (): Promise<LedgerVersion> {
+    return this.#withApp(async (app: SubstrateApp): Promise<LedgerVersion> => {
+      const { device_locked: isLocked, major, minor, patch, test_mode: isTestMode } = await this.#wrapError(app.getVersion());
+
+      return {
+        isLocked,
+        isTestMode,
+        version: [major, minor, patch]
+      };
+    });
+  }
+
+  public async sign (message: Uint8Array, accountOffset = 0, addressOffset = 0, { account = LEDGER_DEFAULT_ACCOUNT, addressIndex = LEDGER_DEFAULT_INDEX, change = LEDGER_DEFAULT_CHANGE }: Partial<AccountOptions> = {}): Promise<LedgerSignature> {
+    return this.#withApp(async (app: SubstrateApp): Promise<LedgerSignature> => {
+      const buffer = u8aToBuffer(message);
+      const { signature } = await this.#wrapError(app.sign(account + accountOffset, change, addressIndex + addressOffset, buffer));
+
+      return {
+        signature: `0x${signature.toString('hex')}`
+      };
+    });
+  }
+
+  #getApp = async (): Promise<SubstrateApp> => {
+    if (!this.#app) {
+      const def = transports.find(({ type }) => type === this.#transport);
+
+      assert(def, () => `Unable to find a transport for ${this.#transport}`);
+
+      const transport = await def.create();
+
+      this.#app = ledgerApps[this.#chain](transport);
+    }
+
+    return this.#app;
+  };
+
+  #withApp = async <T> (fn: (app: SubstrateApp) => Promise<T>): Promise<T> => {
+    try {
+      const app = await this.#getApp();
+
+      return await fn(app);
+    } catch (error) {
+      this.#app = null;
+
+      throw error;
+    }
+  };
+
+  #wrapError = async <T extends ResponseBase> (promise: Promise<T>): Promise<T> => {
+    const result = await promise;
+
+    assert(result.return_code === LEDGER_SUCCESS_CODE, () => result.error_message);
+
+    return result;
+  };
+}

packages/hw-ledger/src/defaults.ts

@@ -2,18 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type Transport from '@ledgerhq/hw-transport';
-import type { SubstrateApp } from '@zondax/ledger-polkadot';
+import type { SubstrateApp } from '@zondax/ledger-substrate';
 
-import { newDockApp, newEdgewareApp, newEquilibriumApp, newKusamaApp, newPolkadotApp, newPolymeshApp } from '@zondax/ledger-polkadot';
+import { newCentrifugeApp, newDockApp, newEdgewareApp, newEquilibriumApp, newKusamaApp, newPolkadotApp, newPolymeshApp, newStatemineApp } from '@zondax/ledger-substrate';
 
-// These match up with the network keys in the @polkadot/networks package
-// (which is turn aligns with the substrate/ss58-registry.json as the single
-// source of truth)
+// These match up with the keys of the knownLedger object in the @polkadot/networks/defaults.ts
 export const ledgerApps: Record<string, (transport: Transport) => SubstrateApp> = {
+  centrifuge: newCentrifugeApp,
   'dock-mainnet': newDockApp,
   edgeware: newEdgewareApp,
   equilibrium: newEquilibriumApp,
   kusama: newKusamaApp,
   polkadot: newPolkadotApp,
-  polymesh: newPolymeshApp
+  polymesh: newPolymeshApp,
+  statemine: newStatemineApp
 };

packages/hw-ledger/src/index.ts

@@ -3,103 +3,4 @@
 
 import './detectPackage';
 
-import type { ResponseBase, SubstrateApp } from '@zondax/ledger-polkadot';
-import type { AccountOptions, LedgerAddress, LedgerSignature, LedgerTypes, LedgerVersion } from './types';
-
-import { transports } from '@polkadot/hw-ledger-transports';
-import { assert, u8aToBuffer } from '@polkadot/util';
-
-import { LEDGER_DEFAULT_ACCOUNT, LEDGER_DEFAULT_CHANGE, LEDGER_DEFAULT_INDEX, LEDGER_SUCCESS_CODE } from './constants';
-import { ledgerApps } from './defaults';
-
-export { packageInfo } from './packageInfo';
-
-type Chain = keyof typeof ledgerApps;
-
-// A very basic wrapper for a ledger app -
-//  - it connects automatically, creating an app as required
-//  - Promises return errors (instead of wrapper errors)
-export class Ledger {
-  #app: SubstrateApp | null = null;
-
-  #chain: Chain;
-
-  #transport: LedgerTypes;
-
-  constructor (transport: LedgerTypes, chain: Chain) {
-    // u2f is deprecated
-    assert(['hid', 'webusb'].includes(transport), () => `Unsupported transport ${transport}`);
-    assert(Object.keys(ledgerApps).includes(chain), () => `Unsupported chain ${chain}`);
-
-    this.#chain = chain;
-    this.#transport = transport;
-  }
-
-  public async getAddress (confirm = false, accountOffset = 0, addressOffset = 0, { account = LEDGER_DEFAULT_ACCOUNT, addressIndex = LEDGER_DEFAULT_INDEX, change = LEDGER_DEFAULT_CHANGE }: Partial<AccountOptions> = {}): Promise<LedgerAddress> {
-    return this.#withApp(async (app: SubstrateApp): Promise<LedgerAddress> => {
-      const { address, pubKey } = await this.#wrapError(app.getAddress(account + accountOffset, change, addressIndex + addressOffset, confirm));
-
-      return {
-        address,
-        publicKey: `0x${pubKey}`
-      };
-    });
-  }
-
-  public async getVersion (): Promise<LedgerVersion> {
-    return this.#withApp(async (app: SubstrateApp): Promise<LedgerVersion> => {
-      const { device_locked: isLocked, major, minor, patch, test_mode: isTestMode } = await this.#wrapError(app.getVersion());
-
-      return {
-        isLocked,
-        isTestMode,
-        version: [major, minor, patch]
-      };
-    });
-  }
-
-  public async sign (message: Uint8Array, accountOffset = 0, addressOffset = 0, { account = LEDGER_DEFAULT_ACCOUNT, addressIndex = LEDGER_DEFAULT_INDEX, change = LEDGER_DEFAULT_CHANGE }: Partial<AccountOptions> = {}): Promise<LedgerSignature> {
-    return this.#withApp(async (app: SubstrateApp): Promise<LedgerSignature> => {
-      const buffer = u8aToBuffer(message);
-      const { signature } = await this.#wrapError(app.sign(account + accountOffset, change, addressIndex + addressOffset, buffer));
-
-      return {
-        signature: `0x${signature.toString('hex')}`
-      };
-    });
-  }
-
-  #getApp = async (): Promise<SubstrateApp> => {
-    if (!this.#app) {
-      const def = transports.find(({ type }) => type === this.#transport);
-
-      assert(def, () => `Unable to find a transport for ${this.#transport}`);
-
-      const transport = await def.create();
-
-      this.#app = ledgerApps[this.#chain](transport);
-    }
-
-    return this.#app;
-  };
-
-  #withApp = async <T> (fn: (app: SubstrateApp) => Promise<T>): Promise<T> => {
-    try {
-      const app = await this.#getApp();
-
-      return await fn(app);
-    } catch (error) {
-      this.#app = null;
-
-      throw error;
-    }
-  };
-
-  #wrapError = async <T extends ResponseBase> (promise: Promise<T>): Promise<T> => {
-    const result = await promise;
-
-    assert(result.return_code === LEDGER_SUCCESS_CODE, () => result.error_message);
-
-    return result;
-  };
-}
+export * from './bundle';

packages/hw-ledger/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/hw-ledger', version: '6.8.1' };
+export const packageInfo = { name: '@polkadot/hw-ledger', version: '7.0.2' };

packages/keyring/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/keyring",
-  "version": "6.8.1",
+  "version": "7.0.2",
   "type": "module",
   "description": "Keyring management",
   "author": "Jaco Greeff <jacogr@gmail.com>",
@@ -19,12 +19,12 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/keyring#readme",
   "dependencies": {
-    "@babel/runtime": "^7.14.5",
-    "@polkadot/util": "6.8.1",
-    "@polkadot/util-crypto": "6.8.1"
+    "@babel/runtime": "^7.14.6",
+    "@polkadot/util": "7.0.2",
+    "@polkadot/util-crypto": "7.0.2"
   },
   "peerDependencies": {
-    "@polkadot/util": "6.8.1",
-    "@polkadot/util-crypto": "6.8.1"
+    "@polkadot/util": "7.0.2",
+    "@polkadot/util-crypto": "7.0.2"
   }
 }

packages/keyring/src/bundle.ts

@@ -0,0 +1,14 @@
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Keyring } from './keyring';
+
+export { decodeAddress, encodeAddress, setSS58Format } from '@polkadot/util-crypto';
+
+export * from './defaults';
+export { createPair } from './pair';
+export { packageInfo } from './packageInfo';
+export { createTestKeyring } from './testing';
+export { createTestPairs } from './testingPairs';
+
+export { Keyring };

packages/keyring/src/index.ts

@@ -3,12 +3,8 @@
 
 import './detectPackage';
 
-import { Keyring } from './keyring';
+import { Keyring } from './bundle';
 
-export { decodeAddress, encodeAddress, setSS58Format } from '@polkadot/util-crypto';
-
-export { packageInfo } from './packageInfo';
+export * from './bundle';
 
 export default Keyring;
-
-export { Keyring };

packages/keyring/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/keyring', version: '6.8.1' };
+export const packageInfo = { name: '@polkadot/keyring', version: '7.0.2' };

packages/keyring/src/pair/index.ts

@@ -176,8 +176,11 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
     toJson: (passphrase?: string): KeyringPair$Json => {
       // NOTE: For ecdsa and ethereum, the publicKey cannot be extracted from the address. For these
       // pass the hex-encoded publicKey through to the address portion of the JSON (before decoding)
+      // unless the publicKey is already an address
       const address = ['ecdsa', 'ethereum'].includes(type)
-        ? u8aToHex(secp256k1Compress(publicKey))
+        ? publicKey.length === 20
+          ? u8aToHex(publicKey)
+          : u8aToHex(secp256k1Compress(publicKey))
         : encodeAddress();
 
       return pairToJson(type, { address, meta }, recode(passphrase), !!passphrase);

packages/networks/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/networks",
-  "version": "6.8.1",
+  "version": "7.0.2",
   "type": "module",
   "description": "A list of all available Substrate networks and their applicable prefixes",
   "main": "index.js",
@@ -16,10 +16,10 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/networks#readme",
   "dependencies": {
-    "@babel/runtime": "^7.14.5"
+    "@babel/runtime": "^7.14.6"
   },
   "devDependencies": {
-    "@polkadot/util": "6.8.1",
-    "@polkadot/x-fetch": "6.8.1"
+    "@polkadot/util": "7.0.2",
+    "@polkadot/x-fetch": "7.0.2"
   }
 }

packages/networks/src/crosscheck.spec.ts

@@ -8,7 +8,7 @@ import fs from 'fs';
 import { stringify } from '@polkadot/util';
 import { fetch } from '@polkadot/x-fetch';
 
-import { all } from './';
+import { allNetworks } from './';
 
 const OUTPUT = './.github/ss58-check.md';
 const SUBSTRATE_REGISTRY = 'https://raw.githubusercontent.com/paritytech/substrate/master/ss58-registry.json';
@@ -32,19 +32,19 @@ describe('check latest Substrate ss58 registry', (): void => {
   });
 
   it('has the same number as the original', (): void => {
-    assertAndLog(all.length === original.registry.length, `Number of entries mismatched:: Expected ${original.registry.length} found ${all.length}`);
+    assertAndLog(allNetworks.length === original.registry.length, `Number of entries mismatched:: Expected ${original.registry.length} found ${allNetworks.length}`);
   });
 
   it('has no missing any entries', (): void => {
     const missing = original.registry
-      .filter(({ prefix }) => !all.some((n) => n.prefix === prefix))
+      .filter(({ prefix }) => !allNetworks.some((n) => n.prefix === prefix))
       .map(({ displayName, prefix }) => `${displayName} (${prefix})`);
 
     assertAndLog(!missing.length, `Missing entries found: ${stringify(missing, 2)}`);
   });
 
   it('has no extra entries', (): void => {
-    const missing = all
+    const missing = allNetworks
       .filter(({ prefix }) => !original.registry.some((n) => n.prefix === prefix))
       .map(({ displayName, prefix }) => `${displayName} (${prefix})`);
 
@@ -55,7 +55,7 @@ describe('check latest Substrate ss58 registry', (): void => {
     const fields = Object.keys(original.schema) as (keyof KnownSubstrate)[];
     const errors = original.registry
       .map((n): [string, string[]] => {
-        const other = all.find(({ prefix }) => prefix === n.prefix);
+        const other = allNetworks.find(({ prefix }) => prefix === n.prefix);
 
         return [
           `${n.displayName} (${n.prefix})`,

packages/networks/src/defaults.spec.ts

@@ -1,9 +1,20 @@
 // Copyright 2017-2021 @polkadot/networks authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+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([]);
+  });
+
   it('has genesis for all Ledger chains', (): void => {
     expect(
       Object.keys(knownLedger).filter((network) =>

packages/networks/src/defaults.ts

@@ -8,6 +8,9 @@ import type { KnownGenesis, KnownIcon, KnownLedger, KnownTestnet } from './types
 // last. This make lookups for the current a simple genesisHash[0]
 // (See Kusama as an example)
 export const knownGenesis: KnownGenesis = {
+  centrifuge: [
+    '0x67dddf2673b69e5f875f6f25277495834398eafd67f492e09f3f3345e003d1b5'
+  ],
   'dock-mainnet': [
     '0xf73467c6544aa68df2ee546b135f955c46b90fa627e9b5d7935f41061bb8a5a9'
   ],
@@ -23,6 +26,9 @@ export const knownGenesis: KnownGenesis = {
     '0x3d75507dd46301767e601265791da1d9cb47b6ebc94e87347b635e5bf58bd047', // Snakenet Gen2
     '0x0ed32bfcab4a83517fac88f2aa7cbc2f88d3ab93be9a12b6188a036bf8a943c2' // Snakenet Gen1
   ],
+  karura: [
+    '0xbaf5aabe40646d11f0ee8abbdc64f4a4b7674925cba08e4a05ff9ebed6e2126b'
+  ],
   kulupu: [
     '0xf7a99d3cb92853d00d5275c971c132c074636256583fee53b3bbe60d7b8769ba'
   ],
@@ -40,6 +46,9 @@ export const knownGenesis: KnownGenesis = {
   polymesh: [
     '0x9deeb940c92ae02111c3bd5baca89970384f4c9849f02a1b2e53e66414d30f9f'
   ],
+  statemine: [
+    '0x48239ef607d7928874027a43a67689209727dfb3d3dc5e5b03a39bdc2eda771a'
+  ],
   subsocial: [
     '0x0bd72c1c305172e1275278aaeb3f161e02eccb7a819e63f62d47bd53a28189f8'
   ]
@@ -47,18 +56,26 @@ export const knownGenesis: KnownGenesis = {
 
 // these are icon overrides
 export const knownIcon: KnownIcon = {
+  centrifuge: 'polkadot',
   kusama: 'polkadot',
-  polkadot: 'polkadot'
+  polkadot: 'polkadot',
+  statemine: 'polkadot',
+  statemint: 'polkadot',
+  westmint: 'polkadot'
 };
 
-// support for ledger
+// These match up with the keys of the ledgerApps object in the @polkadot/hw-ledger/defaults.ts
+// 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 = {
+  centrifuge: 0x000002eb,
   'dock-mainnet': 0x00000252,
   edgeware: 0x0000020b,
   equilibrium: 0x05f5e0fd,
   kusama: 0x000001b2,
   polkadot: 0x00000162,
-  polymesh: 0x00000253
+  polymesh: 0x00000253,
+  statemine: 0x000001b2 // common-good on Kusama, shares derivation
 };
 
 // testnets should not allow selection

packages/networks/src/index.spec.ts

@@ -4,25 +4,25 @@
 import type { SubstrateNetwork } from './types';
 
 import { knownGenesis, knownIcon, knownLedger, knownTestnet } from './defaults';
-import filtered, { all, available } from '.';
+import { allNetworks, availableNetworks, selectableNetworks } from '.';
 
-describe('filtered', (): void => {
+describe('selectableNetworks', (): void => {
   it('has the correct starting order', (): void => {
-    expect(filtered.slice(0, 3).map(({ prefix }) => prefix)).toEqual([0, 2, 42]);
+    expect(selectableNetworks.slice(0, 3).map(({ prefix }) => prefix)).toEqual([0, 2, 42]);
   });
 
   it('has no ignored networks', (): void => {
-    expect(available.some(({ isIgnored }) => isIgnored)).toEqual(false);
+    expect(availableNetworks.some(({ isIgnored }) => isIgnored)).toEqual(false);
   });
 
   it('has no reserved networks', (): void => {
-    expect(available.some(({ prefix }) => prefix === 47)).toEqual(false);
+    expect(availableNetworks.some(({ prefix }) => prefix === 47)).toEqual(false);
   });
 
-  it('has all genesis information', (): void => {
+  it('has allNetworks genesis information', (): void => {
     expect(
       Object.entries(knownGenesis).filter(([network, genesisHash]) =>
-        available.some((a) =>
+        availableNetworks.some((a) =>
           a.network === network &&
           genesisHash.some((g, index) => a.genesisHash[index] !== g)
         )
@@ -30,10 +30,10 @@ describe('filtered', (): void => {
     ).toEqual([]);
   });
 
-  it('has all ledger details', (): void => {
+  it('has allNetworks ledger details', (): void => {
     expect(
       Object.entries(knownLedger).filter(([network, slip44]) =>
-        available.some((a) =>
+        availableNetworks.some((a) =>
           a.network === network && (
             a.slip44 !== slip44 ||
             !a.hasLedgerSupport ||
@@ -47,16 +47,16 @@ describe('filtered', (): void => {
   it('has no testnets exposed', (): void => {
     expect(
       Object.keys(knownTestnet).filter((network) =>
-        available.some((a) =>
+        availableNetworks.some((a) =>
           a.network === network
         )
       )
     ).toEqual([]);
   });
 
-  it('has all icons, except for overrides', (): void => {
+  it('has allNetworks icons, except for overrides', (): void => {
     expect(
-      available.filter(({ icon, network }) =>
+      availableNetworks.filter(({ icon, network }) =>
         icon !== 'substrate' &&
         knownIcon[network] !== icon
       )
@@ -67,7 +67,7 @@ describe('filtered', (): void => {
     const dupes: SubstrateNetwork[] = [];
     const uniques: SubstrateNetwork[] = [];
 
-    all.forEach((a): void => {
+    allNetworks.forEach((a): void => {
       if (uniques.some((u) => u.prefix === a.prefix)) {
         dupes.push(a);
       } else {

packages/networks/src/index.ts

@@ -11,7 +11,7 @@ export { packageInfo } from './packageInfo';
 // These are known prefixes that are not sorted
 const UNSORTED = [0, 2, 42];
 
-export const all = knownSubstrate.map((o): SubstrateNetwork => {
+export const allNetworks = knownSubstrate.map((o): SubstrateNetwork => {
   const network = o.network || '';
   const n = o as SubstrateNetwork;
 
@@ -30,7 +30,7 @@ export const all = knownSubstrate.map((o): SubstrateNetwork => {
 //   - we only include those where we have a standardAccount
 //   - when no icon has been specified, default to substrate
 //   - sort by name, however we keep 0, 2, 42 first in the list
-export const available = all
+export const availableNetworks = allNetworks
   .filter((n): n is Network => !n.isIgnored && !!n.network)
   .sort((a, b) =>
     UNSORTED.includes(a.prefix) === UNSORTED.includes(b.prefix)
@@ -43,4 +43,4 @@ export const available = all
   );
 
 // A filtered list of those chains we have details about (genesisHashes)
-export default available.filter((n) => n.genesisHash.length || n.prefix === 42);
+export const selectableNetworks = availableNetworks.filter((n) => n.genesisHash.length || n.prefix === 42);

packages/networks/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/networks', version: '6.8.1' };
+export const packageInfo = { name: '@polkadot/networks', version: '7.0.2' };

packages/networks/src/substrate.ts

@@ -332,7 +332,7 @@ export const knownSubstrate: KnownSubstrate[] = [
     network: 'centrifuge',
     prefix: 36,
     standardAccount: '*25519',
-    symbols: ['RAD'],
+    symbols: ['CFG'],
     website: 'https://centrifuge.io/'
   },
   {
@@ -506,6 +506,60 @@ export const knownSubstrate: KnownSubstrate[] = [
     symbols: ['KMA'],
     website: 'https://manta.network'
   },
+  {
+    decimals: [18],
+    displayName: 'PolkaSmith Canary Network',
+    network: 'polkasmith',
+    prefix: 98,
+    standardAccount: '*25519',
+    symbols: ['PKS'],
+    website: 'https://polkafoundry.com'
+  },
+  {
+    decimals: [18],
+    displayName: 'PolkaFoundry Network',
+    network: 'polkafoundry',
+    prefix: 99,
+    standardAccount: '*25519',
+    symbols: ['PKF'],
+    website: 'https://polkafoundry.com'
+  },
+  {
+    decimals: [18],
+    displayName: 'OriginTrail Parachain',
+    network: 'origintrail-parachain',
+    prefix: 101,
+    standardAccount: 'secp256k1',
+    symbols: ['TRAC'],
+    website: 'https://origintrail.io'
+  },
+  {
+    decimals: [12],
+    displayName: 'Heiko',
+    network: 'heiko',
+    prefix: 110,
+    standardAccount: '*25519',
+    symbols: ['HKO'],
+    website: 'https://parallel.fi/'
+  },
+  {
+    decimals: [18],
+    displayName: 'Altair',
+    network: 'altair',
+    prefix: 136,
+    standardAccount: '*25519',
+    symbols: ['AIR'],
+    website: 'https://centrifuge.io/'
+  },
+  {
+    decimals: [12],
+    displayName: 'Parallel',
+    network: 'parallel',
+    prefix: 172,
+    standardAccount: '*25519',
+    symbols: ['PARA'],
+    website: 'https://parallel.fi/'
+  },
   {
     decimals: [18],
     displayName: 'Social Network',
@@ -520,7 +574,7 @@ export const knownSubstrate: KnownSubstrate[] = [
     displayName: 'Moonbeam',
     network: 'moonbeam',
     prefix: 1284,
-    standardAccount: '*25519',
+    standardAccount: 'secp256k1',
     symbols: ['GLMR'],
     website: 'https://moonbeam.network'
   },
@@ -529,7 +583,7 @@ export const knownSubstrate: KnownSubstrate[] = [
     displayName: 'Moonriver',
     network: 'moonriver',
     prefix: 1285,
-    standardAccount: '*25519',
+    standardAccount: 'secp256k1',
     symbols: ['MOVR'],
     website: 'https://moonbeam.network'
   },

packages/networks/src/types.ts

@@ -8,7 +8,7 @@ export interface KnownSubstrate {
   displayName: string;
   network: string | null;
   prefix: number;
-  standardAccount: '*25519' | null;
+  standardAccount: '*25519' | 'secp256k1' | null;
   symbols: string[] | null;
   website: string | null;
 }

packages/util-crypto/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@polkadot/util-crypto",
-  "version": "6.8.1",
+  "version": "7.0.2",
   "type": "module",
   "description": "A collection of useful crypto utilities for @polkadot",
   "main": "index.js",
   "sideEffects": [
+    "./cryptoInit.js",
+    "./cryptoInit.cjs",
     "./detectPackage.js",
     "./detectPackage.cjs"
   ],
@@ -19,14 +21,14 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util-crypto#readme",
   "dependencies": {
-    "@babel/runtime": "^7.14.5",
-    "@polkadot/networks": "6.8.1",
-    "@polkadot/util": "6.8.1",
-    "@polkadot/wasm-crypto": "^4.0.2",
-    "@polkadot/x-randomvalues": "6.8.1",
+    "@babel/runtime": "^7.14.6",
+    "@polkadot/networks": "7.0.2",
+    "@polkadot/util": "7.0.2",
+    "@polkadot/wasm-crypto": "^4.1.2",
+    "@polkadot/x-randomvalues": "7.0.2",
     "base-x": "^3.0.8",
     "base64-js": "^1.5.1",
-    "blakejs": "^1.1.0",
+    "blakejs": "^1.1.1",
     "bn.js": "^4.11.9",
     "create-hash": "^1.2.0",
     "elliptic": "^6.5.4",
@@ -39,11 +41,11 @@
   "devDependencies": {
     "@types/bn.js": "^4.11.6",
     "@types/create-hash": "^1.2.2",
-    "@types/elliptic": "^6.4.12",
+    "@types/elliptic": "^6.4.13",
     "@types/scryptsy": "^2.0.0",
     "@types/xxhashjs": "^0.2.2"
   },
   "peerDependencies": {
-    "@polkadot/util": "6.8.1"
+    "@polkadot/util": "7.0.2"
   }
 }

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

@@ -1,12 +1,12 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { available } from '@polkadot/networks';
+import { availableNetworks } from '../networks';
 
 export const defaults = {
   allowedDecodedLengths: [1, 2, 4, 8, 32, 33],
   // publicKey has prefix + 2 checksum bytes, short only prefix + 1 checksum byte
   allowedEncodedLengths: [3, 4, 6, 10, 35, 36, 37, 38],
-  allowedPrefix: available.map(({ prefix }) => prefix),
+  allowedPrefix: availableNetworks.map(({ prefix }) => prefix),
   prefix: 42
 };

packages/util-crypto/src/base58/validate.ts

@@ -13,8 +13,8 @@ interface CheckConfig {
 
 const BASE_CONFIG = { alphabet: BASE58_ALPHABET, ipfsChar: 'z', type: 'base58' };
 
-export function validateChars ({ alphabet, ipfsChar, type }: CheckConfig, value?: string | null, ipfsCompat?: boolean): true {
-  assert(value, () => `Expected non-null, non-empty ${type} input`);
+export function validateChars ({ alphabet, ipfsChar, type }: CheckConfig, value?: unknown, ipfsCompat?: boolean): true {
+  assert(value && typeof value === 'string', () => `Expected non-null, non-empty ${type} string input`);
   assert(!ipfsCompat || value[0] === ipfsChar, () => `Expected ${type} to start with '${ipfsChar}'`);
 
   for (let i = (ipfsCompat ? 1 : 0); i < value.length; i++) {

packages/util-crypto/src/base64/validate.ts

@@ -10,7 +10,7 @@ import { assert } from '@polkadot/util';
  * Validates that the supplied value is valid base64
  */
 export function base64Validate (value?: string | null): value is string {
-  assert(value, 'Expected non-null, non-empty base64 input');
+  assert(value && typeof value === 'string', 'Expected non-null, non-empty base64 string input');
   assert(/^(?:[A-Za-z0-9+/]{2}[A-Za-z0-9+/]{2})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value), 'Invalid base64 encoding');
 
   return true;

packages/util-crypto/src/blake2/asHex.spec.ts

@@ -11,35 +11,43 @@ describe('blake2AsHex', (): void => {
     await waitReady();
   });
 
-  it('returns a 64-bit value (specified)', (): void => {
-    expect(
-      blake2AsHex('abc', 64)
-    ).toEqual('0xd8bb14d833d59559');
-  });
+  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
+    it('returns a 64-bit value (specified)', (): void => {
+      expect(
+        blake2AsHex('abc', 64, null, onlyJs)
+      ).toEqual('0xd8bb14d833d59559');
+    });
 
-  it('returns a 128-bit value (as specified)', (): void => {
-    expect(
-      blake2AsHex('abc', 128)
-    ).toEqual('0xcf4ab791c62b8d2b2109c90275287816');
-  });
+    it('returns a 128-bit value (as specified)', (): void => {
+      expect(
+        blake2AsHex('abc', 128, null, onlyJs)
+      ).toEqual('0xcf4ab791c62b8d2b2109c90275287816');
+    });
 
-  it('returns a 256-bit value (default)', (): void => {
-    expect(
-      blake2AsHex('abc')
-    ).toEqual('0xbddd813c634239723171ef3fee98579b94964e3bb1cb3e427262c8c068d52319');
-  });
+    it('returns a 128-bit value (as specified, with key)', (): void => {
+      expect(
+        blake2AsHex('abc', 128, new Uint8Array([1, 2]), onlyJs)
+      ).toEqual('0x36f3d08cda72a00ddf2be103eb5770d9');
+    });
 
-  it('returns a 512-bit value (as specified)', (): void => {
-    expect(
-      blake2AsHex('abc', 512)
-    ).toEqual('0xba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923');
-  });
+    it('returns a 256-bit value (default)', (): void => {
+      expect(
+        blake2AsHex('abc', undefined, null, onlyJs)
+      ).toEqual('0xbddd813c634239723171ef3fee98579b94964e3bb1cb3e427262c8c068d52319');
+    });
 
-  it('matches with the Rust implementation', (): void => {
-    expect(
-      blake2AsHex(
-        hexToU8a('0x454545454545454545454545454545454545454545454545454545454545454501000000000000002481853da20b9f4322f34650fea5f240dcbfb266d02db94bfa0153c31f4a29dbdbf025dd4a69a6f4ee6e1577b251b655097e298b692cb34c18d3182cac3de0dc00000000'), 256
-      )
-    ).toEqual('0x1025e5db74fdaf4d2818822dccf0e1604ae9ccc62f26cecfde23448ff0248abf');
+    it('returns a 512-bit value (as specified)', (): void => {
+      expect(
+        blake2AsHex('abc', 512, null, onlyJs)
+      ).toEqual('0xba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923');
+    });
+
+    it('matches with the Rust implementation', (): void => {
+      expect(
+        blake2AsHex(
+          hexToU8a('0x454545454545454545454545454545454545454545454545454545454545454501000000000000002481853da20b9f4322f34650fea5f240dcbfb266d02db94bfa0153c31f4a29dbdbf025dd4a69a6f4ee6e1577b251b655097e298b692cb34c18d3182cac3de0dc00000000'), 256, undefined, onlyJs
+        )
+      ).toEqual('0x1025e5db74fdaf4d2818822dccf0e1604ae9ccc62f26cecfde23448ff0248abf');
+    });
   });
 });

packages/util-crypto/src/blake2/asHex.ts

@@ -19,8 +19,8 @@ import { blake2AsU8a } from './asU8a';
  * blake2AsHex('abc'); // => 0xba80a53f981c4d0d
  * ```
  */
-export function blake2AsHex (data: Uint8Array | string, bitLength = 256): string {
+export function blake2AsHex (data: Uint8Array | string, bitLength = 256, key?: Uint8Array | null, onlyJs = false): string {
   return u8aToHex(
-    blake2AsU8a(data, bitLength)
+    blake2AsU8a(data, bitLength, key, onlyJs)
   );
 }

packages/util-crypto/src/blake2/asU8a.spec.ts

@@ -11,38 +11,32 @@ describe('blake2AsU8a', (): void => {
     await waitReady();
   });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`returns a 64-bit value by default (onlyJs=${onlyJs.toString()})`, (): void => {
+  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
+    it('returns a 64-bit value by default', (): void => {
       expect(
         blake2AsU8a('abc', undefined, undefined, onlyJs)
       ).toEqual(
         new Uint8Array([189, 221, 129, 60, 99, 66, 57, 114, 49, 113, 239, 63, 238, 152, 87, 155, 148, 150, 78, 59, 177, 203, 62, 66, 114, 98, 200, 192, 104, 213, 35, 25])
       );
     });
-  });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`returns a 128-bit value (as specified, onlyJs=${onlyJs.toString()})`, (): void => {
+    it('returns a 128-bit value (as specified,)', (): void => {
       expect(
         blake2AsU8a('abc', 128, undefined, onlyJs)
       ).toEqual(
         new Uint8Array([207, 74, 183, 145, 198, 43, 141, 43, 33, 9, 201, 2, 117, 40, 120, 22])
       );
     });
-  });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`returns a 256-bit value (as specified, onlyJs=${onlyJs.toString()})`, (): void => {
+    it('returns a 256-bit value (as specified)', (): void => {
       expect(
         blake2AsU8a('abc', 256, undefined, onlyJs)
       ).toEqual(
         new Uint8Array([189, 221, 129, 60, 99, 66, 57, 114, 49, 113, 239, 63, 238, 152, 87, 155, 148, 150, 78, 59, 177, 203, 62, 66, 114, 98, 200, 192, 104, 213, 35, 25])
       );
     });
-  });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`returns a 512-bit value (as specified, onlyJs=${onlyJs.toString()})`, (): void => {
+    it('returns a 512-bit value (as specified)', (): void => {
       expect(
         blake2AsU8a('abc', 512, undefined, onlyJs)
       ).toEqual(

packages/util-crypto/src/blake2/asU8a.ts

@@ -20,10 +20,10 @@ import { blake2b, isReady } from '@polkadot/wasm-crypto';
  * blake2AsU8a('abc'); // => [0xba, 0x80, 0xa53, 0xf98, 0x1c, 0x4d, 0x0d]
  * ```
  */
-export function blake2AsU8a (data: Uint8Array | string, bitLength = 256, key: Uint8Array | null = null, onlyJs = false): Uint8Array {
+export function blake2AsU8a (data: Uint8Array | string, bitLength = 256, key?: Uint8Array | null, onlyJs = false): Uint8Array {
   const byteLength = Math.ceil(bitLength / 8);
 
   return isReady() && !onlyJs
     ? blake2b(u8aToU8a(data), u8aToU8a(key), byteLength)
-    : js.blake2b(u8aToU8a(data), key, byteLength);
+    : js.blake2b(u8aToU8a(data), key || undefined, byteLength);
 }

packages/util-crypto/src/bundle.ts

@@ -0,0 +1,31 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import './cryptoInit';
+
+export { packageInfo } from './packageInfo';
+
+// all internal exports
+export * from './address';
+export * from './base32';
+export * from './base58';
+export * from './base64';
+export * from './blake2';
+export * from './crypto';
+export * from './ethereum';
+export * from './hd';
+export * from './hmac';
+export * from './json';
+export * from './keccak';
+export * from './key';
+export * from './mnemonic';
+export * from './networks';
+export * from './nacl';
+export * from './pbkdf2';
+export * from './random';
+export * from './schnorrkel';
+export * from './scrypt';
+export * from './secp256k1';
+export * from './sha512';
+export * from './signature';
+export * from './xxhash';

packages/util-crypto/src/ethereum/isAddress.ts

@@ -8,9 +8,7 @@ import { isEthereumChecksum } from './isChecksum';
 export function isEthereumAddress (address?: string): boolean {
   if (!address || address.length !== 42 || !isHex(address)) {
     return false;
-  }
-
-  if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) {
+  } else if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) {
     return true;
   }
 

packages/util-crypto/src/ethereum/isChecksum.ts

@@ -6,7 +6,11 @@ import { u8aToHex } from '@polkadot/util';
 import { keccakAsU8a } from '../keccak';
 
 function isInvalidChar (char: string, byte: number): boolean {
-  return (byte > 7 && char !== char.toUpperCase()) || (byte <= 7 && char !== char.toLowerCase());
+  return char !== (
+    byte > 7
+      ? char.toUpperCase()
+      : char.toLowerCase()
+  );
 }
 
 export function isEthereumChecksum (_address: string): boolean {

packages/util-crypto/src/index.ts

@@ -1,31 +1,6 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import './cryptoInit';
 import './detectPackage';
 
-export { packageInfo } from './packageInfo';
-
-// all internal exports
-export * from './address';
-export * from './base32';
-export * from './base58';
-export * from './base64';
-export * from './blake2';
-export * from './crypto';
-export * from './ethereum';
-export * from './hd';
-export * from './hmac';
-export * from './json';
-export * from './keccak';
-export * from './key';
-export * from './mnemonic';
-export * from './nacl';
-export * from './pbkdf2';
-export * from './random';
-export * from './schnorrkel';
-export * from './scrypt';
-export * from './secp256k1';
-export * from './sha512';
-export * from './signature';
-export * from './xxhash';
+export * from './bundle';

packages/util-crypto/src/keccak/asU8a.spec.ts

@@ -6,8 +6,6 @@ import { waitReady } from '@polkadot/wasm-crypto';
 
 import { keccakAsU8a } from '.';
 
-const BITS: (256 | 512)[] = [256, 512];
-
 describe('keccakAsU8a', (): void => {
   beforeEach(async (): Promise<void> => {
     await waitReady();
@@ -23,29 +21,21 @@ describe('keccakAsU8a', (): void => {
     )
   };
 
-  BITS.forEach((bitLength): void => {
-    [false, true].forEach((onlyJs): void => {
-      it(`returns an hex representation (string, bitLength=${bitLength}, onlyJs=${onlyJs.toString()})`, (): void => {
+  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
+    describe.each([256, 512] as (256 | 512)[])('bitLength=$p', (bitLength): void => {
+      it('returns an hex representation (string)', (): void => {
         expect(
           keccakAsU8a(input, bitLength, onlyJs)
         ).toEqual(output[bitLength]);
       });
-    });
-  });
 
-  BITS.forEach((bitLength): void => {
-    [false, true].forEach((onlyJs): void => {
-      it(`returns an hex representation (Buffer, bitLength=${bitLength}, onlyJs=${onlyJs.toString()})`, (): void => {
+      it('returns an hex representation (Buffer)', (): void => {
         expect(
           keccakAsU8a(Buffer.from(input), bitLength, onlyJs)
         ).toEqual(output[bitLength]);
       });
-    });
-  });
 
-  BITS.forEach((bitLength): void => {
-    [false, true].forEach((onlyJs): void => {
-      it(`returns an hex representation (Uint8Array, bitLength=${bitLength}, onlyJs=${onlyJs.toString()})`, (): void => {
+      it('returns an hex representation (Uint8Array)', (): void => {
         expect(
           keccakAsU8a(stringToU8a(input), bitLength, onlyJs)
         ).toEqual(output[bitLength]);

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

@@ -60,13 +60,11 @@ export class DeriveJunction {
   public soft (value: number | string | BigInt | BN | Uint8Array): DeriveJunction {
     if (isNumber(value) || isBn(value) || isBigInt(value)) {
       return this.soft(bnToHex(value, BN_OPTIONS));
+    } else if (isHex(value)) {
+      return this.soft(hexToU8a(value));
     } else if (isString(value)) {
-      return isHex(value)
-        ? this.soft(hexToU8a(value))
-        : this.soft(compactAddLength(stringToU8a(value)));
-    }
-
-    if (value.length > JUNCTION_ID_LEN) {
+      return this.soft(compactAddLength(stringToU8a(value)));
+    } else if (value.length > JUNCTION_ID_LEN) {
       return this.soft(blake2AsU8a(value));
     }
 

packages/util-crypto/src/mnemonic/generate.spec.ts

@@ -16,20 +16,16 @@ describe('mnemonicGenerate', (): void => {
     ).toEqual(true);
   });
 
-  [false, true].forEach((onlyJs): void => {
-    ([12, 15, 18, 21, 24] as WordCount[]).forEach((num: WordCount): void => {
-      it(`generates a valid mnemonic (${num} words, onlyJs=${onlyJs.toString()})`, (): void => {
-        const mnemonic = mnemonicGenerate(num, onlyJs);
-        const isValid = mnemonicValidate(mnemonic);
+  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
+    it.each([12, 15, 18, 21, 24] as WordCount[])('generates a valid mnemonic (%p words)', (num): void => {
+      const mnemonic = mnemonicGenerate(num, onlyJs);
+      const isValid = mnemonicValidate(mnemonic);
 
-        expect(mnemonic.split(' ')).toHaveLength(num);
-        expect(isValid).toEqual(true);
-      });
+      expect(mnemonic.split(' ')).toHaveLength(num);
+      expect(isValid).toEqual(true);
     });
-  });
 
-  [true, false].forEach((onlyJs): void => {
-    it(`generates not deterministic (onlyJs=${onlyJs.toString()})`, (): void => {
+    it('generates not deterministic', (): void => {
       const m1 = mnemonicGenerate(24, onlyJs);
       const m2 = mnemonicGenerate(24, onlyJs);
 

packages/util-crypto/src/mnemonic/toEntropy.spec.ts

@@ -12,9 +12,9 @@ describe('mnemonicToEntropy', (): void => {
     await cryptoWaitReady();
   });
 
-  tests.forEach(([mnemonic, entropy], index): void => {
-    [false, true].forEach((onlyJs): void => {
-      it(`Created correct entropy for ${index} (onlyJs = ${onlyJs.toString()})`, (): void => {
+  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
+    tests.forEach(([mnemonic, entropy], index): void => {
+      it(`Created correct entropy for ${index}`, (): void => {
         expect(u8aToHex(mnemonicToEntropy(mnemonic, onlyJs))).toEqual(entropy);
       });
     });

packages/util-crypto/src/mnemonic/toLegacySeed.spec.ts

@@ -15,35 +15,29 @@ describe('mnemonicToLegacySeed', (): void => {
     await waitReady();
   });
 
-  [undefined, 'foo', 'bar'].forEach((password): void => {
-    it(`generates Wasm & Js equivalents (password = ${password || 'undefined'})`, (): void => {
-      expect(
-        u8aEq(
-          mnemonicToLegacySeed(MNEMONIC, password, true),
-          mnemonicToLegacySeed(MNEMONIC, password, false)
-        )
-      ).toEqual(true);
-    });
+  it.each([undefined, 'foo', 'bar'])('generates Wasm & Js equivalents (password = %p', (password): void => {
+    expect(
+      u8aEq(
+        mnemonicToLegacySeed(MNEMONIC, password, true),
+        mnemonicToLegacySeed(MNEMONIC, password, false)
+      )
+    ).toEqual(true);
   });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`generates a valid 64bytes seed (onlyJs = ${onlyJs.toString()})`, (): void => {
+  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
+    it('generates a valid 64bytes seed', (): void => {
       expect(
         u8aToHex(mnemonicToLegacySeed(MNEMONIC, undefined, onlyJs, 64))
       ).toEqual(SEED_64);
     });
-  });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`generates a valid 32bytes seed (onlyJs = ${onlyJs.toString()})`, (): void => {
+    it('generates a valid 32bytes seed', (): void => {
       expect(
         u8aToHex(mnemonicToLegacySeed(MNEMONIC, undefined, onlyJs))
       ).toEqual(SEED_32);
     });
-  });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`fails with non-mnemonics (onlyJs = ${onlyJs.toString()})`, (): void => {
+    it('fails with non-mnemonics', (): void => {
       expect(
         () => mnemonicToLegacySeed('foo bar baz', undefined, onlyJs)
       ).toThrow(/mnemonic specified/);

packages/util-crypto/src/mnemonic/toLegacySeed.ts

@@ -14,13 +14,13 @@ import { mnemonicValidate } from './validate';
  * <BR>
  *
  * ```javascript
- * import { mnemonicGenerate, mnemonicToBip39, mnemonicValidate } from '@polkadot/util-crypto';
+ * import { mnemonicGenerate, mnemonicToLegacySeed, mnemonicValidate } from '@polkadot/util-crypto';
  *
  * const mnemonic = mnemonicGenerate(); // => string
  * const isValidMnemonic = mnemonicValidate(mnemonic); // => boolean
  *
  * if (isValidMnemonic) {
- *   console.log(`Seed generated from mnemonic: ${mnemonicToBip39(mnemonic)}`); => u8a
+ *   console.log(`Seed generated from mnemonic: ${mnemonicToLegacySeed(mnemonic)}`); => u8a
  * }
  * ```
  */

packages/util-crypto/src/mnemonic/toMiniSecret.spec.ts

@@ -15,28 +15,30 @@ describe('mnemonicToMiniSecret', (): void => {
     await cryptoWaitReady();
   });
 
-  [undefined, 'foo', 'bar'].forEach((password): void => {
-    it(`generates Wasm & Js equivalents (password = ${password || 'undefined'})`, (): void => {
-      expect(
-        u8aEq(
-          mnemonicToMiniSecret(MNEMONIC, password, true),
-          mnemonicToMiniSecret(MNEMONIC, password, false)
-        )
-      ).toEqual(true);
-    });
+  it.each([undefined, 'foo', 'bar'])('generates Wasm & Js equivalents for password = %p', (password): void => {
+    expect(
+      u8aEq(
+        mnemonicToMiniSecret(MNEMONIC, password, true),
+        mnemonicToMiniSecret(MNEMONIC, password, false)
+      )
+    ).toEqual(true);
   });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`generates a valid seed (onlyJs = ${onlyJs.toString()})`, (): void => {
+  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
+    it('generates a valid seed', (): void => {
       expect(
         u8aToHex(mnemonicToMiniSecret(MNEMONIC, undefined, onlyJs))
       ).toEqual(SEED);
     });
-  });
 
-  tests.forEach(([mnemonic, , seed], index): void => {
-    [false, true].forEach((onlyJs): void => {
-      it(`Created correct seed for ${index} (onlyJs = ${onlyJs.toString()})`, (): void => {
+    it('fails with non-mnemonics', (): void => {
+      expect(
+        () => mnemonicToMiniSecret('foo bar baz', undefined, onlyJs)
+      ).toThrow(/mnemonic specified/);
+    });
+
+    tests.forEach(([mnemonic, , seed], index): void => {
+      it(`Created correct seed for ${index}`, (): void => {
         expect(
           u8aToHex(mnemonicToMiniSecret(mnemonic, 'Substrate', onlyJs))
         ).toEqual(
@@ -46,12 +48,4 @@ describe('mnemonicToMiniSecret', (): void => {
       });
     });
   });
-
-  [false, true].forEach((onlyJs): void => {
-    it(`fails with non-mnemonics (onlyJs = ${onlyJs.toString()})`, (): void => {
-      expect(
-        () => mnemonicToMiniSecret('foo bar baz', undefined, onlyJs)
-      ).toThrow(/mnemonic specified/);
-    });
-  });
 });

packages/util-crypto/src/mnemonic/toMiniSecretCmp.spec.ts

@@ -0,0 +1,57 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { arrayRange, u8aEq } from '@polkadot/util';
+
+import { cryptoWaitReady, mnemonicGenerate, mnemonicToMiniSecret, naclKeypairFromSeed, schnorrkelKeypairFromSeed } from '..';
+
+// NOTE: This basically controls how long stuff runs for, YMMV
+//
+// - 100 runs with 5 checks, takes 2mins on _my_ machine
+// - 10_000 runs with 5 checks should be ~3hrs
+const NUM_RUNS = 100;
+const NUM_CHECKS = 5;
+
+// generate either a JS or WASM mnemonic
+describe.each([true, false])('mnemonicToMiniSecret (compare), onlyJsMnemonic=%p', (onlyJsMnemonic): void => {
+  beforeAll(async (): Promise<void> => {
+    await cryptoWaitReady();
+  });
+
+  // loop through lots of mnemonics
+  describe.each(arrayRange(NUM_RUNS))('run=%p', (): void => {
+    // compare both JS and WASM outputs against original
+    describe.each([true, false])('onlyJsMini=%p', (onlyJsMini): void => {
+      // NOTE we cannot actually use the onlyJsMnemonic flag here
+      const mnemonic = mnemonicGenerate(12);
+
+      describe(mnemonic, (): void => {
+        // 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 testmini = mnemonicToMiniSecret(mnemonic, count ? `${count}` : '', onlyJsMini);
+
+          // explicit minisecret compare
+          expect(
+            u8aEq(minisecret, testmini)
+          ).toEqual(true);
+
+          // compare the sr25519 keypair generated
+          expect(
+            u8aEq(srpub, schnorrkelKeypairFromSeed(testmini).publicKey)
+          ).toEqual(true);
+
+          // compare ed both in WASM and JS
+          [true, false].forEach((onlyJsEd): void => {
+            expect(
+              u8aEq(edpub, naclKeypairFromSeed(testmini, onlyJsEd).publicKey)
+            ).toEqual(true);
+          });
+        });
+      });
+    });
+  });
+});

packages/util-crypto/src/nacl/keypair/fromSeed.spec.ts

@@ -31,8 +31,10 @@ describe('naclKeypairFromSeed', (): void => {
   });
 
   it('generates a valid publicKey/secretKey pair (u8a)', (): void => {
-    expect(
-      naclKeypairFromSeed(TEST)
-    ).toEqual(RESULT);
+    [true, false].forEach((onlyJs): void => {
+      expect(
+        naclKeypairFromSeed(TEST, onlyJs)
+      ).toEqual(RESULT);
+    });
   });
 });

packages/util-crypto/src/nacl/keypair/fromSeed.ts

@@ -21,8 +21,8 @@ import { ed25519KeypairFromSeed, isReady } from '@polkadot/wasm-crypto';
  * naclKeypairFromSeed(...); // => { secretKey: [...], publicKey: [...] }
  * ```
  */
-export function naclKeypairFromSeed (seed: Uint8Array): Keypair {
-  if (isReady()) {
+export function naclKeypairFromSeed (seed: Uint8Array, onlyJs = false): Keypair {
+  if (!onlyJs && isReady()) {
     const full = ed25519KeypairFromSeed(seed);
 
     return {

packages/util-crypto/src/nacl/sign.spec.ts

@@ -11,8 +11,8 @@ describe('naclSign', (): void => {
     await waitReady();
   });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`returns a valid signature for the message (onlyJs=${onlyJs.toString()})`, (): void => {
+  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
+    it('returns a valid signature for the message', (): void => {
       expect(
         naclSign(
           new Uint8Array([0x61, 0x62, 0x63, 0x64]),

packages/util-crypto/src/nacl/verify.spec.ts

@@ -19,8 +19,8 @@ describe('naclVerify', (): void => {
     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]);
   });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`validates a correctly signed message (onlyJs=${onlyJs.toString()})`, (): void => {
+  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
+    it('validates a correctly signed message', (): void => {
       expect(
         naclVerify(
           new Uint8Array([0x61, 0x62, 0x63, 0x64]),
@@ -30,47 +30,51 @@ describe('naclVerify', (): void => {
         )
       ).toEqual(true);
     });
-  });
 
-  it('fails a correctly signed message (message changed)', (): void => {
-    expect(
-      naclVerify(
-        new Uint8Array([0x61, 0x62, 0x63, 0x64, 0x65]),
-        signature,
-        publicKey
-      )
-    ).toEqual(false);
-  });
+    it('fails a correctly signed message (message changed)', (): void => {
+      expect(
+        naclVerify(
+          new Uint8Array([0x61, 0x62, 0x63, 0x64, 0x65]),
+          signature,
+          publicKey,
+          onlyJs
+        )
+      ).toEqual(false);
+    });
 
-  it('fails a correctly signed message (signature changed)', (): void => {
-    signature[0] = 0xff;
+    it('fails a correctly signed message (signature changed)', (): void => {
+      signature[0] = 0xff;
 
-    expect(
-      naclVerify(
-        new Uint8Array([0x61, 0x62, 0x63, 0x64]),
-        signature,
-        publicKey
-      )
-    ).toEqual(false);
-  });
+      expect(
+        naclVerify(
+          new Uint8Array([0x61, 0x62, 0x63, 0x64]),
+          signature,
+          publicKey,
+          onlyJs
+        )
+      ).toEqual(false);
+    });
 
-  it('throws error when publicKey lengths do not match', (): void => {
-    expect(
-      () => naclVerify(
-        new Uint8Array([0x61, 0x62, 0x63, 0x64]),
-        signature,
-        new Uint8Array([1, 2])
-      )
-    ).toThrow(/Invalid publicKey/);
-  });
+    it('throws error when publicKey lengths do not match', (): void => {
+      expect(
+        () => naclVerify(
+          new Uint8Array([0x61, 0x62, 0x63, 0x64]),
+          signature,
+          new Uint8Array([1, 2]),
+          onlyJs
+        )
+      ).toThrow(/Invalid publicKey/);
+    });
 
-  it('throws error when signature lengths do not match', (): void => {
-    expect(
-      () => naclVerify(
-        new Uint8Array([0x61, 0x62, 0x63, 0x64]),
-        new Uint8Array([1, 2]),
-        publicKey
-      )
-    ).toThrow(/Invalid signature/);
+    it('throws error when signature lengths do not match', (): void => {
+      expect(
+        () => naclVerify(
+          new Uint8Array([0x61, 0x62, 0x63, 0x64]),
+          new Uint8Array([1, 2]),
+          publicKey,
+          onlyJs
+        )
+      ).toThrow(/Invalid signature/);
+    });
   });
 });

packages/util-crypto/src/networks.ts

@@ -0,0 +1,4 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from '@polkadot/networks';

packages/util-crypto/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/util-crypto', version: '6.8.1' };
+export const packageInfo = { name: '@polkadot/util-crypto', version: '7.0.2' };

packages/util-crypto/src/pbkdf2/encode.spec.ts

@@ -15,21 +15,19 @@ describe('pbkdf2Encode', (): void => {
     await waitReady();
   });
 
-  [256, 1024, 2048].forEach((rounds): void => {
-    it(`has equivalent Wasm & JS results (${rounds} rounds)`, (): void => {
-      const salt = randomAsU8a();
+  it.each([256, 1024, 2048])('has equivalent Wasm & JS results (%p rounds)', (rounds): void => {
+    const salt = randomAsU8a();
 
-      expect(
-        u8aEq(
-          pbkdf2Encode(TEST_PASSWORD, salt, rounds, false).password,
-          pbkdf2Encode(TEST_PASSWORD, salt, rounds, true).password
-        )
-      ).toBe(true);
-    });
+    expect(
+      u8aEq(
+        pbkdf2Encode(TEST_PASSWORD, salt, rounds, false).password,
+        pbkdf2Encode(TEST_PASSWORD, salt, rounds, true).password
+      )
+    ).toBe(true);
   });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`creates known iterations (onlyJs = ${onlyJs.toString()})`, (): void => {
+  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
+    it('creates known iterations', (): void => {
       expect(
         u8aToHex(pbkdf2Encode(TEST_PASSWORD, KNOWN_SALT, 2048, onlyJs).password)
       ).toEqual(

packages/util-crypto/src/sha512/asU8a.spec.ts

@@ -10,8 +10,8 @@ describe('sha512AsU8a', (): void => {
     await waitReady();
   });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`creates a sha-512 hash (onlyJs=${onlyJs.toString()})`, (): void => {
+  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
+    it('creates a sha-512 hash', (): void => {
       expect(
         sha512AsU8a(Uint8Array.from([0x61, 0x62, 0x63, 0x64]), onlyJs)
       ).toEqual(

packages/util-crypto/src/xxhash/asU8a.spec.ts

@@ -11,28 +11,24 @@ describe('xxhashAsU8a', (): void => {
     await waitReady();
   });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`returns a 64-bit value by default (onlyJs=${onlyJs.toString()})`, (): void => {
+  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
+    it('returns a 64-bit value by default', (): void => {
       expect(
         xxhashAsU8a('abc', undefined, onlyJs)
       ).toEqual(
         hexToU8a('0x990977adf52cbc44')
       );
     });
-  });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`returns a 128-bit value (as specified, onlyJs=${onlyJs.toString()})`, (): void => {
+    it('returns a 128-bit value (as specified', (): void => {
       expect(
         xxhashAsU8a('abc', 128, onlyJs)
       ).toEqual(
         hexToU8a('0x990977adf52cbc440889329981caa9be')
       );
     });
-  });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`returns a 256-bit value (as specified, onlyJs=${onlyJs.toString()})`, (): void => {
+    it('returns a 256-bit value (as specified)', (): void => {
       expect(
         xxhashAsU8a('abc', 256, onlyJs)
       ).toEqual(

packages/util/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/util",
-  "version": "6.8.1",
+  "version": "7.0.2",
   "type": "module",
   "description": "A collection of useful utilities for @polkadot",
   "main": "index.js",
@@ -19,9 +19,9 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util#readme",
   "dependencies": {
-    "@babel/runtime": "^7.14.5",
-    "@polkadot/x-textdecoder": "6.8.1",
-    "@polkadot/x-textencoder": "6.8.1",
+    "@babel/runtime": "^7.14.6",
+    "@polkadot/x-textdecoder": "7.0.2",
+    "@polkadot/x-textencoder": "7.0.2",
     "@types/bn.js": "^4.11.6",
     "bn.js": "^4.11.9",
     "camelcase": "^5.3.1",

packages/util/src/array/index.ts

@@ -8,3 +8,5 @@
 export { arrayChunk } from './chunk';
 export { arrayFilter } from './filter';
 export { arrayFlatten } from './flatten';
+export { arrayRange } from './range';
+export { arrayShuffle } from './shuffle';

packages/util/src/array/range.spec.ts

@@ -0,0 +1,24 @@
+// Copyright 2017-2021 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { arrayRange } from '.';
+
+describe('arrayRange', (): void => {
+  it('does not allow 0 values', (): void => {
+    expect(
+      () => arrayRange(0)
+    ).toThrow(/Expected non-zero, positive number as a range size/);
+  });
+
+  it('it creates a range of the specified length', (): void => {
+    expect(
+      arrayRange(10)
+    ).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+  });
+
+  it('it creates a range of the specified length, with offset', (): void => {
+    expect(
+      arrayRange(7, 3)
+    ).toEqual([3, 4, 5, 6, 7, 8, 9]);
+  });
+});

packages/util/src/array/range.ts

@@ -0,0 +1,25 @@
+// Copyright 2017-2021 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { assert } from '../assert';
+
+/**
+ * @name arrayRange
+ * @summary Returns a range of numbers ith the size and the specified offset
+ * @description
+ * Returns a new array of numbers with the specific size. Optionally, when `startAt`, is provided, it generates the range to start at a specific value.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { arrayRange } from '@polkadot/util';
+ *
+ * arrayRange(5); // [0, 1, 2, 3, 4]
+ * arrayRange(3, 5); // [5, 6, 7]
+ * ```
+ */
+export function arrayRange (size: number, startAt = 0): number[] {
+  assert(size > 0, 'Expected non-zero, positive number as a range size');
+
+  return new Array(size).fill(0).map((_, i) => i + startAt);
+}

packages/util/src/array/shuffle.spec.ts

@@ -0,0 +1,31 @@
+// Copyright 2017-2021 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { arrayRange, arrayShuffle } from '.';
+
+describe('arrayShuffle', (): void => {
+  it('returns an empty array as-is', (): void => {
+    expect(
+      arrayShuffle([])
+    ).toEqual([]);
+  });
+
+  it('returns a single array as-is', (): void => {
+    expect(
+      arrayShuffle([100])
+    ).toEqual([100]);
+  });
+
+  it('shuffles an array', (): void => {
+    const inp = arrayRange(100);
+    const out = arrayShuffle(inp);
+
+    expect(inp).toHaveLength(out.length);
+    expect(
+      inp.filter((v) => !out.includes(v))
+    ).toEqual([]);
+    expect(
+      JSON.stringify(inp)
+    ).not.toEqual(JSON.stringify(out));
+  });
+});

packages/util/src/array/shuffle.ts

@@ -0,0 +1,21 @@
+// Copyright 2017-2021 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export function arrayShuffle <T> (input: T[]): T[] {
+  const result = [...input];
+  let curr = result.length;
+
+  if (curr === 1) {
+    return result;
+  }
+
+  while (curr !== 0) {
+    const rand = Math.floor(Math.random() * curr);
+
+    curr--;
+
+    [result[curr], result[rand]] = [result[rand], result[curr]];
+  }
+
+  return result;
+}

packages/util/src/bundle.ts

@@ -0,0 +1,25 @@
+// Copyright 2017-2021 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @summary Utility methods for this package are split into groups
+ */
+export { packageInfo } from './packageInfo';
+
+export * from './array';
+export * from './assert';
+export * from './bn';
+export * from './buffer';
+export * from './compact';
+export * from './extractTime';
+export * from './format';
+export * from './hex';
+export * from './is';
+export * from './logger';
+export * from './memoize';
+export * from './number';
+export * from './promisify';
+export * from './string';
+export * from './stringify';
+export * from './u8a';
+export * from './versionDetect';

packages/util/src/index.ts

@@ -3,25 +3,4 @@
 
 import './detectPackage';
 
-/**
- * @summary Utility methods for this package are split into groups
- */
-export { packageInfo } from './packageInfo';
-
-export * from './array';
-export * from './assert';
-export * from './bn';
-export * from './buffer';
-export * from './compact';
-export * from './extractTime';
-export * from './format';
-export * from './hex';
-export * from './is';
-export * from './logger';
-export * from './memoize';
-export * from './number';
-export * from './promisify';
-export * from './string';
-export * from './stringify';
-export * from './u8a';
-export * from './versionDetect';
+export * from './bundle';

packages/util/src/is/buffer.ts

@@ -16,5 +16,5 @@
  * ```
  */
 export function isBuffer (value: unknown): value is Buffer {
-  return Buffer.isBuffer(value);
+  return typeof Buffer !== 'undefined' && Buffer.isBuffer(value);
 }

packages/util/src/is/compact.ts

@@ -0,0 +1,21 @@
+// Copyright 2017-2021 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { BN } from '../bn/bn';
+
+import { isFunction } from './function';
+
+interface Compact<T> {
+  toBigInt (): bigint;
+  toBn (): BN;
+  toNumber (): number;
+  unwrap (): T;
+}
+
+/**
+ * @name isCompact
+ * @summary Tests for SCALE-Compact-like object instance.
+ */
+export function isCompact <T> (value: unknown): value is Compact<T> {
+  return isFunction((value as Compact<T>).toBigInt) && isFunction((value as Compact<T>).toBn) && isFunction((value as Compact<T>).toNumber) && isFunction((value as Compact<T>).unwrap);
+}

packages/util/src/is/hex.ts

@@ -1,8 +1,6 @@
 // Copyright 2017-2021 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { isString } from './string';
-
 const HEX_REGEX = /^0x[a-fA-F0-9]+$/;
 
 /**
@@ -20,13 +18,10 @@ const HEX_REGEX = /^0x[a-fA-F0-9]+$/;
  * isHex('0x1234', 8); // => false
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/ban-types
-export function isHex (value: unknown, bitLength = -1, ignoreLength = false): value is string | String {
-  const isValidHex = value === '0x' || (isString(value) && HEX_REGEX.test(value.toString()));
-
-  if (isValidHex && bitLength !== -1) {
-    return (value as string).length === (2 + Math.ceil(bitLength / 4));
-  }
-
-  return isValidHex && (ignoreLength || ((value as string).length % 2 === 0));
+export function isHex (value: unknown, bitLength = -1, ignoreLength = false): value is string {
+  return (typeof value === 'string' && (value === '0x' || HEX_REGEX.test(value)))
+    ? bitLength === -1
+      ? ((value.length % 2 === 0) || ignoreLength)
+      : (value.length === (2 + Math.ceil(bitLength / 4)))
+    : false;
 }

packages/util/src/is/index.ts

@@ -10,6 +10,7 @@ export { isBn } from './bn';
 export { isBuffer } from './buffer';
 export { isBoolean } from './boolean';
 export { isChildClass } from './childClass';
+export { isCompact } from './compact';
 export { isError } from './error';
 export { isFunction } from './function';
 export { isHex } from './hex';

packages/util/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/util', version: '6.8.1' };
+export const packageInfo = { name: '@polkadot/util', version: '7.0.2' };

packages/util/src/u8a/cmp.spec.ts

@@ -0,0 +1,39 @@
+// Copyright 2017-2021 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { u8aCmp } from '.';
+
+describe('u8aCmp', (): void => {
+  it('has the same result as localCompare (equal length)', (): void => {
+    const a = 'test abc';
+    const b = 'test def';
+
+    expect(
+      u8aCmp(a, b)
+    ).toEqual(a.localeCompare(b));
+    expect(
+      u8aCmp(b, a)
+    ).toEqual(b.localeCompare(a));
+  });
+
+  it('has the same result as localCompare (diff length)', (): void => {
+    const a = 'test';
+    const b = 'test abc';
+
+    expect(
+      u8aCmp(a, b)
+    ).toEqual(a.localeCompare(b));
+    expect(
+      u8aCmp(b, a)
+    ).toEqual(b.localeCompare(a));
+  });
+
+  it('compares between string and Uint8Array', (): void => {
+    expect(
+      u8aCmp(
+        '0x12345678',
+        new Uint8Array([0x12, 0x34, 0x56, 0x78])
+      )
+    ).toEqual(0);
+  });
+});

packages/util/src/u8a/cmp.ts

@@ -0,0 +1,51 @@
+// Copyright 2017-2021 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { u8aToU8a } from './toU8a';
+
+function compare (a: Uint8Array, b: Uint8Array): number {
+  let i = 0;
+
+  while (true) {
+    const overA = i >= a.length;
+    const overB = i >= b.length;
+
+    if (overA && overB) {
+      // both ends reached
+      return 0;
+    } else if (overA) {
+      // a has no more data, b has data
+      return -1;
+    } else if (overB) {
+      // b has no more data, a has data
+      return 1;
+    } else if (a[i] !== b[i]) {
+      // the number in this index doesn't match
+      return a[i] > b[i]
+        ? 1
+        : -1;
+    }
+
+    i++;
+  }
+}
+
+/**
+ * @name u8aCmp
+ * @summary Compares two Uint8Arrays for sorting.
+ * @description
+ * For `UInt8Array` (or hex string) input values returning -1, 0 or +1
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aCmp } from '@polkadot/util';
+ *
+ * u8aCmp(new Uint8Array([0x67, 0x65]), new Uint8Array([0x68, 0x65])); // -1
+ * u8aCmp(new Uint8Array([0x68, 0x65]), new Uint8Array([0x68, 0x65])); // 0
+ * u8aCmp(new Uint8Array([0x69, 0x65]), new Uint8Array([0x68, 0x65])); // +1
+ * ```
+ */
+export function u8aCmp (a: Uint8Array | string, b: Uint8Array | string): number {
+  return compare(u8aToU8a(a), u8aToU8a(b));
+}

packages/util/src/u8a/eq.ts

@@ -1,32 +1,23 @@
 // Copyright 2017-2021 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { u8aCmp } from './cmp';
 import { u8aToU8a } from './toU8a';
 
 function equals (a: Uint8Array, b: Uint8Array): boolean {
-  if (a.length !== b.length) {
-    return false;
-  }
-
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) {
-      return false;
-    }
-  }
-
-  return true;
+  return (a.length === b.length) && (u8aCmp(a, b) === 0);
 }
 
 /**
  * @name u8aEq
- * @summary Compares two Uint8Arrays.
+ * @summary Compares two Uint8Arrays for equality.
  * @description
  * For `UInt8Array` (or hex string) input values true if there is a match.
  * @example
  * <BR>
  *
  * ```javascript
- * import { { u8aEq } from '@polkadot/util';
+ * import { u8aEq } from '@polkadot/util';
  *
  * u8aEq(new Uint8Array([0x68, 0x65]), new Uint8Array([0x68, 0x65])); // true
  * ```

packages/util/src/u8a/index.ts

@@ -5,6 +5,7 @@
  * @summary Utility methods to convert to and from `Uint8Array` objects
  */
 
+export { u8aCmp } from './cmp';
 export { u8aConcat } from './concat';
 export { u8aEq } from './eq';
 export { u8aFixLength } from './fixLength';

packages/util/src/u8a/sorted.ts

@@ -1,28 +1,22 @@
 // Copyright 2017-2021 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { isUndefined } from '../is/undefined';
+import { u8aCmp } from './cmp';
 
+/**
+ * @name u8aSorted
+ * @summary Sorts an array of Uint8Arrays
+ * @description
+ * For input `UInt8Array[]` return the sorted result
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aSorted} from '@polkadot/util';
+ *
+ * u8aSorted([new Uint8Array([0x69]), new Uint8Array([0x68])]); // [0x68, 0x69]
+ * ```
+ */
 export function u8aSorted (u8as: Uint8Array[]): Uint8Array[] {
-  return u8as.sort((a, b): number => {
-    let i = 0;
-
-    while (true) {
-      if (isUndefined(a[i]) && isUndefined(b[i])) {
-        return 0;
-      } else if (isUndefined(a[i])) {
-        return -1;
-      } else if (isUndefined(b[i])) {
-        return 1;
-      }
-
-      const cmp = a[i] - b[i];
-
-      if (cmp !== 0) {
-        return cmp;
-      }
-
-      i++;
-    }
-  });
+  return u8as.sort(u8aCmp);
 }

packages/util/src/u8a/toHex.ts

@@ -1,7 +1,9 @@
 // Copyright 2017-2021 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-const ALPHABET = new Array(256).fill(0).map((_, n) => n.toString(16).padStart(2, '0'));
+import { arrayRange } from '../array';
+
+const ALPHABET = arrayRange(256).map((n) => n.toString(16).padStart(2, '0'));
 
 /** @internal */
 function extract (value: Uint8Array): string {

packages/util/src/u8a/toU8a.ts

@@ -27,10 +27,10 @@ import { stringToU8a } from '../string/toU8a';
 export function u8aToU8a (value?: number[] | Buffer | Uint8Array | string | null): Uint8Array {
   if (!value) {
     return new Uint8Array();
+  } else if (isHex(value)) {
+    return hexToU8a(value);
   } else if (isString(value)) {
-    return isHex(value)
-      ? hexToU8a(value)
-      : stringToU8a(value);
+    return stringToU8a(value);
   } else if (Array.isArray(value) || isBuffer(value)) {
     return new Uint8Array(value);
   }

packages/x-bundle/README.md

@@ -0,0 +1,3 @@
+# @polkadot/x-bundle
+
+A rollup-only package to allow for bundling of builtin dependencies

packages/x-bundle/package.json

@@ -1,8 +1,8 @@
 {
-  "name": "@polkadot/x-rxjs",
-  "version": "6.8.1",
+  "name": "@polkadot/x-bundle",
+  "version": "7.0.2",
   "type": "module",
-  "description": "A pass-through interface for RxJs (allowing node + mjs usage)",
+  "description": "A bundler helper",
   "main": "index.js",
   "sideEffects": false,
   "engines": {
@@ -14,9 +14,10 @@
   "license": "Apache-2.0",
   "repository": "github:polkadot-js/common",
   "bugs": "https://github.com/polkadot-js/common/issues",
-  "homepage": "https://github.com/polkadot-js/common/tree/master/packages/x-rxjs#readme",
+  "homepage": "https://github.com/polkadot-js/common/tree/master/packages/x-bundle#readme",
   "dependencies": {
-    "@babel/runtime": "^7.14.5",
-    "rxjs": "^6.6.7"
+    "@babel/runtime": "^7.14.6",
+    "@polkadot/util": "^7.0.2",
+    "buffer-es6": "^4.9.3"
   }
 }

packages/x-bundle/src/bn.cjs

@@ -0,0 +1,6 @@
+// Copyright 2017-2021 @polkadot/x-bundle authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const { BN } = require('@polkadot/util');
+
+module.exports = BN;

packages/x-bundle/src/buffer-es6.d.ts

@@ -0,0 +1,4 @@
+// Copyright 2017-2021 @polkadot/x-bundle authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+declare module 'buffer-es6';

packages/x-bundle/src/buffer.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2021 @polkadot/x-bundle authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Buffer } from 'buffer-es6';
+
+export default Buffer;
+export { Buffer };

packages/x-bundle/src/crypto.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2021 @polkadot/x-bundle authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const crypto = {};
+
+export default crypto;

packages/x-bundle/src/empty.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2021 @polkadot/x-bundle authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const empty = {};
+
+export default empty;

packages/x-bundle/src/index.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2021 @polkadot/x-bundle authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export { packageInfo } from './packageInfo';
+
+console.error('@polkadot/x-bundle is not meant to be used directly');

packages/x-bundle/src/inherits.ts

@@ -0,0 +1,26 @@
+// Copyright 2017-2021 @polkadot/x-bundle authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapted from https://github.com/isaacs/inherits/blob/dbade4c47c548aa7259017eca8874d61c8aaad2b/inherits_browser.js
+// The ISC License
+// Copyright (c) Isaac Z. Schlueter
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/explicit-module-boundary-types
+function inherits (ctor: any, superCtor: any): any {
+  if (superCtor) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
+    ctor.super_ = superCtor;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
+    ctor.prototype = Object.create(superCtor.prototype, {
+      constructor: {
+        configurable: true,
+        enumerable: false,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        value: ctor,
+        writable: true
+      }
+    });
+  }
+}
+
+export default inherits;

packages/x-bundle/src/packageInfo.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2021 @polkadot/x-bundle authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Auto-generated by @polkadot/dev, do not edit
+
+export const packageInfo = { name: '@polkadot/x-bundle', version: '7.0.2' };

packages/x-fetch/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/x-fetch",
-  "version": "6.8.1",
+  "version": "7.0.2",
   "type": "module",
   "description": "A cross-environment fetch replacement",
   "browser": "browser.js",
@@ -18,9 +18,9 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/x-fetch#readme",
   "dependencies": {
-    "@babel/runtime": "^7.14.5",
-    "@polkadot/x-global": "6.8.1",
-    "@types/node-fetch": "^2.5.10",
+    "@babel/runtime": "^7.14.6",
+    "@polkadot/x-global": "7.0.2",
+    "@types/node-fetch": "^2.5.11",
     "node-fetch": "^2.6.1"
   }
 }

packages/x-fetch/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/x-fetch', version: '6.8.1' };
+export const packageInfo = { name: '@polkadot/x-fetch', version: '7.0.2' };

packages/x-global/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/x-global",
-  "version": "6.8.1",
+  "version": "7.0.2",
   "type": "module",
   "description": "A cross-environment global replacement",
   "main": "index.js",
@@ -16,8 +16,6 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/x-global#readme",
   "dependencies": {
-    "@babel/runtime": "^7.14.5",
-    "@types/node-fetch": "^2.5.10",
-    "node-fetch": "^2.6.1"
+    "@babel/runtime": "^7.14.6"
   }
 }

packages/x-global/src/index.ts

@@ -1,4 +1,4 @@
-// Copyright 2017-2021 @polkadot/x-fetch authors & contributors
+// Copyright 2017-2021 @polkadot/x-global authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 export { packageInfo } from './packageInfo';

packages/x-global/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/x-global', version: '6.8.1' };
+export const packageInfo = { name: '@polkadot/x-global', version: '7.0.2' };

packages/x-randomvalues/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/x-randomvalues",
-  "version": "6.8.1",
+  "version": "7.0.2",
   "type": "module",
   "description": "A cross-environment window.crypto.getRandomValues replacement",
   "browser": "browser.js",
@@ -18,10 +18,10 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/x-randomvalues#readme",
   "dependencies": {
-    "@babel/runtime": "^7.14.5",
-    "@polkadot/x-global": "6.8.1"
+    "@babel/runtime": "^7.14.6",
+    "@polkadot/x-global": "7.0.2"
   },
   "devDependencies": {
-    "@types/react-native": "^0.64.10"
+    "@types/react-native": "^0.64.11"
   }
 }

packages/x-randomvalues/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/x-randomvalues', version: '6.8.1' };
+export const packageInfo = { name: '@polkadot/x-randomvalues', version: '7.0.2' };

packages/x-rxjs/LICENSE

@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                    http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-  "License" shall mean the terms and conditions for use, reproduction,
-  and distribution as defined by Sections 1 through 9 of this document.
-
-  "Licensor" shall mean the copyright owner or entity authorized by
-  the copyright owner that is granting the License.
-
-  "Legal Entity" shall mean the union of the acting entity and all
-  other entities that control, are controlled by, or are under common
-  control with that entity. For the purposes of this definition,
-  "control" means (i) the power, direct or indirect, to cause the
-  direction or management of such entity, whether by contract or
-  otherwise, or (ii) ownership of fifty percent (50%) or more of the
-  outstanding shares, or (iii) beneficial ownership of such entity.
-
-  "You" (or "Your") shall mean an individual or Legal Entity
-  exercising permissions granted by this License.
-
-  "Source" form shall mean the preferred form for making modifications,
-  including but not limited to software source code, documentation
-  source, and configuration files.
-
-  "Object" form shall mean any form resulting from mechanical
-  transformation or translation of a Source form, including but
-  not limited to compiled object code, generated documentation,
-  and conversions to other media types.
-
-  "Work" shall mean the work of authorship, whether in Source or
-  Object form, made available under the License, as indicated by a
-  copyright notice that is included in or attached to the work
-  (an example is provided in the Appendix below).
-
-  "Derivative Works" shall mean any work, whether in Source or Object
-  form, that is based on (or derived from) the Work and for which the
-  editorial revisions, annotations, elaborations, or other modifications
-  represent, as a whole, an original work of authorship. For the purposes
-  of this License, Derivative Works shall not include works that remain
-  separable from, or merely link (or bind by name) to the interfaces of,
-  the Work and Derivative Works thereof.
-
-  "Contribution" shall mean any work of authorship, including
-  the original version of the Work and any modifications or additions
-  to that Work or Derivative Works thereof, that is intentionally
-  submitted to Licensor for inclusion in the Work by the copyright owner
-  or by an individual or Legal Entity authorized to submit on behalf of
-  the copyright owner. For the purposes of this definition, "submitted"
-  means any form of electronic, verbal, or written communication sent
-  to the Licensor or its representatives, including but not limited to
-  communication on electronic mailing lists, source code control systems,
-  and issue tracking systems that are managed by, or on behalf of, the
-  Licensor for the purpose of discussing and improving the Work, but
-  excluding communication that is conspicuously marked or otherwise
-  designated in writing by the copyright owner as "Not a Contribution."
-
-  "Contributor" shall mean Licensor and any individual or Legal Entity
-  on behalf of whom a Contribution has been received by Licensor and
-  subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-  this License, each Contributor hereby grants to You a perpetual,
-  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-  copyright license to reproduce, prepare Derivative Works of,
-  publicly display, publicly perform, sublicense, and distribute the
-  Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-  this License, each Contributor hereby grants to You a perpetual,
-  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-  (except as stated in this section) patent license to make, have made,
-  use, offer to sell, sell, import, and otherwise transfer the Work,
-  where such license applies only to those patent claims licensable
-  by such Contributor that are necessarily infringed by their
-  Contribution(s) alone or by combination of their Contribution(s)
-  with the Work to which such Contribution(s) was submitted. If You
-  institute patent litigation against any entity (including a
-  cross-claim or counterclaim in a lawsuit) alleging that the Work
-  or a Contribution incorporated within the Work constitutes direct
-  or contributory patent infringement, then any patent licenses
-  granted to You under this License for that Work shall terminate
-  as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-  Work or Derivative Works thereof in any medium, with or without
-  modifications, and in Source or Object form, provided that You
-  meet the following conditions:
-
-  (a) You must give any other recipients of the Work or
-      Derivative Works a copy of this License; and
-
-  (b) You must cause any modified files to carry prominent notices
-      stating that You changed the files; and
-
-  (c) You must retain, in the Source form of any Derivative Works
-      that You distribute, all copyright, patent, trademark, and
-      attribution notices from the Source form of the Work,
-      excluding those notices that do not pertain to any part of
-      the Derivative Works; and
-
-  (d) If the Work includes a "NOTICE" text file as part of its
-      distribution, then any Derivative Works that You distribute must
-      include a readable copy of the attribution notices contained
-      within such NOTICE file, excluding those notices that do not
-      pertain to any part of the Derivative Works, in at least one
-      of the following places: within a NOTICE text file distributed
-      as part of the Derivative Works; within the Source form or
-      documentation, if provided along with the Derivative Works; or,
-      within a display generated by the Derivative Works, if and
-      wherever such third-party notices normally appear. The contents
-      of the NOTICE file are for informational purposes only and
-      do not modify the License. You may add Your own attribution
-      notices within Derivative Works that You distribute, alongside
-      or as an addendum to the NOTICE text from the Work, provided
-      that such additional attribution notices cannot be construed
-      as modifying the License.
-
-  You may add Your own copyright statement to Your modifications and
-  may provide additional or different license terms and conditions
-  for use, reproduction, or distribution of Your modifications, or
-  for any such Derivative Works as a whole, provided Your use,
-  reproduction, and distribution of the Work otherwise complies with
-  the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-  any Contribution intentionally submitted for inclusion in the Work
-  by You to the Licensor shall be under the terms and conditions of
-  this License, without any additional terms or conditions.
-  Notwithstanding the above, nothing herein shall supersede or modify
-  the terms of any separate license agreement you may have executed
-  with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-  names, trademarks, service marks, or product names of the Licensor,
-  except as required for reasonable and customary use in describing the
-  origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-  agreed to in writing, Licensor provides the Work (and each
-  Contributor provides its Contributions) on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-  implied, including, without limitation, any warranties or conditions
-  of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-  PARTICULAR PURPOSE. You are solely responsible for determining the
-  appropriateness of using or redistributing the Work and assume any
-  risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-  whether in tort (including negligence), contract, or otherwise,
-  unless required by applicable law (such as deliberate and grossly
-  negligent acts) or agreed to in writing, shall any Contributor be
-  liable to You for damages, including any direct, indirect, special,
-  incidental, or consequential damages of any character arising as a
-  result of this License or out of the use or inability to use the
-  Work (including but not limited to damages for loss of goodwill,
-  work stoppage, computer failure or malfunction, or any and all
-  other commercial damages or losses), even if such Contributor
-  has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-  the Work or Derivative Works thereof, You may choose to offer,
-  and charge a fee for, acceptance of support, warranty, indemnity,
-  or other liability obligations and/or rights consistent with this
-  License. However, in accepting such obligations, You may act only
-  on Your own behalf and on Your sole responsibility, not on behalf
-  of any other Contributor, and only if You agree to indemnify,
-  defend, and hold each Contributor harmless for any liability
-  incurred by, or claims asserted against, such Contributor by reason
-  of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-  To apply the Apache License to your work, attach the following
-  boilerplate notice, with the fields enclosed by brackets "[]"
-  replaced with your own identifying information. (Don't include
-  the brackets!)  The text should be enclosed in the appropriate
-  comment syntax for the file format. We also recommend that a
-  file or class name and description of purpose be included on the
-  same "printed page" as the copyright notice for easier
-  identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

packages/x-rxjs/README.md

@@ -1,5 +0,0 @@
-# @polkadot/x-rxjs
-
-This is a small wrapper around rjx to make it friendly to both Node.js (from .mjs as well as .cjs) as well as bundlers using both esm and cjs modules.
-
-This need wil disappear, once rxjs supports export maps.

packages/x-rxjs/src/cjs/index.d.ts

@@ -1,4 +0,0 @@
-// Copyright 2017-2021 @polkadot/x-rxjs authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export * from 'rxjs';

packages/x-rxjs/src/cjs/index.js

@@ -1,69 +0,0 @@
-// Copyright 2017-2021 @polkadot/x-rxjs authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// This is not great, but while having esm files, rxjs doesn't quite play nicely with
-// Node.js esm files. (Hopefully this improves in 7.0, although no exports map as of yet)
-
-const rxjs = require('rxjs');
-
-exports.Observable = rxjs.Observable;
-exports.ConnectableObservable = rxjs.ConnectableObservable;
-exports.GroupedObservable = rxjs.GroupedObservable;
-exports.observable = rxjs.observable;
-exports.Subject = rxjs.Subject;
-exports.BehaviorSubject = rxjs.BehaviorSubject;
-exports.ReplaySubject = rxjs.ReplaySubject;
-exports.AsyncSubject = rxjs.AsyncSubject;
-exports.asap = rxjs.asap;
-exports.asapScheduler = rxjs.asapScheduler;
-exports.async = rxjs.async;
-exports.asyncScheduler = rxjs.asyncScheduler;
-exports.queue = rxjs.queue;
-exports.queueScheduler = rxjs.queueScheduler;
-exports.animationFrame = rxjs.animationFrame;
-exports.animationFrameScheduler = rxjs.animationFrameScheduler;
-exports.VirtualTimeScheduler = rxjs.VirtualTimeScheduler;
-exports.VirtualAction = rxjs.VirtualAction;
-exports.Scheduler = rxjs.Scheduler;
-exports.Subscription = rxjs.Subscription;
-exports.Subscriber = rxjs.Subscriber;
-exports.Notification = rxjs.Notification;
-exports.NotificationKind = rxjs.NotificationKind;
-exports.pipe = rxjs.pipe;
-exports.noop = rxjs.noop;
-exports.identity = rxjs.identity;
-exports.isObservable = rxjs.isObservable;
-exports.ArgumentOutOfRangeError = rxjs.ArgumentOutOfRangeError;
-exports.EmptyError = rxjs.EmptyError;
-exports.ObjectUnsubscribedError = rxjs.ObjectUnsubscribedError;
-exports.UnsubscriptionError = rxjs.UnsubscriptionError;
-exports.TimeoutError = rxjs.TimeoutError;
-exports.bindCallback = rxjs.bindCallback;
-exports.bindNodeCallback = rxjs.bindNodeCallback;
-exports.combineLatest = rxjs.combineLatest;
-exports.concat = rxjs.concat;
-exports.defer = rxjs.defer;
-exports.empty = rxjs.empty;
-exports.forkJoin = rxjs.forkJoin;
-exports.from = rxjs.from;
-exports.fromEvent = rxjs.fromEvent;
-exports.fromEventPattern = rxjs.fromEventPattern;
-exports.generate = rxjs.generate;
-exports.iif = rxjs.iif;
-exports.interval = rxjs.interval;
-exports.merge = rxjs.merge;
-exports.never = rxjs.never;
-exports.of = rxjs.of;
-exports.onErrorResumeNext = rxjs.onErrorResumeNext;
-exports.pairs = rxjs.pairs;
-exports.partition = rxjs.partition;
-exports.race = rxjs.race;
-exports.range = rxjs.range;
-exports.throwError = rxjs.throwError;
-exports.timer = rxjs.timer;
-exports.using = rxjs.using;
-exports.zip = rxjs.zip;
-exports.scheduled = rxjs.scheduled;
-exports.EMPTY = rxjs.EMPTY;
-exports.NEVER = rxjs.NEVER;
-exports.config = rxjs.config;

packages/x-rxjs/src/cjs/operators.d.ts

@@ -1,4 +0,0 @@
-// Copyright 2017-2021 @polkadot/x-rxjs authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export * from 'rxjs/operators';

packages/x-rxjs/src/cjs/operators.js

@@ -1,112 +0,0 @@
-// Copyright 2017-2021 @polkadot/x-rxjs authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// This is not great, but while having esm files, rxjs doesn't quite play nicely with
-// Node.js esm files. (Hopefully this improves in 7.0, although no exports map as of yet)
-
-const operators = require('rxjs/operators');
-
-exports.audit = operators.audit;
-exports.auditTime = operators.auditTime;
-exports.buffer = operators.buffer;
-exports.bufferCount = operators.bufferCount;
-exports.bufferTime = operators.bufferTime;
-exports.bufferToggle = operators.bufferToggle;
-exports.bufferWhen = operators.bufferWhen;
-exports.catchError = operators.catchError;
-exports.combineAll = operators.combineAll;
-exports.combineLatest = operators.combineLatest;
-exports.concat = operators.concat;
-exports.concatAll = operators.concatAll;
-exports.concatMap = operators.concatMap;
-exports.concatMapTo = operators.concatMapTo;
-exports.count = operators.count;
-exports.debounce = operators.debounce;
-exports.debounceTime = operators.debounceTime;
-exports.defaultIfEmpty = operators.defaultIfEmpty;
-exports.delay = operators.delay;
-exports.delayWhen = operators.delayWhen;
-exports.dematerialize = operators.dematerialize;
-exports.distinct = operators.distinct;
-exports.distinctUntilChanged = operators.distinctUntilChanged;
-exports.distinctUntilKeyChanged = operators.distinctUntilKeyChanged;
-exports.elementAt = operators.elementAt;
-exports.endWith = operators.endWith;
-exports.every = operators.every;
-exports.exhaust = operators.exhaust;
-exports.exhaustMap = operators.exhaustMap;
-exports.expand = operators.expand;
-exports.filter = operators.filter;
-exports.finalize = operators.finalize;
-exports.find = operators.find;
-exports.findIndex = operators.findIndex;
-exports.first = operators.first;
-exports.groupBy = operators.groupBy;
-exports.ignoreElements = operators.ignoreElements;
-exports.isEmpty = operators.isEmpty;
-exports.last = operators.last;
-exports.map = operators.map;
-exports.mapTo = operators.mapTo;
-exports.materialize = operators.materialize;
-exports.max = operators.max;
-exports.merge = operators.merge;
-exports.mergeAll = operators.mergeAll;
-exports.mergeMap = operators.mergeMap;
-exports.flatMap = operators.flatMap;
-exports.mergeMapTo = operators.mergeMapTo;
-exports.mergeScan = operators.mergeScan;
-exports.min = operators.min;
-exports.multicast = operators.multicast;
-exports.observeOn = operators.observeOn;
-exports.onErrorResumeNext = operators.onErrorResumeNext;
-exports.pairwise = operators.pairwise;
-exports.partition = operators.partition;
-exports.pluck = operators.pluck;
-exports.publish = operators.publish;
-exports.publishBehavior = operators.publishBehavior;
-exports.publishLast = operators.publishLast;
-exports.publishReplay = operators.publishReplay;
-exports.race = operators.race;
-exports.reduce = operators.reduce;
-exports.repeat = operators.repeat;
-exports.repeatWhen = operators.repeatWhen;
-exports.retry = operators.retry;
-exports.retryWhen = operators.retryWhen;
-exports.refCount = operators.refCount;
-exports.sample = operators.sample;
-exports.sampleTime = operators.sampleTime;
-exports.scan = operators.scan;
-exports.sequenceEqual = operators.sequenceEqual;
-exports.share = operators.share;
-exports.shareReplay = operators.shareReplay;
-exports.single = operators.single;
-exports.skip = operators.skip;
-exports.skipLast = operators.skipLast;
-exports.skipUntil = operators.skipUntil;
-exports.skipWhile = operators.skipWhile;
-exports.startWith = operators.startWith;
-exports.subscribeOn = operators.subscribeOn;
-exports.switchAll = operators.switchAll;
-exports.switchMap = operators.switchMap;
-exports.switchMapTo = operators.switchMapTo;
-exports.take = operators.take;
-exports.takeLast = operators.takeLast;
-exports.takeUntil = operators.takeUntil;
-exports.takeWhile = operators.takeWhile;
-exports.tap = operators.tap;
-exports.throttle = operators.throttle;
-exports.throttleTime = operators.throttleTime;
-exports.throwIfEmpty = operators.throwIfEmpty;
-exports.timeInterval = operators.timeInterval;
-exports.timeout = operators.timeout;
-exports.timeoutWith = operators.timeoutWith;
-exports.timestamp = operators.timestamp;
-exports.toArray = operators.toArray;
-exports.window = operators.window;
-exports.windowCount = operators.windowCount;
-exports.windowTime = operators.windowTime;
-exports.windowToggle = operators.windowToggle;
-exports.windowWhen = operators.windowWhen;
-exports.withLatestFrom = operators.withLatestFrom;
-exports.zip = operators.zip;
-exports.zipAll = operators.zipAll;

packages/x-rxjs/src/cjs/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}

packages/x-rxjs/src/index.ts

@@ -1,4 +0,0 @@
-// Copyright 2017-2021 @polkadot/x-rxjs authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export * from './cjs/index.js';