[CI Skip] release/stable 5.8.1

skip-checks: true

.123trigger

@@ -8,4 +8,5 @@
 5.4.3
 5.4.4
 5.5.2
-5.6.2
+5.6.2
+5.6.3

.github/workflows/ss58-check.yml

@@ -1,7 +1,7 @@
 name: SS58
 on:
   schedule:
-    - cron:  '45 3 * * *'
+    - cron:  '15 4/6 * * *'
 
 jobs:
   ss58:
@@ -22,3 +22,4 @@ jobs:
         GITHUB_TOKEN: ${{ secrets.GH_PAT_BOT }}
       with:
         filename: .github/ss58-check.md
+        update_existing: true

CHANGELOG.md

@@ -1,5 +1,46 @@
 # CHANGELOG
 
+## 5.8.1 Feb 26, 2021
+
+Contributed:
+
+- Add ss58 information for HydraDX (Thanks to https://github.com/jak-pan)
+- HD derivation for Ethereum (Thanks to https://github.com/joelamouche)
+
+Changes:
+
+- Adjust base64 encoding/decoding to not rely on Buffer being available
+- Rework Ethereum derivation to only use Uint8Array internally
+- Shared HD path validation for Ledger & Ethereum
+- Additional derivation, encoding and decoding tests on keyring
+- Align networks with upstream ss58 registry
+- `@polkadot/wasm-crypto` 3.2.4
+
+
+## 5.7.1 Feb 21, 2021
+
+**Breaking change** The signature of `pair.verify` now requires the signer public key as a parameter. If using `pair.verify` pass the publicKey (hex or Uint8Array) of the signer.
+
+Changes:
+
+- The signature on the keyring for `.verify` now explicitly requires the `publicKey` of the signer. Previously it only verified against an own public key.
+- Add additional ss58 test vectors (against chains with >63 prefixes in the Substrate registry)
+
+
+## 5.6.3 Feb 16, 2021
+
+Contributed:
+
+- Add ss58 information for Aventus (Thanks to https://github.com/nahuseyoum)
+
+Changes:
+
+- Add `unlock(password)` to keypair (less confusing than only having `decodePkcs8`, equivalent to `lock()`)
+- Change use of `detectPackage` to use `packageInfo.ts`
+- Align with upstream ss58 registry
+- `@polkadot/wasm-crypto` 3.2.3
+
+
 ## 5.6.2 Feb 8, 2021
 
 Changes:

package.json

@@ -7,7 +7,7 @@
     "packages/*"
   ],
   "resolutions": {
-    "typescript": "^4.1.3"
+    "typescript": "^4.1.5"
   },
   "scripts": {
     "build": "polkadot-dev-build-ts",
@@ -20,10 +20,10 @@
     "test:one": "polkadot-dev-run-test"
   },
   "devDependencies": {
-    "@babel/core": "^7.12.13",
-    "@polkadot/dev": "^0.61.25",
+    "@babel/core": "^7.13.1",
+    "@polkadot/dev": "^0.61.28",
     "@polkadot/ts": "^0.3.59",
     "@types/jest": "^26.0.20"
   },
-  "version": "5.6.2"
+  "version": "5.8.1"
 }

packages/hw-ledger-transports/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/hw-ledger-transports",
-  "version": "5.6.2",
+  "version": "5.8.1",
   "repository": "github:polkadot-js/common",
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "maintainers": [],
@@ -11,14 +11,14 @@
   "react-native": "react-native.js",
   "sideEffects": false,
   "dependencies": {
-    "@babel/runtime": "^7.12.13",
-    "@ledgerhq/hw-transport-webusb": "^5.41.0"
+    "@babel/runtime": "^7.13.7",
+    "@ledgerhq/hw-transport-webusb": "^5.43.0"
   },
   "devDependencies": {
     "@types/ledgerhq__hw-transport-node-hid": "^4.22.2",
     "@types/ledgerhq__hw-transport-webusb": "^4.70.1"
   },
   "optionalDependencies": {
-    "@ledgerhq/hw-transport-node-hid-singleton": "^5.41.0"
+    "@ledgerhq/hw-transport-node-hid-singleton": "^5.43.0"
   }
 }

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

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

packages/hw-ledger/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/hw-ledger",
-  "version": "5.6.2",
+  "version": "5.8.1",
   "repository": "github:polkadot-js/common",
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "maintainers": [],
@@ -9,9 +9,9 @@
   "main": "index.js",
   "sideEffects": false,
   "dependencies": {
-    "@babel/runtime": "^7.12.13",
-    "@polkadot/hw-ledger-transports": "5.6.2",
-    "@polkadot/util": "^5.6.2",
-    "@zondax/ledger-polkadot": "^0.13.0"
+    "@babel/runtime": "^7.13.7",
+    "@polkadot/hw-ledger-transports": "5.8.1",
+    "@polkadot/util": "^5.8.1",
+    "@zondax/ledger-polkadot": "^0.13.1"
   }
 }

packages/hw-ledger/src/packageInfo.ts

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

packages/keyring/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/keyring",
-  "version": "5.6.2",
+  "version": "5.8.1",
   "description": "Keyring management",
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "maintainers": [],
@@ -15,12 +15,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.12.13",
-    "@polkadot/util": "5.6.2",
-    "@polkadot/util-crypto": "5.6.2"
+    "@babel/runtime": "^7.13.7",
+    "@polkadot/util": "5.8.1",
+    "@polkadot/util-crypto": "5.8.1"
   },
   "peerDependencies": {
-    "@polkadot/util": "5.6.2",
-    "@polkadot/util-crypto": "5.6.2"
+    "@polkadot/util": "5.8.1",
+    "@polkadot/util-crypto": "5.8.1"
   }
 }

packages/keyring/src/detectPackage.ts

@@ -18,7 +18,7 @@
 
 import { detectPackage } from '@polkadot/util';
 
-import packageInfo from './package-info.json';
+import { packageInfo } from './packageInfo';
 
 detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname);
 

packages/keyring/src/index.spec.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { hexToU8a, stringToU8a } from '@polkadot/util';
-import { cryptoWaitReady, encodeAddress, setSS58Format } from '@polkadot/util-crypto';
+import { cryptoWaitReady, encodeAddress, randomAsU8a, setSS58Format } from '@polkadot/util-crypto';
 
 import Keyring from '.';
 
@@ -83,8 +83,9 @@ describe('keypair', (): void => {
       const pair = keyring.getPair(publicKeyOne);
       const signature = pair.sign(MESSAGE);
 
-      expect(pair.verify(MESSAGE, signature)).toBe(true);
-      expect(pair.verify(new Uint8Array(), signature)).toBe(false);
+      expect(pair.verify(MESSAGE, signature, pair.publicKey)).toBe(true);
+      expect(pair.verify(MESSAGE, signature, randomAsU8a())).toBe(false);
+      expect(pair.verify(new Uint8Array(), signature, pair.publicKey)).toBe(false);
     });
 
     it('signs and verifies (withType)', (): void => {
@@ -92,8 +93,9 @@ describe('keypair', (): void => {
       const pair = keyring.getPair(publicKeyOne);
       const signature = pair.sign(MESSAGE, { withType: true });
 
-      expect(pair.verify(MESSAGE, signature)).toBe(true);
-      expect(pair.verify(new Uint8Array(), signature)).toBe(false);
+      expect(pair.verify(MESSAGE, signature, pair.publicKey)).toBe(true);
+      expect(pair.verify(MESSAGE, signature, randomAsU8a())).toBe(false);
+      expect(pair.verify(new Uint8Array(), signature, pair.publicKey)).toBe(false);
     });
   });
 
@@ -159,8 +161,9 @@ describe('keypair', (): void => {
       const pair = keyring.getPair(publicKeyOne);
       const signature = pair.sign(MESSAGE);
 
-      expect(pair.verify(MESSAGE, signature)).toBe(true);
-      expect(pair.verify(new Uint8Array(), signature)).toBe(false);
+      expect(pair.verify(MESSAGE, signature, pair.publicKey)).toBe(true);
+      expect(pair.verify(MESSAGE, signature, randomAsU8a())).toBe(false);
+      expect(pair.verify(new Uint8Array(), signature, pair.publicKey)).toBe(false);
     });
 
     it('signs and verifies (withType)', (): void => {
@@ -168,8 +171,9 @@ describe('keypair', (): void => {
       const pair = keyring.getPair(publicKeyOne);
       const signature = pair.sign(MESSAGE, { withType: true });
 
-      expect(pair.verify(MESSAGE, signature)).toBe(true);
-      expect(pair.verify(new Uint8Array(), signature)).toBe(false);
+      expect(pair.verify(MESSAGE, signature, pair.publicKey)).toBe(true);
+      expect(pair.verify(MESSAGE, signature, randomAsU8a())).toBe(false);
+      expect(pair.verify(new Uint8Array(), signature, pair.publicKey)).toBe(false);
     });
   });
 
@@ -259,13 +263,33 @@ describe('keypair', (): void => {
       ).not.toThrow();
     });
 
+    it('encodes a pair toJSON (and decodes)', (): void => {
+      const pair = keyring.createFromUri('moral movie very draw assault whisper awful rebuild speed purity repeat card');
+      const json = pair.toJson('password');
+
+      expect(json.address).toEqual('0x03ddca309bd5fedd01f914d6fb76f23aa848a2a520802159215dba5085d7863619');
+      expect(json.encoding).toEqual({
+        content: ['pkcs8', 'ecdsa'],
+        type: ['scrypt', 'xsalsa20-poly1305'],
+        version: '3'
+      });
+
+      const newPair = keyring.createFromJson(json);
+
+      expect(newPair.publicKey).toEqual(pair.publicKey);
+      expect(
+        () => newPair.unlock('password')
+      ).not.toThrow();
+    });
+
     it('signs and verifies', (): void => {
       const MESSAGE = stringToU8a('this is a message');
       const pair = keyring.getPair(addressKeyOne);
       const signature = pair.sign(MESSAGE);
 
-      expect(pair.verify(MESSAGE, signature)).toBe(true);
-      expect(pair.verify(new Uint8Array(), signature)).toBe(false);
+      expect(pair.verify(MESSAGE, signature, pair.publicKey)).toBe(true);
+      expect(pair.verify(MESSAGE, signature, randomAsU8a())).toBe(false);
+      expect(pair.verify(new Uint8Array(), signature, pair.publicKey)).toBe(false);
     });
 
     it('signs and verifies (withType)', (): void => {
@@ -273,36 +297,69 @@ describe('keypair', (): void => {
       const pair = keyring.getPair(addressKeyOne);
       const signature = pair.sign(MESSAGE, { withType: true });
 
-      expect(pair.verify(MESSAGE, signature)).toBe(true);
-      expect(pair.verify(new Uint8Array(), signature)).toBe(false);
+      expect(pair.verify(MESSAGE, signature, pair.publicKey)).toBe(true);
+      expect(pair.verify(MESSAGE, signature, randomAsU8a())).toBe(false);
+      expect(pair.verify(new Uint8Array(), signature, pair.publicKey)).toBe(false);
     });
   });
 
   describe('ethereum', (): void => {
-    const PHRASE = 'seed sock milk update focus rotate barely fade car face mechanic mercy';
+    // combine mnemonic with derivation path
+    const PHRASE = 'seed sock milk update focus rotate barely fade car face mechanic mercy' + '/m/44\'/60\'/0\'/0/0';
+    const ETH_ADDRESS_ONE = '0x31ea8795EE32D782C8ff41a5C68Dcbf0F5B27f6d';
+
     let keyring: Keyring;
 
     beforeEach((): void => {
       keyring = new Keyring({ type: 'ethereum' });
     });
 
-    it('adds a pair with the correct address', (): void => {
+    it('creates with dev phrase with derivation path specified', (): void => {
       const pair = keyring.createFromUri(PHRASE);
 
-      expect(pair.publicKey).toEqual(hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077'));
-      expect(pair.address).toEqual('0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887');
+      expect(
+        pair.address
+      ).toEqual(ETH_ADDRESS_ONE);
     });
 
-    it('encodes a pair toJSON', (): void => {
+    it('creates with dev phrase with derivation path specified - addFromUri', (): void => {
+      expect(
+        keyring.addFromUri(PHRASE).address
+      ).toEqual(ETH_ADDRESS_ONE);
+    });
+
+    it('encodes a pair toJSON (and decodes)', (): void => {
       const pair = keyring.createFromUri(PHRASE);
       const json = pair.toJson('password');
 
-      expect(json.address).toEqual('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077');
+      expect(json.address).toEqual('0x0381351b1b46d2602b0992bb5d5531f9c1696b0812feb2534b6884adc47e2e1d8b'); // this is the public key (different from address for ethereum)
       expect(json.encoding).toEqual({
         content: ['pkcs8', 'ethereum'],
         type: ['scrypt', 'xsalsa20-poly1305'],
         version: '3'
       });
+
+      const newPair = keyring.createFromJson(json);
+
+      expect(newPair.publicKey).toEqual(pair.publicKey);
+      expect(
+        () => newPair.unlock('password')
+      ).not.toThrow();
+    });
+
+    it('encodes a pair toJSON and back', (): void => {
+      const pairOriginal = keyring.createFromUri(PHRASE);
+      const json = pairOriginal.toJson('password');
+      const pair = keyring.addFromJson(
+        json
+      );
+
+      expect(pair.address).toEqual(ETH_ADDRESS_ONE);
+
+      pair.decodePkcs8('password');
+
+      expect(pair.isLocked).toBe(false);
+      expect(pair.address).toBe(ETH_ADDRESS_ONE);
     });
 
     it('allows adding from JSON', (): void => {
@@ -328,9 +385,13 @@ describe('keypair', (): void => {
       );
 
       const signature = signer.sign(MESSAGE);
+      const dummyPublic = verifier.publicKey.slice();
 
-      expect(verifier.verify(MESSAGE, signature)).toBe(true);
-      expect(verifier.verify(new Uint8Array(), signature)).toBe(false);
+      dummyPublic[dummyPublic.length - 1] = 0;
+
+      expect(verifier.verify(MESSAGE, signature, signer.publicKey)).toBe(true);
+      expect(verifier.verify(MESSAGE, signature, dummyPublic)).toBe(false);
+      expect(verifier.verify(new Uint8Array(), signature, signer.publicKey)).toBe(false);
     });
 
     it('allows for signing/verification (withType)', (): void => {
@@ -341,9 +402,13 @@ describe('keypair', (): void => {
       );
 
       const signature = signer.sign(MESSAGE, { withType: true });
+      const dummyPublic = verifier.publicKey.slice();
 
-      expect(verifier.verify(MESSAGE, signature)).toBe(true);
-      expect(verifier.verify(new Uint8Array(), signature)).toBe(false);
+      dummyPublic[dummyPublic.length - 1] = 0;
+
+      expect(verifier.verify(MESSAGE, signature, signer.publicKey)).toBe(true);
+      expect(verifier.verify(MESSAGE, signature, dummyPublic)).toBe(false);
+      expect(verifier.verify(new Uint8Array(), signature, signer.publicKey)).toBe(false);
     });
   });
 

packages/keyring/src/keyring.ts

@@ -5,7 +5,7 @@ import type { Keypair, KeypairType } from '@polkadot/util-crypto/types';
 import type { KeyringInstance, KeyringOptions, KeyringPair, KeyringPair$Json, KeyringPair$JsonEncodingTypes, KeyringPair$Meta } from './types';
 
 import { assert, hexToU8a, isHex, isUndefined, stringToU8a } from '@polkadot/util';
-import { base64Decode, decodeAddress, encodeAddress, keyExtractSuri, keyFromPath, mnemonicToLegacySeed, mnemonicToMiniSecret, naclKeypairFromSeed as naclFromSeed, schnorrkelKeypairFromSeed as schnorrkelFromSeed, secp256k1KeypairFromSeed as secp256k1FromSeed } from '@polkadot/util-crypto';
+import { base64Decode, decodeAddress, encodeAddress, ethereumEncode, hdEthereum, keyExtractSuri, keyFromPath, mnemonicToLegacySeed, mnemonicToMiniSecret, naclKeypairFromSeed as naclFromSeed, schnorrkelKeypairFromSeed as schnorrkelFromSeed, secp256k1KeypairFromSeed as secp256k1FromSeed } from '@polkadot/util-crypto';
 
 import { DEV_PHRASE } from './defaults';
 import { createPair } from './pair';
@@ -46,7 +46,7 @@ export class Keyring implements KeyringInstance {
   constructor (options: KeyringOptions = {}) {
     options.type = options.type || 'ed25519';
 
-    assert(options && ['ecdsa', 'ethereum', 'ed25519', 'sr25519'].includes(options.type || 'undefined'), `Expected a keyring type of either 'ed25519', 'sr25519' or 'ecdsa', found '${options.type}`);
+    assert(options && ['ecdsa', 'ethereum', 'ed25519', 'sr25519'].includes(options.type || 'undefined'), `Expected a keyring type of either 'ed25519', 'sr25519', 'ethereum' or 'ecdsa', found '${options.type}`);
 
     this.#pairs = new Pairs();
     this.#ss58 = options.ss58Format;
@@ -152,6 +152,7 @@ export class Keyring implements KeyringInstance {
     const encType = !Array.isArray(type)
       ? [type]
       : type;
+      // Here the address and publicKey are 32 bytes and isomorphic. This is why the address field needs to be the public key for ethereum type pairs
     const publicKey = isHex(address)
       ? hexToU8a(address)
       : this.decodeAddress(address, ignoreChecksum);
@@ -172,7 +173,7 @@ export class Keyring implements KeyringInstance {
     const suri = _suri.startsWith('//')
       ? `${DEV_PHRASE}${_suri}`
       : _suri;
-    const { password, path, phrase } = keyExtractSuri(suri);
+    const { derivePath, password, path, phrase } = keyExtractSuri(suri);
     let seed: Uint8Array;
 
     if (isHex(phrase, 256)) {
@@ -183,7 +184,7 @@ export class Keyring implements KeyringInstance {
 
       if ([12, 15, 18, 21, 24].includes(parts.length)) {
         seed = type === 'ethereum'
-          ? mnemonicToLegacySeed(phrase)
+          ? mnemonicToLegacySeed(phrase, '', false, 64)
           : mnemonicToMiniSecret(phrase, password);
       } else {
         assert(str.length <= 32, 'specified phrase is not a valid mnemonic and is invalid as a raw seed at > 32 bytes');
@@ -192,8 +193,9 @@ export class Keyring implements KeyringInstance {
       }
     }
 
-    // FIXME Need to support Ethereum-type derivation paths
-    const derived = keyFromPath(keypairFromSeed[type](seed), path, type);
+    const derived = type === 'ethereum'
+      ? hdEthereum(seed, derivePath.substring(1))
+      : keyFromPath(keypairFromSeed[type](seed), path, type);
 
     return createPair({ toSS58: this.encodeAddress, type }, derived, meta, null);
   }
@@ -203,7 +205,9 @@ export class Keyring implements KeyringInstance {
    * @description Encodes the input into an ss58 representation
    */
   public encodeAddress = (address: Uint8Array | string, ss58Format?: number): string => {
-    return encodeAddress(address, isUndefined(ss58Format) ? this.#ss58 : ss58Format);
+    return this.type === 'ethereum'
+      ? ethereumEncode(address)
+      : encodeAddress(address, isUndefined(ss58Format) ? this.#ss58 : ss58Format);
   }
 
   /**

packages/keyring/src/packageInfo.ts

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

packages/keyring/src/pair/index.spec.ts

@@ -1,10 +1,10 @@
 // Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { hexToU8a } from '@polkadot/util';
+import { hexToU8a, u8aToHex } from '@polkadot/util';
 import { cryptoWaitReady, encodeAddress as toSS58, setSS58Format } from '@polkadot/util-crypto';
 
-import { PAIRS } from '../testing';
+import { PAIRSSR25519 } from '../testing';
 import { createTestPairs } from '../testingPairs';
 import { createPair } from '.';
 
@@ -42,16 +42,28 @@ describe('pair', (): void => {
     expect(
       keyring.alice.verify(
         new Uint8Array([0x61, 0x62, 0x63, 0x64]),
-        SIGNATURE
+        SIGNATURE,
+        keyring.alice.publicKey
       )
     ).toEqual(true);
   });
 
+  it('fails a correctly signed message (signer changed)', (): void => {
+    expect(
+      keyring.alice.verify(
+        new Uint8Array([0x61, 0x62, 0x63, 0x64, 0x65]),
+        SIGNATURE,
+        keyring.bob.publicKey
+      )
+    ).toEqual(false);
+  });
+
   it('fails a correctly signed message (message changed)', (): void => {
     expect(
       keyring.alice.verify(
         new Uint8Array([0x61, 0x62, 0x63, 0x64, 0x65]),
-        SIGNATURE
+        SIGNATURE,
+        keyring.alice.publicKey
       )
     ).toEqual(false);
   });
@@ -62,11 +74,24 @@ describe('pair', (): void => {
     expect(
       keyring.alice.vrfVerify(
         message,
-        keyring.alice.vrfSign(message)
+        keyring.alice.vrfSign(message),
+        keyring.alice.publicKey
       )
     ).toBe(true);
   });
 
+  it('fails vrf sign and verify (publicKey changed)', (): void => {
+    const message = new Uint8Array([0x61, 0x62, 0x63, 0x64, 0x65]);
+
+    expect(
+      keyring.alice.vrfVerify(
+        message,
+        keyring.alice.vrfSign(message),
+        keyring.bob.publicKey
+      )
+    ).toBe(false);
+  });
+
   it('allows setting/getting of meta', (): void => {
     keyring.bob.setMeta({ foo: 'bar', something: 'else' });
 
@@ -99,11 +124,11 @@ describe('pair', (): void => {
   });
 
   it('allows derivation on the pair', (): void => {
-    const alice = createPair({ toSS58, type: 'sr25519' }, { publicKey: PAIRS[0].publicKey, secretKey: PAIRS[0].secretKey }, {});
+    const alice = createPair({ toSS58, type: 'sr25519' }, { publicKey: PAIRSSR25519[0].publicKey, secretKey: PAIRSSR25519[0].secretKey }, {});
     const stash = alice.derive('//stash');
     const soft = alice.derive('//funding/0');
 
-    expect(stash.publicKey).toEqual(PAIRS[1].publicKey);
+    expect(stash.publicKey).toEqual(PAIRSSR25519[1].publicKey);
     expect(soft.address).toEqual('5ECQNn7UueWHPFda5qUi4fTmTtyCnPvGnuoyVVSj5CboJh9J');
   });
 
@@ -117,11 +142,43 @@ describe('pair', (): void => {
   });
 
   describe('ethereum', (): void => {
+    const PUBLICDERIVED = new Uint8Array([
+      3, 129, 53, 27, 27, 70, 210, 96,
+      43, 9, 146, 187, 93, 85, 49, 249,
+      193, 105, 107, 8, 18, 254, 178, 83,
+      75, 104, 132, 173, 196, 126, 46, 29,
+      139
+    ]);
+    const SECRETDERIVED = new Uint8Array([
+      7, 13, 195, 17, 115, 0, 1, 25,
+      24, 226, 107, 2, 23, 105, 69, 204,
+      21, 195, 213, 72, 207, 73, 253, 132,
+      24, 217, 127, 147, 175, 105, 158, 70
+    ]);
+
     it('has a valid address from a known public', (): void => {
       const pair = createPair({ toSS58, type: 'ethereum' }, { publicKey: hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077') });
 
       expect(pair.address).toEqual('0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887');
       expect(pair.addressRaw).toEqual(hexToU8a('0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887'));
     });
+
+    it('converts to json', (): void => {
+      const pair = createPair({ toSS58, type: 'ethereum' }, { publicKey: PUBLICDERIVED, secretKey: SECRETDERIVED });
+      const json = pair.toJson('password');
+
+      expect(json.encoding).toEqual({
+        content: ['pkcs8', 'ethereum'],
+        type: ['scrypt', 'xsalsa20-poly1305'],
+        version: '3'
+      });
+      expect(json.address).toEqual(u8aToHex(PUBLICDERIVED));
+    });
+
+    it('has Gerald as test address for Ethereum type parachains', (): void => {
+      const keyringEthereum = createTestPairs({ type: 'ethereum' }, false);
+
+      expect(keyringEthereum.Gerald.address).toEqual('0x6Be02d1d3665660d22FF9624b7BE0551ee1Ac91b');
+    });
   });
 });

packages/keyring/src/pair/index.ts

@@ -145,6 +145,7 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
     // eslint-disable-next-line sort-keys
     decodePkcs8,
     derive: (suri: string, meta?: KeyringPair$Meta): KeyringPair => {
+      assert(type !== 'ethereum', 'Unable to derive on this keypair');
       assert(!isLocked(secretKey), 'Cannot derive on a locked keypair');
 
       const { path } = keyExtractPath(suri);
@@ -172,14 +173,19 @@ 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)
       const address = ['ecdsa', 'ethereum'].includes(type)
         ? u8aToHex(secp256k1Compress(publicKey))
         : encodeAddress();
 
       return pairToJson(type, { address, meta }, recode(passphrase), !!passphrase);
     },
-    verify: (message: string | Uint8Array, signature: Uint8Array): boolean => {
-      return signatureVerify(message, signature, TYPE_ADDRESS[type](publicKey)).isValid;
+    unlock: (passphrase?: string): void => {
+      return decodePkcs8(passphrase);
+    },
+    verify: (message: string | Uint8Array, signature: Uint8Array, _signerPublic: string | Uint8Array): boolean => {
+      return signatureVerify(message, signature, TYPE_ADDRESS[type](u8aToU8a(_signerPublic))).isValid;
     },
     vrfSign: (message: string | Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): Uint8Array => {
       assert(!isLocked(secretKey), 'Cannot sign with a locked key pair');
@@ -192,13 +198,16 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
 
       return u8aConcat(vrfHash(proof, context, extra), proof);
     },
-    vrfVerify: (message: string | Uint8Array, vrfResult: Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): boolean => {
-      return type === 'sr25519'
-        ? schnorrkelVrfVerify(message, vrfResult, publicKey, context, extra)
-        : (
-          signatureVerify(message, u8aConcat(TYPE_PREFIX[type], vrfResult.subarray(32)), TYPE_ADDRESS[type](publicKey)).isValid &&
-          u8aEq(vrfResult.subarray(0, 32), vrfHash(vrfResult.subarray(32), context, extra))
-        );
+    vrfVerify: (message: string | Uint8Array, vrfResult: Uint8Array, _signerPublic: Uint8Array | string, context?: string | Uint8Array, extra?: string | Uint8Array): boolean => {
+      const signerPublic = TYPE_ADDRESS[type](u8aToU8a(_signerPublic));
+
+      if (type === 'sr25519') {
+        return schnorrkelVrfVerify(message, vrfResult, publicKey, context, extra);
+      }
+
+      const result = signatureVerify(message, u8aConcat(TYPE_PREFIX[type], vrfResult.subarray(32)), signerPublic);
+
+      return result.isValid && u8aEq(vrfResult.subarray(0, 32), vrfHash(vrfResult.subarray(32), context, extra));
     }
   };
 }

packages/keyring/src/pair/nobody.ts

@@ -52,6 +52,9 @@ export function nobody (): KeyringPair {
       json,
     type: 'ed25519',
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    unlock: (passphrase?: string): void =>
+      undefined,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     verify: (message: Uint8Array, signature: Uint8Array): boolean =>
       false,
     // eslint-disable-next-line @typescript-eslint/no-unused-vars

packages/keyring/src/pair/vrf.spec.ts

@@ -29,8 +29,8 @@ describe('vrf', (): void => {
     const sig2 = ecdsa.vrfSign(MESSAGE, CONTEXT);
 
     expect(u8aToHex(sig1)).toEqual(u8aToHex(sig2));
-    expect(ecdsa.vrfVerify(MESSAGE, sig1, CONTEXT)).toEqual(true);
-    expect(ecdsa.vrfVerify(MESSAGE, sig2, CONTEXT)).toEqual(true);
+    expect(ecdsa.vrfVerify(MESSAGE, sig1, ecdsa.publicKey, CONTEXT)).toEqual(true);
+    expect(ecdsa.vrfVerify(MESSAGE, sig2, ecdsa.publicKey, CONTEXT)).toEqual(true);
   });
 
   it('has deterministic signature values for ed25519', (): void => {
@@ -38,8 +38,8 @@ describe('vrf', (): void => {
     const sig2 = ed25519.vrfSign(MESSAGE, CONTEXT);
 
     expect(u8aToHex(sig1)).toEqual(u8aToHex(sig2));
-    expect(ed25519.vrfVerify(MESSAGE, sig1, CONTEXT)).toEqual(true);
-    expect(ed25519.vrfVerify(MESSAGE, sig2, CONTEXT)).toEqual(true);
+    expect(ed25519.vrfVerify(MESSAGE, sig1, ed25519.publicKey, CONTEXT)).toEqual(true);
+    expect(ed25519.vrfVerify(MESSAGE, sig2, ed25519.publicKey, CONTEXT)).toEqual(true);
   });
 
   it('has deterministic signature values for sr25519', (): void => {
@@ -47,7 +47,7 @@ describe('vrf', (): void => {
     const sig2 = sr25519.vrfSign(MESSAGE, CONTEXT);
 
     expect(u8aToHex(sig1.slice(0, 32))).toEqual(u8aToHex(sig2.slice(0, 32)));
-    expect(sr25519.vrfVerify(MESSAGE, sig1, CONTEXT)).toEqual(true);
-    expect(sr25519.vrfVerify(MESSAGE, sig2, CONTEXT)).toEqual(true);
+    expect(sr25519.vrfVerify(MESSAGE, sig1, sr25519.publicKey, CONTEXT)).toEqual(true);
+    expect(sr25519.vrfVerify(MESSAGE, sig2, sr25519.publicKey, CONTEXT)).toEqual(true);
   });
 });

packages/keyring/src/suri.spec.ts

@@ -18,6 +18,13 @@ const TESTS = {
       uri: `${PHRASE}//Alice`
     }
   ],
+  ethereum: [
+    {
+      pk: '0x0381351b1b46d2602b0992bb5d5531f9c1696b0812feb2534b6884adc47e2e1d8b',
+      ss: '0x31ea8795EE32D782C8ff41a5C68Dcbf0F5B27f6d',
+      uri: "seed sock milk update focus rotate barely fade car face mechanic mercy/m/44'/60'/0'/0/0"
+    }
+  ],
   sr25519: [
     {
       pk: '0x46ebddef8cd9bb167dc30878d7113b7e168e6f0646beffd77d69d39bad76b47a',

packages/keyring/src/testing.ts

@@ -4,6 +4,7 @@
 import type { KeyringInstance, KeyringOptions } from './types';
 
 import { hexToU8a } from '@polkadot/util';
+import { KeypairType } from '@polkadot/util-crypto/types';
 
 import { createPair } from './pair';
 import Keyring from '.';
@@ -13,53 +14,75 @@ interface PairDef {
   publicKey: Uint8Array;
   seed: string;
   secretKey?: Uint8Array;
-  type?: 'ed25519' | 'sr25519';
+  type: KeypairType
 }
 
 // NOTE This is not great since we have the secretKey here explicitly, but a testing
 // keyring is for testing - what happens is that in most cases the keyring is initialises
 // before anything else. Since the sr25519 crypto is async, this creates problems with
 // adding the keys when only the keyring is used.
-export const PAIRS: PairDef[] = [
+export const PAIRSSR25519: PairDef[] = [
   {
     publicKey: hexToU8a('0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d'),
     secretKey: hexToU8a('0x98319d4ff8a9508c4bb0cf0b5a78d760a0b2082c02775e6e82370816fedfff48925a225d97aa00682d6a59b95b18780c10d7032336e88f3442b42361f4a66011'),
-    seed: 'Alice'
+    seed: 'Alice',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f'),
     secretKey: hexToU8a('0xe8da6c9d810e020f5e3c7f5af2dea314cbeaa0d72bc6421e92c0808a0c584a6046ab28e97c3ffc77fe12b5a4d37e8cd4afbfebbf2391ffc7cb07c0f38c023efd'),
-    seed: 'Alice//stash'
+    seed: 'Alice//stash',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0x8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48'),
     secretKey: hexToU8a('0x081ff694633e255136bdb456c20a5fc8fed21f8b964c11bb17ff534ce80ebd5941ae88f85d0c1bfc37be41c904e1dfc01de8c8067b0d6d5df25dd1ac0894a325'),
-    seed: 'Bob'
+    seed: 'Bob',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e'),
     secretKey: hexToU8a('0xc006507cdfc267a21532394c49ca9b754ca71de21e15a1cdf807c7ceab6d0b6c3ed408d9d35311540dcd54931933e67cf1ea10d46f75408f82b789d9bd212fde'),
-    seed: 'Bob//stash'
+    seed: 'Bob//stash',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0x90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22'),
     secretKey: hexToU8a('0xa8f2d83016052e5d6d77b2f6fd5d59418922a09024cda701b3c34369ec43a7668faf12ff39cd4e5d92bb773972f41a7a5279ebc2ed92264bed8f47d344f8f18c'),
-    seed: 'Charlie'
+    seed: 'Charlie',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0x306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20'),
     secretKey: hexToU8a('0x20e05482ca4677e0edbc58ae9a3a59f6ed3b1a9484ba17e64d6fe8688b2b7b5d108c4487b9323b98b11fe36cb301b084e920f7b7895536809a6d62a451b25568'),
-    seed: 'Dave'
+    seed: 'Dave',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0xe659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e'),
     secretKey: hexToU8a('0x683576abfd5dc35273e4264c23095a1bf21c14517bece57c7f0cc5c0ed4ce06a3dbf386b7828f348abe15d76973a72009e6ef86a5c91db2990cb36bb657c6587'),
-    seed: 'Eve'
+    seed: 'Eve',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0x1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c'),
     secretKey: hexToU8a('0xb835c20f450079cf4f513900ae9faf8df06ad86c681884122c752a4b2bf74d4303e4f21bc6cc62bb4eeed5a9cce642c25e2d2ac1464093b50f6196d78e3a7426'),
-    seed: 'Ferdie'
+    seed: 'Ferdie',
+    type: 'sr25519'
+  }
+];
+
+export const PAIRSETHEREUM: PairDef[] = [
+  {
+    name: 'Gerald',
+    publicKey: new Uint8Array([3, 98, 79, 114, 14, 174, 103, 106,
+      4, 17, 22, 49, 201, 202, 51, 140,
+      17, 208, 245, 168, 14, 228, 34, 16,
+      198, 190, 114, 152, 60, 235, 98, 15,
+      191]),
+    secretKey: hexToU8a('0x99b3c12287537e38c90a9219d4cb074a89a16e9cdb20bf85728ebd97c343e342'),
+    seed: 'Gerald',
+    type: 'ethereum'
   }
 ];
 
@@ -71,8 +94,9 @@ export const PAIRS: PairDef[] = [
  */
 export function createTestKeyring (options: KeyringOptions = {}, isDerived = true): KeyringInstance {
   const keyring = new Keyring(options);
+  const pairs: PairDef[] = (options.type && options.type === 'ethereum') ? PAIRSETHEREUM : PAIRSSR25519;
 
-  PAIRS.forEach(({ name, publicKey, secretKey, seed, type = 'sr25519' }): void => {
+  pairs.forEach(({ name, publicKey, secretKey, seed, type }): void => {
     const meta = {
       isTesting: true,
       name: name || seed.replace('//', '_').toLowerCase()

packages/keyring/src/types.ts

@@ -40,16 +40,17 @@ export interface KeyringPair {
   readonly publicKey: Uint8Array;
   readonly type: KeypairType;
 
-  decodePkcs8: (passphrase?: string, encoded?: Uint8Array) => void;
-  derive: (suri: string, meta?: KeyringPair$Meta) => KeyringPair;
-  encodePkcs8: (passphrase?: string) => Uint8Array;
-  lock: () => void;
-  setMeta: (meta: KeyringPair$Meta) => void;
+  decodePkcs8 (passphrase?: string, encoded?: Uint8Array): void;
+  derive (suri: string, meta?: KeyringPair$Meta): KeyringPair;
+  encodePkcs8 (passphrase?: string): Uint8Array;
+  lock (): void;
+  setMeta (meta: KeyringPair$Meta): void;
   sign (message: string | Uint8Array, options?: SignOptions): Uint8Array;
   toJson (passphrase?: string): KeyringPair$Json;
-  verify (message: string | Uint8Array, signature: Uint8Array): boolean;
+  unlock (passphrase?: string): void;
+  verify (message: string | Uint8Array, signature: Uint8Array, signerPublic: string | Uint8Array): boolean;
   vrfSign (message: string | Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): Uint8Array;
-  vrfVerify (message: string | Uint8Array, vrfResult: Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): boolean;
+  vrfVerify (message: string | Uint8Array, vrfResult: Uint8Array, signerPublic: Uint8Array | string, context?: string | Uint8Array, extra?: string | Uint8Array): boolean;
 }
 
 export interface KeyringPairs {

packages/networks/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/networks",
-  "version": "5.6.2",
+  "version": "5.8.1",
   "description": "A list of all available Substrate networks and their applicable prefixes",
   "main": "index.js",
   "sideEffects": false,
@@ -12,10 +12,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.12.13"
+    "@babel/runtime": "^7.13.7"
   },
   "devDependencies": {
-    "@polkadot/util": "5.6.2",
-    "@polkadot/x-fetch": "5.6.2"
+    "@polkadot/util": "5.8.1",
+    "@polkadot/x-fetch": "5.8.1"
   }
 }

packages/networks/src/index.ts

@@ -344,6 +344,15 @@ const all: NetworkFromSubstrate[] = [
     symbols: null,
     website: null
   },
+  {
+    decimals: [12],
+    displayName: 'Ares Protocol',
+    network: 'ares',
+    prefix: 34,
+    standardAccount: '*25519',
+    symbols: ['ARES'],
+    website: 'https://www.aresprotocol.com/'
+  },
   {
     decimals: [15],
     displayName: 'Valiu Liquidity Network',
@@ -437,7 +446,43 @@ const all: NetworkFromSubstrate[] = [
     website: 'https://uniarts.me'
   },
   createReserved(46, 'This prefix is reserved.', 'reserved46'),
-  createReserved(47, 'This prefix is reserved.', 'reserved47')
+  createReserved(47, 'This prefix is reserved.', 'reserved47'),
+  {
+    decimals: [12],
+    displayName: 'Neatcoin Mainnet',
+    network: 'neatcoin',
+    prefix: 48,
+    standardAccount: '*25519',
+    symbols: ['NEAT'],
+    website: 'https://neatcoin.org'
+  },
+  {
+    decimals: [12],
+    displayName: 'HydraDX',
+    network: 'hydradx',
+    prefix: 63,
+    standardAccount: '*25519',
+    symbols: ['HDX'],
+    website: 'https://hydradx.io'
+  },
+  {
+    decimals: [18],
+    displayName: 'AvN Mainnet',
+    network: 'aventus',
+    prefix: 65,
+    standardAccount: '*25519',
+    symbols: ['AVT'],
+    website: 'https://aventus.io'
+  },
+  {
+    decimals: [12],
+    displayName: 'Crust Network',
+    network: 'crust',
+    prefix: 66,
+    standardAccount: '*25519',
+    symbols: ['CRU'],
+    website: 'https://crust.network'
+  }
 ];
 
 // The list of available/claimed prefixes

packages/networks/src/packageInfo.ts

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

packages/util-crypto/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/util-crypto",
-  "version": "5.6.2",
+  "version": "5.8.1",
   "description": "A collection of useful crypto utilities for @polkadot",
   "main": "index.js",
   "sideEffects": [
@@ -15,12 +15,13 @@
   "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.12.13",
-    "@polkadot/networks": "5.6.2",
-    "@polkadot/util": "5.6.2",
-    "@polkadot/wasm-crypto": "^3.2.2",
-    "@polkadot/x-randomvalues": "5.6.2",
+    "@babel/runtime": "^7.13.7",
+    "@polkadot/networks": "5.8.1",
+    "@polkadot/util": "5.8.1",
+    "@polkadot/wasm-crypto": "^3.2.4",
+    "@polkadot/x-randomvalues": "5.8.1",
     "base-x": "^3.0.8",
+    "base64-js": "^1.5.1",
     "blakejs": "^1.1.0",
     "bn.js": "^4.11.9",
     "create-hash": "^1.2.0",
@@ -39,6 +40,6 @@
     "@types/xxhashjs": "^0.2.2"
   },
   "peerDependencies": {
-    "@polkadot/util": "5.6.2"
+    "@polkadot/util": "5.8.1"
   }
 }

packages/util-crypto/src/address/checksum.spec.ts

@@ -11,7 +11,13 @@ describe('checkAddressChecksum', (): void => {
     ).toEqual([true, 33, 1, 2]);
   });
 
-  it('correctly extracts the info from a 2-byte-prefix address', (): void => {
+  it('correctly extracts the info from a 2-byte-prefix address (66)', (): void => {
+    expect(
+      checkAddressChecksum(base58Decode('cTGShekJ1L1UKFZR9xmv9UTJod7vqjFAPo4sDhXih2c3y1yLS'))
+    ).toEqual([true, 34, 2, 66]);
+  });
+
+  it('correctly extracts the info from a 2-byte-prefix address (255)', (): void => {
     expect(
       checkAddressChecksum(base58Decode('yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k'))
     ).toEqual([true, 34, 2, 255]);

packages/util-crypto/src/address/decode.spec.ts

@@ -81,7 +81,15 @@ describe('decodeAddress', (): void => {
     );
   });
 
-  it('decodes a 2-byte prefix', (): void => {
+  it('decodes a 2-byte prefix (65)', (): void => {
+    expect(
+      decodeAddress('cLtA6nCDyvwKcEHH4QkZDSHMhS9s78BvUJUsKUbUAn1Jc2SCF')
+    ).toEqual(
+      hexToU8a('0x08e8969768fc14399930d4b8d693f68a2ff6c6a597325d6946095e5e9d9d1b0e')
+    );
+  });
+
+  it('decodes a 2-byte prefix (255)', (): void => {
     expect(
       decodeAddress('yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k')
     ).toEqual(

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

@@ -9,10 +9,23 @@ const keyring = createTestPairs({ type: 'ed25519' }, false);
 
 const SUBKEY = [
   {
+    // substrate default
     address: '5DA4D4GL5iakrn22h5uKoevgvo18Pqj5BcdEUv8etEDPdijA',
     publicKey: '0x3050f8456519829fe03302da802d22d3233a5f4037b9a3e2bcc403ccfcb2d735',
     ss58Format: 42
   },
+  {
+    // aventus
+    address: 'cLtA6nCDyvwKcEHH4QkZDSHMhS9s78BvUJUsKUbUAn1Jc2SCF',
+    publicKey: '0x08e8969768fc14399930d4b8d693f68a2ff6c6a597325d6946095e5e9d9d1b0e',
+    ss58Format: 65
+  },
+  {
+    // crust
+    address: 'cTGShekJ1L1UKFZR9xmv9UTJod7vqjFAPo4sDhXih2c3y1yLS',
+    publicKey: '0x04a047d52fe542484c69bc528990cfeaf3a663dded0638ee1b51cf78bacd1072',
+    ss58Format: 66
+  },
   {
     // ecdsa
     address: '4pbsSkWcBaYoFHrKJZp5fDVUKbqSYD9dhZZGvpp3vQ5ysVs5ybV',
@@ -121,7 +134,7 @@ describe('encode', (): void => {
   });
 
   SUBKEY.forEach(({ address, publicKey, ss58Format }, index): void => {
-    it(`encodes with Subkey equality (${index})`, (): void => {
+    it(`encodes with Subkey equality (${index} - ${ss58Format})`, (): void => {
       expect(
         encodeAddress(publicKey, ss58Format)
       ).toEqual(address);

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { bufferToU8a } from '@polkadot/util';
+import base64 from 'base64-js';
 
 import { base64Validate } from './validate';
 
@@ -14,5 +14,5 @@ import { base64Validate } from './validate';
 export function base64Decode (value: string): Uint8Array {
   base64Validate(value);
 
-  return bufferToU8a(Buffer.from(value, 'base64'));
+  return base64.toByteArray(value);
 }

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

@@ -1,7 +1,9 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { u8aToBuffer, u8aToU8a } from '@polkadot/util';
+import base64 from 'base64-js';
+
+import { u8aToU8a } from '@polkadot/util';
 
 /**
  * @name base64Encode
@@ -10,5 +12,5 @@ import { u8aToBuffer, u8aToU8a } from '@polkadot/util';
  * From the provided input, create the base64 and return the result as a string.
  */
 export function base64Encode (value: Uint8Array | string | Buffer | number[]): string {
-  return u8aToBuffer(u8aToU8a(value)).toString('base64');
+  return base64.fromByteArray(u8aToU8a(value));
 }

packages/util-crypto/src/detectPackage.ts

@@ -18,7 +18,7 @@
 
 import { detectPackage } from '@polkadot/util';
 
-import packageInfo from './package-info.json';
+import { packageInfo } from './packageInfo';
 
 detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname);
 

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

@@ -0,0 +1,52 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { mnemonicToLegacySeed } from '@polkadot/util-crypto';
+
+import { hdEthereum } from '.';
+
+describe('hdEthereum', (): void => {
+  const PHRASE = 'seed sock milk update focus rotate barely fade car face mechanic mercy';
+  const derivationPath = 'm/44\'/60\'/0\'/0/0';
+  const PUBLIC = new Uint8Array([
+    3, 118, 64, 77, 247, 27, 4, 157,
+    236, 206, 251, 221, 230, 244, 154, 147,
+    189, 131, 249, 169, 102, 78, 3, 185,
+    153, 19, 89, 40, 24, 25, 139, 131,
+    93
+  ]);
+  const SECRET = new Uint8Array([
+    166, 162, 203, 17, 2, 206, 110, 176,
+    18, 102, 230, 144, 90, 158, 25, 232,
+    43, 180, 176, 49, 189, 149, 3, 71,
+    243, 228, 223, 104, 125, 132, 58, 228
+  ]
+  );
+  const PUBLICDERIVED = new Uint8Array([
+    3, 129, 53, 27, 27, 70, 210, 96,
+    43, 9, 146, 187, 93, 85, 49, 249,
+    193, 105, 107, 8, 18, 254, 178, 83,
+    75, 104, 132, 173, 196, 126, 46, 29,
+    139
+  ]);
+  const SECRETDERIVED = new Uint8Array([
+    7, 13, 195, 17, 115, 0, 1, 25,
+    24, 226, 107, 2, 23, 105, 69, 204,
+    21, 195, 213, 72, 207, 73, 253, 132,
+    24, 217, 127, 147, 175, 105, 158, 70
+  ]);
+
+  it('derives the right key pair from a mnemonic', (): void => {
+    const key = hdEthereum(mnemonicToLegacySeed(PHRASE, '', false, 64));
+
+    expect(key.publicKey).toEqual(PUBLIC);
+    expect(key.secretKey).toEqual(SECRET);
+  });
+
+  it('derives the right key pair from a mnemonic and a derivation path', (): void => {
+    const key = hdEthereum(mnemonicToLegacySeed(PHRASE, '', false, 64), derivationPath);
+
+    expect(key.publicKey).toEqual(PUBLICDERIVED);
+    expect(key.secretKey).toEqual(SECRETDERIVED);
+  });
+});

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

@@ -0,0 +1,72 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Keypair } from '../../types';
+
+import { assert, bnToU8a, stringToU8a, u8aConcat } from '@polkadot/util';
+
+import { hmacSha512 } from '../../hmac';
+import { secp256k1KeypairFromSeed, secp256k1PrivateKeyTweakAdd } from '../../secp256k1';
+import { HARDENED, hdValidatePath } from '../validatePath';
+
+const MASTER_SECRET = stringToU8a('Bitcoin seed');
+
+export class HDKey {
+  readonly chainCode: Uint8Array;
+  readonly publicKey: Uint8Array;
+  readonly secretKey: Uint8Array;
+
+  constructor (secretKey: Uint8Array, chainCode: Uint8Array) {
+    this.secretKey = secretKey;
+    this.publicKey = secp256k1KeypairFromSeed(secretKey).publicKey;
+    this.chainCode = chainCode;
+  }
+
+  public derive (path: string): HDKey {
+    if (path === 'm' || path === 'M' || path === "m'" || path === "M'") {
+      return this;
+    }
+
+    assert(hdValidatePath(path), 'Invalid derivation path');
+
+    return path
+      .split('/')
+      .slice(1)
+      .reduce((hd: HDKey, c): HDKey => hd.deriveChild(
+        parseInt(c, 10) + (
+          (c.length > 1) && c.endsWith("'")
+            ? HARDENED
+            : 0
+        )
+      ), this);
+  }
+
+  private deriveChild (index: number): HDKey {
+    const indexBuffer = bnToU8a(index, { bitLength: 32, isLe: false });
+    const data = index >= HARDENED
+      ? u8aConcat(new Uint8Array(1), this.secretKey, indexBuffer)
+      : u8aConcat(this.publicKey, indexBuffer);
+
+    try {
+      const I = hmacSha512(this.chainCode, data);
+
+      return new HDKey(
+        secp256k1PrivateKeyTweakAdd(this.secretKey, I.slice(0, 32)),
+        I.slice(32)
+      );
+    } catch (err) {
+      // In case parse256(IL) >= n or ki == 0, proceed with the next value for i
+      return this.deriveChild(index + 1);
+    }
+  }
+}
+
+export function hdEthereum (seed: Uint8Array, path = ''): Keypair {
+  const I = hmacSha512(MASTER_SECRET, seed);
+  const hdkey = new HDKey(I.slice(0, 32), I.slice(32));
+  const { publicKey, secretKey } = path
+    ? hdkey.derive(path)
+    : hdkey;
+
+  return { publicKey, secretKey };
+}

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

@@ -1,4 +1,6 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+export { hdEthereum } from './ethereum';
 export { hdLedger } from './ledger';
+export { hdValidatePath } from './validatePath';

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

@@ -7,15 +7,13 @@ import { assert } from '@polkadot/util';
 
 import { mnemonicValidate } from '../../mnemonic';
 import { naclKeypairFromSeed } from '../../nacl';
+import { HARDENED, hdValidatePath } from '../validatePath';
 import { ledgerDerivePrivate } from './derivePrivate';
 import { ledgerMaster } from './master';
-import { ledgerValidatePath } from './validatePath';
-
-const HARDENED = 0x80000000;
 
 export function hdLedger (mnemonic: string, path: string): Keypair {
   assert(mnemonicValidate(mnemonic), 'Invalid mnemonic passed to ledger derivation');
-  assert(ledgerValidatePath(path), 'Invalid derivation path');
+  assert(hdValidatePath(path), 'Invalid derivation path');
 
   return naclKeypairFromSeed(
     path

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

@@ -1,7 +1,9 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export function ledgerValidatePath (path: string): boolean {
+export const HARDENED = 0x80000000;
+
+export function hdValidatePath (path: string): boolean {
   if (!path.startsWith('m/')) {
     return false;
   }
@@ -10,5 +12,5 @@ export function ledgerValidatePath (path: string): boolean {
     .split('/')
     .slice(1)
     .map((n) => parseInt(n.replace("'", ''), 10))
-    .some((n) => isNaN(n));
+    .some((n) => isNaN(n) && n < HARDENED);
 }

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

@@ -7,6 +7,7 @@ import { DeriveJunction } from './DeriveJunction';
 import { keyExtractPath } from './extractPath';
 
 export interface ExtractResult {
+  derivePath: string,
   password?: string;
   path: DeriveJunction[];
   phrase: string;
@@ -27,6 +28,7 @@ export function keyExtractSuri (suri: string): ExtractResult {
   const { path } = keyExtractPath(derivePath);
 
   return {
+    derivePath,
     password,
     path,
     phrase

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

@@ -7,7 +7,8 @@ import { waitReady } from '@polkadot/wasm-crypto';
 import { mnemonicToLegacySeed } from './';
 
 const MNEMONIC = 'seed sock milk update focus rotate barely fade car face mechanic mercy';
-const SEED = '0x3c121e20de068083b49c2315697fb59a2d9e8643c24e5ea7628132c58969a027';
+const SEED_32 = '0x3c121e20de068083b49c2315697fb59a2d9e8643c24e5ea7628132c58969a027';
+const SEED_64 = '0x3c121e20de068083b49c2315697fb59a2d9e8643c24e5ea7628132c58969a0275693dd5bd9d4cc9e648475eba9613ed4678f4d62560a9c42f75bac04022ded25';
 
 describe('mnemonicToLegacySeed', (): void => {
   beforeEach(async (): Promise<void> => {
@@ -26,10 +27,18 @@ describe('mnemonicToLegacySeed', (): void => {
   });
 
   [false, true].forEach((onlyJs): void => {
-    it(`generates a valid seed (onlyJs = ${onlyJs.toString()})`, (): void => {
+    it(`generates a valid 64bytes seed (onlyJs = ${onlyJs.toString()})`, (): 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 => {
       expect(
         u8aToHex(mnemonicToLegacySeed(MNEMONIC, undefined, onlyJs))
-      ).toEqual(SEED);
+      ).toEqual(SEED_32);
     });
   });
 

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

@@ -24,10 +24,17 @@ import { mnemonicValidate } from './validate';
  * }
  * ```
  */
-export function mnemonicToLegacySeed (mnemonic: string, password = '', onlyJs = false): Uint8Array {
+export function mnemonicToLegacySeed (mnemonic: string, password = '', onlyJs = false, byteLength: 32 | 64 = 32): Uint8Array {
   assert(mnemonicValidate(mnemonic), 'Invalid bip39 mnemonic specified');
+  assert([32, 64].includes(byteLength), `Invalid seed length ${byteLength}, expected 32 or 64`);
 
-  return isReady() && !onlyJs
-    ? bip39ToSeed(mnemonic, password)
-    : mnemonicToSeedSync(mnemonic, password).subarray(0, 32);
+  if (byteLength && byteLength === 32) {
+    return isReady() && !onlyJs
+      ? bip39ToSeed(mnemonic, password)
+      : mnemonicToSeedSync(mnemonic, password).subarray(0, 32);
+  } else if (byteLength === 64) {
+    return mnemonicToSeedSync(mnemonic, password);
+  } else {
+    return new Uint8Array();
+  }
 }

packages/util-crypto/src/packageInfo.ts

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

packages/util-crypto/src/secp256k1/index.ts

@@ -6,4 +6,5 @@ export { secp256k1Expand } from './expand';
 export { secp256k1KeypairFromSeed } from './keypair/fromSeed';
 export { secp256k1Recover } from './recover';
 export { secp256k1Sign } from './sign';
+export { secp256k1PrivateKeyTweakAdd } from './tweakAdd';
 export { secp256k1Verify } from './verify';

packages/util-crypto/src/secp256k1/tweakAdd.spec.ts

@@ -0,0 +1,31 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { secp256k1PrivateKeyTweakAdd } from './tweakAdd';
+
+describe('TweakAdd', (): void => {
+  describe('PrivateKey TweakAdd', (): void => {
+    it('succeeds for a simple case', (): void => {
+      const A = new Uint8Array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1]);
+      const B = new Uint8Array([3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]);
+
+      expect(
+        secp256k1PrivateKeyTweakAdd(A, B)
+      ).toEqual(new Uint8Array([
+        3, 4, 3, 4, 3, 4, 3, 4, 3,
+        4, 3, 4, 3, 4, 3, 4, 3, 4,
+        3, 4, 3, 4, 3, 4, 3, 4, 3,
+        4, 3, 4, 3, 4
+      ]));
+    });
+
+    it('fails for wrong array length', (): void => {
+      const A = new Uint8Array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1]);
+      const B = new Uint8Array([3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]);
+
+      expect(
+        () => secp256k1PrivateKeyTweakAdd(A, B)
+      ).toThrow(/Expected tweak to be an Uint8Array/);
+    });
+  });
+});

packages/util-crypto/src/secp256k1/tweakAdd.ts

@@ -0,0 +1,29 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BN from 'bn.js';
+
+import { assert, bnToU8a, isU8a } from '@polkadot/util';
+
+import { secp256k1 } from './secp256k1';
+
+const ecparams = secp256k1.curve as { n: BN };
+
+export function secp256k1PrivateKeyTweakAdd (seckey: Uint8Array, tweak: Uint8Array): Uint8Array {
+  assert(isU8a(seckey) && seckey.length === 32, 'Expected seckey to be an Uint8Array with length 32');
+  assert(isU8a(tweak) && tweak.length === 32, 'Expected tweak to be an Uint8Array with length 32');
+
+  const bn = new BN(tweak);
+
+  assert(bn.cmp(ecparams.n) < 0, 'Tweak parameter is out of range');
+
+  bn.iadd(new BN(seckey));
+
+  if (bn.cmp(ecparams.n) >= 0) {
+    bn.isub(ecparams.n);
+  }
+
+  assert(!bn.isZero(), 'Invalid resulting private key');
+
+  return bnToU8a(bn, { bitLength: 256, isLe: false });
+}

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

@@ -36,21 +36,24 @@ describe('signatureVerify', (): void => {
     it('verifies an ed25519 signature', (): void => {
       expect(signatureVerify(MESSAGE, SIG_ED, ADDR_ED)).toEqual({
         crypto: 'ed25519',
-        isValid: true
+        isValid: true,
+        publicKey: decodeAddress(ADDR_ED)
       });
     });
 
     it('verifies an ecdsa signature', (): void => {
       expect(signatureVerify(MESSAGE, SIG_EC, ADDR_EC)).toEqual({
         crypto: 'ecdsa',
-        isValid: true
+        isValid: true,
+        publicKey: decodeAddress(ADDR_EC)
       });
     });
 
     it('verifies an ethereum signature', (): void => {
       expect(signatureVerify(MESSAGE, SIG_ET, ADDR_ET)).toEqual({
         crypto: 'ethereum',
-        isValid: true
+        isValid: true,
+        publicKey: hexToU8a(ADDR_ET)
       });
     });
 
@@ -63,35 +66,40 @@ describe('signatureVerify', (): void => {
         '0x002309df96687e44280bb72c3818358faeeb699c'
       )).toEqual({
         crypto: 'ethereum',
-        isValid: true
+        isValid: true,
+        publicKey: hexToU8a('0x002309df96687e44280bb72c3818358faeeb699c')
       });
     });
 
     it('fails on invalid ethereum signature', (): void => {
       expect(signatureVerify(MESSAGE, SIG_EC, ADDR_ET)).toEqual({
         crypto: 'none',
-        isValid: false
+        isValid: false,
+        publicKey: hexToU8a(ADDR_ET)
       });
     });
 
     it('verifies an sr25519 signature', (): void => {
       expect(signatureVerify(MESSAGE, SIG_SR, ADDR_SR)).toEqual({
         crypto: 'sr25519',
-        isValid: true
+        isValid: true,
+        publicKey: decodeAddress(ADDR_SR)
       });
     });
 
     it('allows various inputs', (): void => {
       expect(signatureVerify(stringToU8a(MESSAGE), hexToU8a(SIG_ED), decodeAddress(ADDR_ED))).toEqual({
         crypto: 'ed25519',
-        isValid: true
+        isValid: true,
+        publicKey: decodeAddress(ADDR_ED)
       });
     });
 
     it('fails on an invalid signature', (): void => {
       expect(signatureVerify(MESSAGE, SIG_SR, ADDR_ED)).toEqual({
         crypto: 'none',
-        isValid: false
+        isValid: false,
+        publicKey: decodeAddress(ADDR_ED)
       });
     });
   });
@@ -100,35 +108,40 @@ describe('signatureVerify', (): void => {
     it('verifies an ed25519 signature', (): void => {
       expect(signatureVerify(MESSAGE, MUL_ED, ADDR_ED)).toEqual({
         crypto: 'ed25519',
-        isValid: true
+        isValid: true,
+        publicKey: decodeAddress(ADDR_ED)
       });
     });
 
     it('verifies an ecdsa signature', (): void => {
       expect(signatureVerify(MESSAGE, MUL_EC, ADDR_EC)).toEqual({
         crypto: 'ecdsa',
-        isValid: true
+        isValid: true,
+        publicKey: decodeAddress(ADDR_EC)
       });
     });
 
     it('verifies an ethereum signature', (): void => {
       expect(signatureVerify(MESSAGE, MUL_ET, ADDR_ET)).toEqual({
         crypto: 'ethereum',
-        isValid: true
+        isValid: true,
+        publicKey: hexToU8a(ADDR_ET)
       });
     });
 
     it('verifies an sr25519 signature', (): void => {
       expect(signatureVerify(MESSAGE, MUL_SR, ADDR_SR)).toEqual({
         crypto: 'sr25519',
-        isValid: true
+        isValid: true,
+        publicKey: decodeAddress(ADDR_SR)
       });
     });
 
     it('fails on an invalid signature', (): void => {
       expect(signatureVerify(MESSAGE, MUL_SR, ADDR_ED)).toEqual({
         crypto: 'sr25519',
-        isValid: false
+        isValid: false,
+        publicKey: new Uint8Array([61, 12, 55, 211, 0, 211, 97, 199, 4, 37, 17, 213, 81, 175, 166, 23, 251, 199, 144, 210, 19, 83, 186, 1, 196, 231, 14, 156, 171, 46, 141, 146])
       });
     });
   });

packages/util-crypto/src/signature/verify.ts

@@ -79,9 +79,9 @@ export function signatureVerify (message: Uint8Array | string, signature: Uint8A
 
   assert([64, 65, 66].includes(signatureU8a.length), `Invalid signature length, expected [64..66] bytes, found ${signatureU8a.length}`);
 
-  const result: VerifyResult = { crypto: 'none', isValid: false };
   const publicKey = decodeAddress(addressOrPublicKey);
   const input = { message, publicKey, signature: signatureU8a };
+  const result: VerifyResult = { crypto: 'none', isValid: false, publicKey };
 
   return [0, 1, 2].includes(signatureU8a[0]) && [65, 66].includes(signatureU8a.length)
     ? verifyMultisig(result, input)

packages/util-crypto/src/types.ts

@@ -16,4 +16,5 @@ export type KeypairType = 'ed25519' | 'sr25519' | 'ecdsa' | 'ethereum';
 export interface VerifyResult {
   crypto: 'none' | KeypairType;
   isValid: boolean;
+  publicKey: Uint8Array;
 }

packages/util/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/util",
-  "version": "5.6.2",
+  "version": "5.8.1",
   "description": "A collection of useful utilities for @polkadot",
   "main": "index.js",
   "sideEffects": false,
@@ -12,9 +12,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.12.13",
-    "@polkadot/x-textdecoder": "5.6.2",
-    "@polkadot/x-textencoder": "5.6.2",
+    "@babel/runtime": "^7.13.7",
+    "@polkadot/x-textdecoder": "5.8.1",
+    "@polkadot/x-textencoder": "5.8.1",
     "@types/bn.js": "^4.11.6",
     "bn.js": "^4.11.9",
     "camelcase": "^5.3.1",

packages/util/src/packageInfo.ts

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

packages/x-fetch/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/x-fetch",
-  "version": "5.6.2",
+  "version": "5.8.1",
   "description": "A cross-environment fetch replacement",
   "browser": "browser.js",
   "main": "node.js",
@@ -14,8 +14,8 @@
   "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.12.13",
-    "@polkadot/x-global": "5.6.2",
+    "@babel/runtime": "^7.13.7",
+    "@polkadot/x-global": "5.8.1",
     "@types/node-fetch": "^2.5.8",
     "node-fetch": "^2.6.1"
   }

packages/x-fetch/src/packageInfo.ts

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

packages/x-global/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/x-global",
-  "version": "5.6.2",
+  "version": "5.8.1",
   "description": "A cross-environment global replacement",
   "main": "index.js",
   "sideEffects": false,
@@ -12,7 +12,7 @@
   "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.12.13",
+    "@babel/runtime": "^7.13.7",
     "@types/node-fetch": "^2.5.8",
     "node-fetch": "^2.6.1"
   }

packages/x-global/src/packageInfo.ts

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

packages/x-randomvalues/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/x-randomvalues",
-  "version": "5.6.2",
+  "version": "5.8.1",
   "description": "A cross-environment window.crypto.getRandomValues replacement",
   "browser": "browser.js",
   "main": "node.js",
@@ -14,10 +14,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.12.13",
-    "@polkadot/x-global": "5.6.2"
+    "@babel/runtime": "^7.13.7",
+    "@polkadot/x-global": "5.8.1"
   },
   "devDependencies": {
-    "@types/react-native": "^0.63.48"
+    "@types/react-native": "^0.63.50"
   }
 }

packages/x-randomvalues/src/packageInfo.ts

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

packages/x-rxjs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/x-rxjs",
-  "version": "5.6.2",
+  "version": "5.8.1",
   "description": "A pass-through interface for RxJs (allowing node + mjs usage)",
   "main": "index.js",
   "sideEffects": false,
@@ -12,7 +12,7 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/x-rxjs#readme",
   "dependencies": {
-    "@babel/runtime": "^7.12.13",
-    "rxjs": "^6.6.3"
+    "@babel/runtime": "^7.13.7",
+    "rxjs": "^6.6.6"
   }
 }

packages/x-rxjs/src/packageInfo.ts

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

packages/x-textdecoder/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/x-textdecoder",
-  "version": "5.6.2",
+  "version": "5.8.1",
   "description": "A TextDecoder replacement",
   "browser": "browser.js",
   "main": "node.js",
@@ -14,7 +14,7 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/x-textdecoder#readme",
   "dependencies": {
-    "@babel/runtime": "^7.12.13",
-    "@polkadot/x-global": "5.6.2"
+    "@babel/runtime": "^7.13.7",
+    "@polkadot/x-global": "5.8.1"
   }
 }

packages/x-textdecoder/src/packageInfo.ts

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

packages/x-textencoder/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/x-textencoder",
-  "version": "5.6.2",
+  "version": "5.8.1",
   "description": "A TextDecoder replacement",
   "browser": "browser.js",
   "main": "node.js",
@@ -14,7 +14,7 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/x-textencoder#readme",
   "dependencies": {
-    "@babel/runtime": "^7.12.13",
-    "@polkadot/x-global": "5.6.2"
+    "@babel/runtime": "^7.13.7",
+    "@polkadot/x-global": "5.8.1"
   }
 }

packages/x-textencoder/src/packageInfo.ts

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

packages/x-ws/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/x-ws",
-  "version": "5.6.2",
+  "version": "5.8.1",
   "description": "A cross-environment WebSocket replacement",
   "browser": "browser.js",
   "main": "node.js",
@@ -14,8 +14,8 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/x-ws#readme",
   "dependencies": {
-    "@babel/runtime": "^7.12.13",
-    "@polkadot/x-global": "5.6.2",
+    "@babel/runtime": "^7.13.7",
+    "@polkadot/x-global": "5.8.1",
     "@types/websocket": "^1.0.1",
     "websocket": "^1.0.33"
   }

packages/x-ws/src/packageInfo.ts

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