[CI Skip] release/stable 10.1.1

skip-checks: true
10.1.1 (#1614 )
2022-07-21 05:37:00 +00:00 · 2022-07-21 08:33:15 +03:00 · 2022-07-20 08:51:57 +00:00 · 2022-07-20 11:47:55 +03:00 · 2022-07-20 08:27:48 +00:00 · 2022-07-20 11:23:26 +03:00
170 changed files with 2757 additions and 2129 deletions
@@ -1,30 +0,0 @@
-8
-2.6.2
-2.12.2
-5.2.2
-5.2.3
-5.4.2
-5.4.3
-5.4.4
-5.5.2
-5.6.2
-5.6.3
-5.9.2
-6.0.2
-6.0.3
-6.0.4
-6.0.5
-
-7.0.2
-7.0.3
-7.1.2
-7.8.2
-7.9.2
-8.0.2
-8.0.3
-8.0.4
-8.0.5
-8.1.2
-8.2.2
-8.3.2
-8.3.3
@@ -1,50 +1,86 @@
 <!--

-For general support, howto, coding and bundling questions, please use the Substrate & Polkadot StackExchange at https://substrate.stackexchange.com/ and get other ecosystem developers involved. This issues in this repository are meant for the tracking of feature requests and bug reports.
+For general support, howto, coding and bundling questions, please
+use the Substrate & Polkadot StackExchange at

-While all issues are looked at non-bug and non-features would take quite a bit longer to get to and may yield less than satisfactory responses in this format.
+  https://substrate.stackexchange.com/

-Additionally, please ensure you have done a search on the existing and closed issues before logging a new request. This saves time on all sides.
+and get other ecosystem developers involved. This issues in this
+repository are meant for the tracking of feature requests and bug
+reports.
+
+While all issues are looked at non-bug and non-features would take
+quite a bit longer to get to and may yield less than satisfactory
+responses in this format.
+
+Additionally, please ensure you have done a search on the existing
+and closed issues before logging a new request. This saves time on
+all sides.

 -->


 * **I'm submitting a ...**

-<!--- Try and classify your actual report -->
+<!---
+
+REQUIRED:
+
+Classify the type of report your are submitting
+
+-->

  - [ ] Bug report
  - [ ] Feature request
-  - [ ] Support request (please bear the comments above in mind)
+  - [ ] Support request
  - [ ] Other


 * **What is the current behavior and expected behavior?**

-<!--- If you're describing a bug, tell us what should happen -->
-<!--- If you're suggesting a change/improvement, tell us how it should work -->
+<!---
+
+REQUIRED:
+
+If you're describing a bug, tell us what should happen. If you're
+suggesting a change/improvement, tell us how it should work.
+
+-->


 * **What is the motivation for changing the behavior?**

-<!--- Not obligatory, but suggest a motivation for the request -->
-<!--- or ideas how to implement the addition or change -->
+<!---
+
+OPTIONAL:
+
+Suggest a motivation for the request or ideas how to implement the
+addition or change
+
+-->


 * **Please tell us about your environment:**

-<!--- Include as many relevant details about the environment you experienced the issue in -->
-<!--- Also snsure that you have tested against the latest stable releases if a bug -->
+<!---
+
+REQUIRED:
+
+Include as many relevant details about the environment in which you
+experienced the issue. Also ensure that you have tested against the
+latest stable releases if you believe this to be a bug
+
+-->

  - Version:
  - Environment:

    - [ ] Node.js
    - [ ] Browser
-    - [ ] Other (limited support for other environments available)
+    - [ ] Other (limited support for other environments)

  - Language:

    - [ ] JavaScript
-    - [ ] TypeScript
+    - [ ] TypeScript (include tsc --version)
    - [ ] Other
@@ -5,7 +5,7 @@ jobs:
  pr:
    strategy:
      matrix:
-        step: ['lint', 'test', 'build']
+        step: ['lint', 'test', 'build', 'deno']
    name: ${{ matrix.step }}
    runs-on: ubuntu-latest
    env:
@@ -13,7 +13,11 @@ jobs:
      CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
    steps:
    - uses: actions/checkout@v2
+    - uses: denoland/setup-deno@v1
+      with:
+        deno-version: vx.x.x
    - name: ${{ matrix.step }}
+      if: always()
      run: |
        yarn install --immutable | grep -v 'YN0013'
        yarn ${{ matrix.step }}
@@ -1,13 +1,12 @@
 --test-*
 _book/
 build/
-build-cjs/
-build-esm/
-build-docs/
+build-*/
 coverage/
-docs/.vuepress/dist/
 node_modules/
 tmp/
+/import_map.json
+/mod.ts
 .DS_Store
 .env.local
 .env.development.local
@@ -26,6 +25,4 @@ npm-debug.log*
 package-lock.json
 yarn-debug.log*
 yarn-error.log*
-store.db
-store.db.compacted
 tsconfig.*buildinfo
@@ -1,5 +1,77 @@
 # CHANGELOG

+## 10.1.1 Jul 21, 2022
+
+Changes:
+
+- Add `arrayUnzip` as reverse of `arrayZip`
+- Adjust `objectSpread` to natively handle `Map` entries spreads
+- Adjust `isAscii` check to disallow `\t`, `\n`, & `\r` characters
+- Adjust `nobody` zero-key pair with pre-computed address
+- Align `objectProperty` & `lazyMethod` call signatures (backwards compatible)
+- Various internal speed optimizations
+- Upgrade dependencies to latest stable versions
+
+
+## 10.0.2 Jul 10, 2022
+
+Changes:
+
+- Adjust async import in `x-fetch` to be Jest-friendly
+
+
+## 10.0.1 Jul 8, 2022
+
+- **Breaking change** In this major version version previously deprecated function signatures have been removed. If still using the old forms for either `bnToHex`, `bnToU8a`, `formatBalance`, `hexToBn` or `u8aToBn`, please update and only pass through an options object as the second parameter.
+
+Contributed:
+
+- Ledger support for Stafi (Thanks to https://github.com/kaelnew)
+- Ledger support for Aleph Zero (Thanks to https://github.com/carlosala)
+- Add genesis for HydraDX parachain (Thanks to https://github.com/jak-pan)
+
+Changes:
+
+- Remove deprecated signatures for `bnToHex`, `bnToU8a`, `formatBalance`, `hexToBn`, `u8aToBn`
+- Align option handling of `n*` (BigInt) functions with `bn*` (BN)
+- Allow for usage without `@types/node` installed
+- Adjust for available ESM-only dependencies
+- Upgrade dependencies to latest stable versions
+- Upgrade to `@polkadot/wasm-crypto` 6.2.3
+
+
+## 9.7.2 Jul 4, 2022
+
+Changes:
+
+- Upgrade to `@polkadot/wasm-crypto` 6.2.2
+
+
+## 9.7.1 Jul 1, 2022
+
+Changes:
+
+- Update signatures where `readonly` arrays are used
+- Upgrade dependencies to latest stable versions
+- Upgrade to `@polkadot/wasm-crypto` 6.2.1
+
+
+## 9.6.2 Jun 25, 2022
+
+Changes:
+
+- Fix `hexToU8a` where `0x` is not correctly converted
+
+
+## 9.6.1 Jun 23, 2022
+
+Changes:
+
+- Add `floatToU8a` and `u8aToFloat` (both 32 & 64-bit, le & be)
+- Adjust `isUndefined` check (local variable available)
+- Adjust use of `assert`, `isUndefined` & `isNull`
+
+
 ## 9.5.1 Jun 18, 2022

 Contributed:
@@ -1,10 +1,10 @@
-    1363	Jaco                          	9.5.1 (#1545)
+    1432	Jaco                          	10.1.1 (#1614)
       9	Antoine Estienne              	Add eth uri keyring test (#1291)
       6	Amaury Martiny                	Add tests from Rust (#283)
+       6	Carlo Sala                    	feat(ledger): add interlay and unique (#1609)
+       5	Jakub Pánik                   	Add HydraDX parachain to genesis (#1583)
       5	kwingram25                    	Add BN consts and timeToString (#610)
       4	Adam Dossa                    	Update Polymesh Genesis Hash (#1193)
-       4	Carlo Sala                    	add Composable support for ledger (#1515)
-       4	Jakub Pánik                   	Add basilisk 🐍 (#1396)
       3	Luke Schoen                   	docs: Fix example in readme since we use default imports (#243)
       3	pan                           	update bifrost genesis hash (#1521)
       2	AndreasGassmann               	feat(dependencies): remove moment.js (#530)
@@ -30,6 +30,7 @@
       1	Jake Naviasky                 	Add evmToAddress and addressToEvm crypto utils. (#705)
       1	JesseAbram                    	added check if valid address to docs (#440)
       1	joe petrowski                 	Add example for multisig address creation (#590)
+       1	kaelnew                       	add ledger support for stafi (#1569)
       1	Lezek123                      	logger - wildcard include/exclude with DEBUG env (#932)
       1	Mario Neises                  	remove redudant export (#257)
       1	Miguel Hervas                 	Add CFG Ledger Support (#1057)
@@ -10,7 +10,12 @@
    "url": "https://github.com/polkadot-js/common.git"
  },
  "sideEffects": false,
-  "version": "9.5.1",
+  "type": "module",
+  "version": "10.1.1",
+  "versions": {
+    "git": "10.1.1",
+    "npm": "10.1.1"
+  },
  "workspaces": [
    "packages/*"
  ],
@@ -19,19 +24,19 @@
    "build:release": "polkadot-ci-ghact-build",
    "build:rollup": "polkadot-exec-rollup --config",
    "clean": "polkadot-dev-clean-build",
+    "deno": "yarn polkadot-dev-deno-map && yarn build && deno check --import-map=import_map.json mod.ts",
    "lint": "polkadot-dev-run-lint",
-    "networks:crosscheck": "polkadot-dev-run-test packages/networks/src/crosscheck",
    "postinstall": "polkadot-dev-yarn-only",
-    "test": "polkadot-dev-run-test --coverage --runInBand --testPathIgnorePatterns crosscheck --testPathIgnorePatterns toMiniSecretCmp",
+    "test": "NODE_OPTIONS=--experimental-vm-modules 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.18.5",
-    "@polkadot/dev": "^0.67.4",
-    "@types/jest": "^28.1.2"
+    "@babel/core": "^7.18.9",
+    "@polkadot/dev": "^0.67.84",
+    "@types/jest": "^28.1.6"
  },
  "resolutions": {
-    "typescript": "^4.7.3"
+    "typescript": "^4.7.4"
  }
 }
@@ -16,18 +16,18 @@
  },
  "sideEffects": false,
  "type": "module",
-  "version": "9.5.1",
+  "version": "10.1.1",
  "browser": "browser.js",
  "main": "node.js",
  "react-native": "react-native.js",
  "dependencies": {
-    "@babel/runtime": "^7.18.3",
+    "@babel/runtime": "^7.18.9",
    "@ledgerhq/hw-transport": "^6.27.1",
    "@ledgerhq/hw-transport-webhid": "^6.27.1",
    "@ledgerhq/hw-transport-webusb": "^6.27.1",
-    "@polkadot/util": "9.5.1"
+    "@polkadot/util": "10.1.1"
  },
  "optionalDependencies": {
-    "@ledgerhq/hw-transport-node-hid-singleton": "^6.27.1"
+    "@ledgerhq/hw-transport-node-hid-singleton": "^6.27.2"
  }
 }
@@ -0,0 +1,8 @@
+// Copyright 2017-2022 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { TransportDef } from './types';
+
+export { packageInfo } from './packageInfo';
+
+export const transports: TransportDef[] = [];
@@ -0,0 +1,4 @@
+// Copyright 2017-2022 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './empty';
@@ -3,4 +3,4 @@

 // Do not edit, auto-generated by @polkadot/dev

-export const packageInfo = { name: '@polkadot/hw-ledger-transports', path: 'auto', type: 'auto', version: '9.5.1' };
+export const packageInfo = { name: '@polkadot/hw-ledger-transports', path: 'auto', type: 'auto', version: '10.1.1' };
@@ -1,8 +1,4 @@
 // Copyright 2017-2022 @polkadot/hw-ledger authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import type { TransportDef } from './types';
-
-export { packageInfo } from './packageInfo';
-
-export const transports: TransportDef[] = [];
+export * from './empty';
@@ -19,13 +19,13 @@
    "./detectPackage.cjs"
  ],
  "type": "module",
-  "version": "9.5.1",
+  "version": "10.1.1",
  "main": "index.js",
  "dependencies": {
-    "@babel/runtime": "^7.18.3",
+    "@babel/runtime": "^7.18.9",
    "@ledgerhq/hw-transport": "^6.27.1",
-    "@polkadot/hw-ledger-transports": "9.5.1",
-    "@polkadot/util": "9.5.1",
-    "@zondax/ledger-substrate": "^0.31.0"
+    "@polkadot/hw-ledger-transports": "10.1.1",
+    "@polkadot/util": "10.1.1",
+    "@zondax/ledger-substrate": "^0.33.0"
  }
 }
@@ -5,7 +5,7 @@ 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 { u8aToBuffer } from '@polkadot/util';

 import { LEDGER_DEFAULT_ACCOUNT, LEDGER_DEFAULT_CHANGE, LEDGER_DEFAULT_INDEX, LEDGER_SUCCESS_CODE } from './constants';
 import { ledgerApps } from './defaults';
@@ -26,8 +26,11 @@ export class Ledger {

  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}`);
+    if (!['hid', 'webusb'].includes(transport)) {
+      throw new Error(`Unsupported transport ${transport}`);
+    } else if (!Object.keys(ledgerApps).includes(chain)) {
+      throw new Error(`Unsupported chain ${chain}`);
+    }

    this.#chain = chain;
    this.#transport = transport;
@@ -71,7 +74,9 @@ export class Ledger {
    if (!this.#app) {
      const def = transports.find(({ type }) => type === this.#transport);

-      assert(def, () => `Unable to find a transport for ${this.#transport}`);
+      if (!def) {
+        throw new Error(`Unable to find a transport for ${this.#transport}`);
+      }

      const transport = await def.create();

@@ -96,7 +101,9 @@ export class Ledger {
  #wrapError = async <T extends ResponseBase> (promise: Promise<T>): Promise<T> => {
    const result = await promise;

-    assert(result.return_code === LEDGER_SUCCESS_CODE, () => result.error_message);
+    if (result.return_code !== LEDGER_SUCCESS_CODE) {
+      throw new Error(result.error_message);
+    }

    return result;
  };
@@ -4,11 +4,12 @@
 import type Transport from '@ledgerhq/hw-transport';
 import type { SubstrateApp } from '@zondax/ledger-substrate';

-import { newAcalaApp, newAstarApp, newBifrostApp, newCentrifugeApp, newComposableApp, newDockApp, newEdgewareApp, newEquilibriumApp, newGenshiroApp, newKaruraApp, newKusamaApp, newNodleApp, newParallelApp, newPolkadexApp, newPolkadotApp, newPolymeshApp, newSoraApp, newStatemineApp, newStatemintApp, newXXNetworkApp } from '@zondax/ledger-substrate';
+import { newAcalaApp, newAlephZeroApp, newAstarApp, newBifrostApp, newCentrifugeApp, newComposableApp, newDockApp, newEdgewareApp, newEquilibriumApp, newGenshiroApp, newInterlayApp, newKaruraApp, newKusamaApp, newNodleApp, newParallelApp, newPolkadexApp, newPolkadotApp, newPolymeshApp, newSoraApp, newStafiApp, newStatemineApp, newStatemintApp, newUniqueApp, newXXNetworkApp } from '@zondax/ledger-substrate';

 // These match up with the keys of the knownLedger object in the @polkadot/networks/defaults/ledger.ts
 export const ledgerApps: Record<string, (transport: Transport) => SubstrateApp> = {
  acala: newAcalaApp,
+  'aleph-node': newAlephZeroApp,
  astar: newAstarApp,
  bifrost: newBifrostApp,
  centrifuge: newCentrifugeApp,
@@ -17,6 +18,7 @@ export const ledgerApps: Record<string, (transport: Transport) => SubstrateApp>
  edgeware: newEdgewareApp,
  equilibrium: newEquilibriumApp,
  genshiro: newGenshiroApp,
+  'interlay-parachain': newInterlayApp,
  karura: newKaruraApp,
  kusama: newKusamaApp,
  'nodle-para': newNodleApp,
@@ -25,7 +27,9 @@ export const ledgerApps: Record<string, (transport: Transport) => SubstrateApp>
  polkadot: newPolkadotApp,
  polymesh: newPolymeshApp,
  sora: newSoraApp,
+  stafi: newStafiApp,
  statemine: newStatemineApp,
  statemint: newStatemintApp,
+  unique: newUniqueApp,
  xxnetwork: newXXNetworkApp
 };
@@ -0,0 +1,4 @@
+// Copyright 2017-2022 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index';
@@ -3,4 +3,4 @@

 // Do not edit, auto-generated by @polkadot/dev

-export const packageInfo = { name: '@polkadot/hw-ledger', path: 'auto', type: 'auto', version: '9.5.1' };
+export const packageInfo = { name: '@polkadot/hw-ledger', path: 'auto', type: 'auto', version: '10.1.1' };
@@ -20,15 +20,15 @@
    "./detectPackage.cjs"
  ],
  "type": "module",
-  "version": "9.5.1",
+  "version": "10.1.1",
  "main": "index.js",
  "dependencies": {
-    "@babel/runtime": "^7.18.3",
-    "@polkadot/util": "9.5.1",
-    "@polkadot/util-crypto": "9.5.1"
+    "@babel/runtime": "^7.18.9",
+    "@polkadot/util": "10.1.1",
+    "@polkadot/util-crypto": "10.1.1"
  },
  "peerDependencies": {
-    "@polkadot/util": "9.5.1",
-    "@polkadot/util-crypto": "9.5.1"
+    "@polkadot/util": "10.1.1",
+    "@polkadot/util-crypto": "10.1.1"
  }
 }
@@ -4,7 +4,7 @@
 import type { EncryptedJsonEncoding, Keypair, KeypairType } from '@polkadot/util-crypto/types';
 import type { KeyringInstance, KeyringOptions, KeyringPair, KeyringPair$Json, KeyringPair$Meta } from './types';

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

 import { DEV_PHRASE } from './defaults';
@@ -50,7 +50,9 @@ export class Keyring implements KeyringInstance {
  constructor (options: KeyringOptions = {}) {
    options.type = options.type || 'ed25519';

-    assert(['ecdsa', 'ethereum', 'ed25519', 'sr25519'].includes(options.type || 'undefined'), () => `Expected a keyring type of either 'ed25519', 'sr25519', 'ethereum' or 'ecdsa', found '${options.type || 'unknown'}`);
+    if (!['ecdsa', 'ethereum', 'ed25519', 'sr25519'].includes(options.type || 'undefined')) {
+      throw new Error(`Expected a keyring type of either 'ed25519', 'sr25519', 'ethereum' or 'ecdsa', found '${options.type || 'unknown'}`);
+    }

    this.#pairs = new Pairs();
    this.#ss58 = options.ss58Format;
@@ -162,7 +164,9 @@ export class Keyring implements KeyringInstance {
   * @description Creates a pair from a JSON keyfile
   */
  public createFromJson ({ address, encoded, encoding: { content, type, version }, meta }: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair {
-    assert(version !== '3' || content[0] === 'pkcs8', () => `Unable to decode non-pkcs8 type, [${content.join(',')}] found}`);
+    if (version === '3' && content[0] !== 'pkcs8') {
+      throw new Error(`Unable to decode non-pkcs8 type, [${content.join(',')}] found}`);
+    }

    const cryptoType = version === '0' || !Array.isArray(content)
      ? this.type
@@ -171,7 +175,9 @@ export class Keyring implements KeyringInstance {
      ? [type]
      : type;

-    assert(['ed25519', 'sr25519', 'ecdsa', 'ethereum'].includes(cryptoType), () => `Unknown crypto type ${cryptoType}`);
+    if (!['ed25519', 'sr25519', 'ecdsa', 'ethereum'].includes(cryptoType)) {
+      throw new Error(`Unknown crypto type ${cryptoType}`);
+    }

    // 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)
@@ -216,7 +222,9 @@ export class Keyring implements KeyringInstance {
          ? mnemonicToLegacySeed(phrase, '', false, 64)
          : mnemonicToMiniSecret(phrase, password);
      } else {
-        assert(phrase.length <= 32, 'specified phrase is not a valid mnemonic and is invalid as a raw seed at > 32 bytes');
+        if (phrase.length > 32) {
+          throw new Error('specified phrase is not a valid mnemonic and is invalid as a raw seed at > 32 bytes');
+        }

        seed = stringToU8a(phrase.padEnd(32));
      }
@@ -238,7 +246,7 @@ export class Keyring implements KeyringInstance {
  public encodeAddress = (address: Uint8Array | string, ss58Format?: number): string => {
    return this.type === 'ethereum'
      ? ethereumEncode(address)
-      : encodeAddress(address, isUndefined(ss58Format) ? this.#ss58 : ss58Format);
+      : encodeAddress(address, ss58Format === undefined ? this.#ss58 : ss58Format);
  };

  /**
@@ -0,0 +1,4 @@
+// Copyright 2017-2022 @polkadot/keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index';
@@ -3,4 +3,4 @@

 // Do not edit, auto-generated by @polkadot/dev

-export const packageInfo = { name: '@polkadot/keyring', path: 'auto', type: 'auto', version: '9.5.1' };
+export const packageInfo = { name: '@polkadot/keyring', path: 'auto', type: 'auto', version: '10.1.1' };
@@ -4,7 +4,7 @@
 import type { EncryptedJsonEncoding } from '@polkadot/util-crypto/types';
 import type { PairInfo } from './types';

-import { assert, isUndefined, u8aEq } from '@polkadot/util';
+import { u8aEq } from '@polkadot/util';
 import { jsonDecryptData } from '@polkadot/util-crypto';

 import { PKCS8_DIVIDER, PKCS8_HEADER, PUB_LENGTH, SEC_LENGTH, SEED_LENGTH } from './defaults';
@@ -16,13 +16,15 @@ type DecodeResult = PairInfo & {
 };

 export function decodePair (passphrase?: string, encrypted?: Uint8Array | null, _encType?: EncryptedJsonEncoding | EncryptedJsonEncoding[]): DecodeResult {
-  const encType = Array.isArray(_encType) || isUndefined(_encType)
+  const encType = Array.isArray(_encType) || _encType === undefined
    ? _encType
    : [_encType];
  const decrypted = jsonDecryptData(encrypted, passphrase, encType);
  const header = decrypted.subarray(0, PKCS8_HEADER.length);

-  assert(u8aEq(header, PKCS8_HEADER), 'Invalid Pkcs8 header found in body');
+  if (!u8aEq(header, PKCS8_HEADER)) {
+    throw new Error('Invalid Pkcs8 header found in body');
+  }

  let secretKey = decrypted.subarray(SEED_OFFSET, SEED_OFFSET + SEC_LENGTH);
  let divOffset = SEED_OFFSET + SEC_LENGTH;
@@ -34,7 +36,9 @@ export function decodePair (passphrase?: string, encrypted?: Uint8Array | null,
    secretKey = decrypted.subarray(SEED_OFFSET, divOffset);
    divider = decrypted.subarray(divOffset, divOffset + PKCS8_DIVIDER.length);

-    assert(u8aEq(divider, PKCS8_DIVIDER), 'Invalid Pkcs8 divider found in body');
+    if (!u8aEq(divider, PKCS8_DIVIDER)) {
+      throw new Error('Invalid Pkcs8 divider found in body');
+    }
  }

  const pubOffset = divOffset + PKCS8_DIVIDER.length;
@@ -3,13 +3,15 @@

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

-import { assert, u8aConcat } from '@polkadot/util';
+import { u8aConcat } from '@polkadot/util';
 import { naclEncrypt, scryptEncode, scryptToU8a } from '@polkadot/util-crypto';

 import { PKCS8_DIVIDER, PKCS8_HEADER } from './defaults';

 export function encodePair ({ publicKey, secretKey }: PairInfo, passphrase?: string): Uint8Array {
-  assert(secretKey, 'Expected a valid secretKey to be passed to encode');
+  if (!secretKey) {
+    throw new Error('Expected a valid secretKey to be passed to encode');
+  }

  const encoded = u8aConcat(
    PKCS8_HEADER,
@@ -217,11 +217,11 @@ describe('pair', (): void => {
  });

  it('allows derivation on the pair', (): void => {
-    const alice = createPair({ toSS58, type: 'sr25519' }, { publicKey: PAIRSSR25519[0].publicKey, secretKey: PAIRSSR25519[0].secretKey }, {});
+    const alice = createPair({ toSS58, type: 'sr25519' }, { publicKey: hexToU8a(PAIRSSR25519[0].p), secretKey: hexToU8a(PAIRSSR25519[0].s) }, {});
    const stash = alice.derive('//stash');
    const soft = alice.derive('//funding/0');

-    expect(stash.publicKey).toEqual(PAIRSSR25519[1].publicKey);
+    expect(stash.publicKey).toEqual(hexToU8a(PAIRSSR25519[1].p));
    expect(soft.address).toEqual('5ECQNn7UueWHPFda5qUi4fTmTtyCnPvGnuoyVVSj5CboJh9J');
  });

@@ -6,7 +6,7 @@ import type { EncryptedJsonEncoding, Keypair, KeypairType } from '@polkadot/util
 import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta, SignOptions } from '../types';
 import type { PairInfo } from './types';

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

 import { decodePair } from './decode';
@@ -145,8 +145,11 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
    // eslint-disable-next-line sort-keys
    decodePkcs8,
    decryptMessage: (encryptedMessageWithNonce: HexString | string | Uint8Array, senderPublicKey: HexString | string | Uint8Array): Uint8Array | null => {
-      assert(!isLocked(secretKey), 'Cannot encrypt with a locked key pair');
-      assert(!['ecdsa', 'ethereum'].includes(type), 'Secp256k1 not supported yet');
+      if (isLocked(secretKey)) {
+        throw new Error('Cannot encrypt with a locked key pair');
+      } else if (['ecdsa', 'ethereum'].includes(type)) {
+        throw new Error('Secp256k1 not supported yet');
+      }

      const messageU8a = u8aToU8a(encryptedMessageWithNonce);

@@ -158,8 +161,11 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
      );
    },
    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');
+      if (type === 'ethereum') {
+        throw new Error('Unable to derive on this keypair');
+      } else if (isLocked(secretKey)) {
+        throw new Error('Cannot derive on a locked keypair');
+      }

      const { path } = keyExtractPath(suri);
      const derived = keyFromPath({ publicKey, secretKey }, path, type);
@@ -170,8 +176,11 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
      return recode(passphrase);
    },
    encryptMessage: (message: HexString | string | Uint8Array, recipientPublicKey: HexString | string | Uint8Array, nonceIn?: Uint8Array): Uint8Array => {
-      assert(!isLocked(secretKey), 'Cannot encrypt with a locked key pair');
-      assert(!['ecdsa', 'ethereum'].includes(type), 'Secp256k1 not supported yet');
+      if (isLocked(secretKey)) {
+        throw new Error('Cannot encrypt with a locked key pair');
+      } else if (['ecdsa', 'ethereum'].includes(type)) {
+        throw new Error('Secp256k1 not supported yet');
+      }

      const { nonce, sealed } = naclSeal(u8aToU8a(message), convertSecretKeyToCurve25519(secretKey), convertPublicKeyToCurve25519(u8aToU8a(recipientPublicKey)), nonceIn);

@@ -184,7 +193,9 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
      meta = objectSpread({}, meta, additional);
    },
    sign: (message: HexString | string | Uint8Array, options: SignOptions = {}): Uint8Array => {
-      assert(!isLocked(secretKey), 'Cannot sign with a locked key pair');
+      if (isLocked(secretKey)) {
+        throw new Error('Cannot sign with a locked key pair');
+      }

      return u8aConcat(
        options.withType
@@ -212,7 +223,9 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
      return signatureVerify(message, signature, TYPE_ADDRESS[type](u8aToU8a(signerPublic))).isValid;
    },
    vrfSign: (message: HexString | string | Uint8Array, context?: HexString | string | Uint8Array, extra?: string | Uint8Array): Uint8Array => {
-      assert(!isLocked(secretKey), 'Cannot sign with a locked key pair');
+      if (isLocked(secretKey)) {
+        throw new Error('Cannot sign with a locked key pair');
+      }

      if (type === 'sr25519') {
        return sr25519VrfSign(message, { secretKey }, context, extra);
@@ -3,10 +3,11 @@

 import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '../types';

-import { encodeAddress } from '@polkadot/util-crypto';
-
+// empty publicKey
 const publicKey = new Uint8Array(32);
-const address = encodeAddress(publicKey);
+
+// pre-computed via encodeAddress(publicKey)
+const address = '5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM';

 const meta = {
  isTesting: true,
@@ -4,7 +4,7 @@
 import type { HexString } from '@polkadot/util/types';
 import type { KeyringPair, KeyringPairs } from './types';

-import { assert, isHex, isU8a, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { isHex, isU8a, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { decodeAddress } from '@polkadot/util-crypto';

 type KeyringPairMap = Record<string, KeyringPair>;
@@ -25,11 +25,13 @@ export class Pairs implements KeyringPairs {
  public get (address: HexString | string | Uint8Array): KeyringPair {
    const pair = this.#map[decodeAddress(address).toString()];

-    assert(pair, () => `Unable to retrieve keypair '${
-      isU8a(address) || isHex(address)
-        ? u8aToHex(u8aToU8a(address))
-        : address
-    }'`);
+    if (!pair) {
+      throw new Error(`Unable to retrieve keypair '${
+        isU8a(address) || isHex(address)
+          ? u8aToHex(u8aToU8a(address))
+          : address
+      }'`);
+    }

    return pair;
  }
@@ -1,19 +1,20 @@
 // Copyright 2017-2022 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0

+import type { HexString } from '@polkadot/util/types';
+import type { KeypairType } from '@polkadot/util-crypto/types';
 import type { KeyringInstance, KeyringOptions } from './types';

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

 import { Keyring } from './keyring';
 import { createPair } from './pair';

 interface PairDef {
  name?: string;
-  publicKey: Uint8Array;
+  p: HexString;
+  s: HexString;
  seed?: string;
-  secretKey?: Uint8Array;
  type: KeypairType
 }

@@ -23,50 +24,50 @@ interface PairDef {
 // adding the keys when only the keyring is used.
 export const PAIRSSR25519: PairDef[] = [
  {
-    publicKey: hexToU8a('0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d'),
-    secretKey: hexToU8a('0x98319d4ff8a9508c4bb0cf0b5a78d760a0b2082c02775e6e82370816fedfff48925a225d97aa00682d6a59b95b18780c10d7032336e88f3442b42361f4a66011'), // nosemgrep
+    p: '0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d',
+    s: '0x98319d4ff8a9508c4bb0cf0b5a78d760a0b2082c02775e6e82370816fedfff48925a225d97aa00682d6a59b95b18780c10d7032336e88f3442b42361f4a66011', // nosemgrep
    seed: 'Alice',
    type: 'sr25519'
  },
  {
-    publicKey: hexToU8a('0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f'),
-    secretKey: hexToU8a('0xe8da6c9d810e020f5e3c7f5af2dea314cbeaa0d72bc6421e92c0808a0c584a6046ab28e97c3ffc77fe12b5a4d37e8cd4afbfebbf2391ffc7cb07c0f38c023efd'), // nosemgrep
+    p: '0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f',
+    s: '0xe8da6c9d810e020f5e3c7f5af2dea314cbeaa0d72bc6421e92c0808a0c584a6046ab28e97c3ffc77fe12b5a4d37e8cd4afbfebbf2391ffc7cb07c0f38c023efd', // nosemgrep
    seed: 'Alice//stash',
    type: 'sr25519'
  },
  {
-    publicKey: hexToU8a('0x8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48'),
-    secretKey: hexToU8a('0x081ff694633e255136bdb456c20a5fc8fed21f8b964c11bb17ff534ce80ebd5941ae88f85d0c1bfc37be41c904e1dfc01de8c8067b0d6d5df25dd1ac0894a325'), // nosemgrep
+    p: '0x8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48',
+    s: '0x081ff694633e255136bdb456c20a5fc8fed21f8b964c11bb17ff534ce80ebd5941ae88f85d0c1bfc37be41c904e1dfc01de8c8067b0d6d5df25dd1ac0894a325', // nosemgrep
    seed: 'Bob',
    type: 'sr25519'
  },
  {
-    publicKey: hexToU8a('0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e'),
-    secretKey: hexToU8a('0xc006507cdfc267a21532394c49ca9b754ca71de21e15a1cdf807c7ceab6d0b6c3ed408d9d35311540dcd54931933e67cf1ea10d46f75408f82b789d9bd212fde'), // nosemgrep
+    p: '0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e',
+    s: '0xc006507cdfc267a21532394c49ca9b754ca71de21e15a1cdf807c7ceab6d0b6c3ed408d9d35311540dcd54931933e67cf1ea10d46f75408f82b789d9bd212fde', // nosemgrep
    seed: 'Bob//stash',
    type: 'sr25519'
  },
  {
-    publicKey: hexToU8a('0x90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22'),
-    secretKey: hexToU8a('0xa8f2d83016052e5d6d77b2f6fd5d59418922a09024cda701b3c34369ec43a7668faf12ff39cd4e5d92bb773972f41a7a5279ebc2ed92264bed8f47d344f8f18c'), // nosemgrep
+    p: '0x90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22',
+    s: '0xa8f2d83016052e5d6d77b2f6fd5d59418922a09024cda701b3c34369ec43a7668faf12ff39cd4e5d92bb773972f41a7a5279ebc2ed92264bed8f47d344f8f18c', // nosemgrep
    seed: 'Charlie',
    type: 'sr25519'
  },
  {
-    publicKey: hexToU8a('0x306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20'),
-    secretKey: hexToU8a('0x20e05482ca4677e0edbc58ae9a3a59f6ed3b1a9484ba17e64d6fe8688b2b7b5d108c4487b9323b98b11fe36cb301b084e920f7b7895536809a6d62a451b25568'), // nosemgrep
+    p: '0x306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20',
+    s: '0x20e05482ca4677e0edbc58ae9a3a59f6ed3b1a9484ba17e64d6fe8688b2b7b5d108c4487b9323b98b11fe36cb301b084e920f7b7895536809a6d62a451b25568', // nosemgrep
    seed: 'Dave',
    type: 'sr25519'
  },
  {
-    publicKey: hexToU8a('0xe659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e'),
-    secretKey: hexToU8a('0x683576abfd5dc35273e4264c23095a1bf21c14517bece57c7f0cc5c0ed4ce06a3dbf386b7828f348abe15d76973a72009e6ef86a5c91db2990cb36bb657c6587'), // nosemgrep
+    p: '0xe659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e',
+    s: '0x683576abfd5dc35273e4264c23095a1bf21c14517bece57c7f0cc5c0ed4ce06a3dbf386b7828f348abe15d76973a72009e6ef86a5c91db2990cb36bb657c6587', // nosemgrep
    seed: 'Eve',
    type: 'sr25519'
  },
  {
-    publicKey: hexToU8a('0x1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c'),
-    secretKey: hexToU8a('0xb835c20f450079cf4f513900ae9faf8df06ad86c681884122c752a4b2bf74d4303e4f21bc6cc62bb4eeed5a9cce642c25e2d2ac1464093b50f6196d78e3a7426'), // nosemgrep
+    p: '0x1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c',
+    s: '0xb835c20f450079cf4f513900ae9faf8df06ad86c681884122c752a4b2bf74d4303e4f21bc6cc62bb4eeed5a9cce642c25e2d2ac1464093b50f6196d78e3a7426', // nosemgrep
    seed: 'Ferdie',
    type: 'sr25519'
  }
@@ -75,44 +76,46 @@ export const PAIRSSR25519: PairDef[] = [
 export const PAIRSETHEREUM: PairDef[] = [
  {
    name: 'Alith',
-    publicKey: hexToU8a('0x02509540919faacf9ab52146c9aa40db68172d83777250b28e4679176e49ccdd9f'),
-    secretKey: hexToU8a('0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133'), // nosemgrep
+    p: '0x02509540919faacf9ab52146c9aa40db68172d83777250b28e4679176e49ccdd9f',
+    s: '0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133', // nosemgrep
    type: 'ethereum'
  },
  {
    name: 'Baltathar',
-    publicKey: hexToU8a('0x033bc19e36ff1673910575b6727a974a9abd80c9a875d41ab3e2648dbfb9e4b518'),
-    secretKey: hexToU8a('0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b'), // nosemgrep
+    p: '0x033bc19e36ff1673910575b6727a974a9abd80c9a875d41ab3e2648dbfb9e4b518',
+    s: '0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b', // nosemgrep
    type: 'ethereum'
  },
  {
    name: 'Charleth',
-    publicKey: hexToU8a('0x0234637bdc0e89b5d46543bcbf8edff329d2702bc995e27e9af4b1ba009a3c2a5e'),
-    secretKey: hexToU8a('0x0b6e18cafb6ed99687ec547bd28139cafdd2bffe70e6b688025de6b445aa5c5b'), // nosemgrep
+    p: '0x0234637bdc0e89b5d46543bcbf8edff329d2702bc995e27e9af4b1ba009a3c2a5e',
+    s: '0x0b6e18cafb6ed99687ec547bd28139cafdd2bffe70e6b688025de6b445aa5c5b', // nosemgrep
    type: 'ethereum'
  },
  {
    name: 'Dorothy',
-    publicKey: hexToU8a('0x02a00d60b2b408c2a14c5d70cdd2c205db8985ef737a7e55ad20ea32cc9e7c417c'),
-    secretKey: hexToU8a('0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68'), // nosemgrep
+    p: '0x02a00d60b2b408c2a14c5d70cdd2c205db8985ef737a7e55ad20ea32cc9e7c417c',
+    s: '0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68', // nosemgrep
    type: 'ethereum'
  },
  {
    name: 'Ethan',
-    publicKey: hexToU8a('0x025cdc005b752651cd3f728fb9192182acb3a9c89e19072cbd5b03f3ee1f1b3ffa'),
-    secretKey: hexToU8a('0x7dce9bc8babb68fec1409be38c8e1a52650206a7ed90ff956ae8a6d15eeaaef4'), // nosemgrep
+    p: '0x025cdc005b752651cd3f728fb9192182acb3a9c89e19072cbd5b03f3ee1f1b3ffa',
+    s: '0x7dce9bc8babb68fec1409be38c8e1a52650206a7ed90ff956ae8a6d15eeaaef4', // nosemgrep
    type: 'ethereum'
  },
  {
    name: 'Faith',
-    publicKey: hexToU8a('0x037964b6c9d546da4646ada28a99e34acaa1d14e7aba861a9055f9bd200c8abf74'),
-    secretKey: hexToU8a('0xb9d2ea9a615f3165812e8d44de0d24da9bbd164b65c4f0573e1ce2c8dbd9c8df'), // nosemgrep
+    p: '0x037964b6c9d546da4646ada28a99e34acaa1d14e7aba861a9055f9bd200c8abf74',
+    s: '0xb9d2ea9a615f3165812e8d44de0d24da9bbd164b65c4f0573e1ce2c8dbd9c8df', // nosemgrep
    type: 'ethereum'
  }
 ];

 function createMeta (name?: string, seed?: string) {
-  assert(name || seed, 'Testing pair should have either a name or a seed');
+  if (!name && !seed) {
+    throw new Error('Testing pair should have either a name or a seed');
+  }

  return {
    isTesting: true,
@@ -128,16 +131,20 @@ function createMeta (name?: string, seed?: string) {
 */
 export function createTestKeyring (options: KeyringOptions = {}, isDerived = true): KeyringInstance {
  const keyring = new Keyring(options);
-  const pairs = (options.type && options.type === 'ethereum')
+  const pairs = options.type === 'ethereum'
    ? PAIRSETHEREUM
    : PAIRSSR25519;

-  for (const { name, publicKey, secretKey, seed, type } of pairs) {
+  for (const { name, p, s, seed, type } of pairs) {
    const meta = createMeta(name, seed);
    const pair = !isDerived && !name && seed
      ? keyring.addFromUri(seed, meta, options.type)
      : keyring.addPair(
-        createPair({ toSS58: keyring.encodeAddress, type }, { publicKey, secretKey }, meta)
+        createPair(
+          { toSS58: keyring.encodeAddress, type },
+          { publicKey: hexToU8a(p), secretKey: hexToU8a(s) },
+          meta
+        )
      );

    pair.lock = (): void => {
@@ -17,15 +17,14 @@
  },
  "sideEffects": false,
  "type": "module",
-  "version": "9.5.1",
+  "version": "10.1.1",
  "main": "index.js",
  "dependencies": {
-    "@babel/runtime": "^7.18.3",
-    "@polkadot/util": "9.5.1",
-    "@substrate/ss58-registry": "^1.22.0"
+    "@babel/runtime": "^7.18.9",
+    "@polkadot/util": "10.1.1",
+    "@substrate/ss58-registry": "^1.24.0"
  },
  "devDependencies": {
-    "@polkadot/hw-ledger": "9.5.1",
-    "@polkadot/x-fetch": "9.5.1"
+    "@polkadot/hw-ledger": "10.1.1"
  }
 }
@@ -1,75 +0,0 @@
-// Copyright 2017-2022 @polkadot/networks authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Ss58Registry } from './types';
-
-import fs from 'fs';
-
-import { objectKeys, stringify } from '@polkadot/util';
-import { fetch } from '@polkadot/x-fetch';
-
-import { allNetworks } from './';
-
-const REGISTRY = 'https://raw.githubusercontent.com/paritytech/ss58-registry/main/ss58-registry.json';
-const OUTPUT = './.github/ss58-check.md';
-
-function assertAndLog (check: boolean, error: string): void {
-  if (!check) {
-    process.env.CI_LOG && fs.appendFileSync(OUTPUT, `
-
-${error}
-`);
-
-    throw new Error(error);
-  }
-}
-
-describe('check latest Substrate ss58 registry', (): void => {
-  let original: Ss58Registry;
-
-  beforeAll(async (): Promise<void> => {
-    original = (await (await fetch(REGISTRY)).json()) as Ss58Registry;
-  });
-
-  it('has the same number as the original', (): void => {
-    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 }) => !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 = allNetworks
-      .filter(({ prefix }) => !original.registry.some((n) => n.prefix === prefix))
-      .map(({ displayName, prefix }) => `${displayName} (${prefix})`);
-
-    assertAndLog(!missing.length, `Extra entries found: ${stringify(missing, 2)}`);
-  });
-
-  it('has the same values as the original', (): void => {
-    const fields = objectKeys(original.schema);
-    const errors = original.registry
-      .map((n): [string, string[]] => {
-        const other = allNetworks.find(({ prefix }) => prefix === n.prefix);
-
-        return [
-          `${n.displayName} (${n.prefix})`,
-          other
-            ? fields.filter((f) =>
-              ['decimals', 'symbols'].includes(f)
-                ? stringify(n[f] || []) !== stringify(other[f] || [])
-                : stringify(n[f]) !== stringify(other[f])
-            )
-            : []
-        ];
-      })
-      .filter(([, fields]) => fields.length);
-
-    assertAndLog(!errors.length, `Mismatches found: ${stringify(errors.map(([n, m]) => `${n}:: ${m.join(', ')}`), 2)}`);
-  });
-});
@@ -11,6 +11,9 @@ export const knownGenesis: KnownGenesis = {
  acala: [
    '0xfc41b9bd8ef8fe53d58c7ea67c794c7ec9a73daf05e6d54b14ff6342c99ba64c'
  ],
+  'aleph-node': [
+    '0x70255b4d28de0fc4e1a193d7e175ad1ccef431598211c55538f1018651a0344e'
+  ],
  astar: [
    '0x9eb76c5184c4ab8679d2d5d819fdf90b9c001403e9e17da2e14b6d8aec4029c6'
  ],
@@ -41,11 +44,15 @@ export const knownGenesis: KnownGenesis = {
    '0x9b8cefc0eb5c568b527998bdd76c184e2b76ae561be76e4667072230217ea243'
  ],
  hydradx: [
+    '0xafdc188f45c71dacbaa0b62e16a91f726c7b8699a9748cdf715459de6b7f366d', // HydraDX Parachain
    '0xd2a620c27ec5cbc5621ff9a522689895074f7cca0d08e7134a7804e1a3ba86fc', // Snakenet Gen3-1
    '0x10af6e84234477d84dc572bac0789813b254aa490767ed06fb9591191d1073f9', // Snakenet Gen3
    '0x3d75507dd46301767e601265791da1d9cb47b6ebc94e87347b635e5bf58bd047', // Snakenet Gen2
    '0x0ed32bfcab4a83517fac88f2aa7cbc2f88d3ab93be9a12b6188a036bf8a943c2' // Snakenet Gen1
  ],
+  'interlay-parachain': [
+    '0xbf88efe70e9e0e916416e8bed61f2b45717f517d7f3523e33c7b001e5ffcbc72'
+  ],
  karura: [
    '0xbaf5aabe40646d11f0ee8abbdc64f4a4b7674925cba08e4a05ff9ebed6e2126b'
  ],
@@ -104,6 +111,9 @@ export const knownGenesis: KnownGenesis = {
  subsocial: [
    '0x0bd72c1c305172e1275278aaeb3f161e02eccb7a819e63f62d47bd53a28189f8'
  ],
+  unique: [
+    '0x84322d9cddbf35088f1e54e9a85c967a41a56a4f43445768125e61af166c7d31'
+  ],
  westend: [
    '0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e'
  ],
@@ -9,6 +9,7 @@ import type { KnownLedger } from '../types';
 // NOTE: Any network here needs to have a genesisHash attached in the ./genesis.ts config
 export const knownLedger: KnownLedger = {
  acala: 0x00000313,
+  'aleph-node': 0x00000283,
  astar: 0x0000032a,
  bifrost: 0x00000314,
  centrifuge: 0x000002eb,
@@ -17,6 +18,7 @@ export const knownLedger: KnownLedger = {
  edgeware: 0x0000020b,
  equilibrium: 0x05f5e0fd,
  genshiro: 0x05f5e0fc,
+  'interlay-parachain': 0x00000162,
  karura: 0x000002ae,
  kusama: 0x000001b2,
  'nodle-para': 0x000003eb,
@@ -25,7 +27,9 @@ export const knownLedger: KnownLedger = {
  polkadot: 0x00000162,
  polymesh: 0x00000253,
  sora: 0x00000269,
+  stafi: 0x0000038b,
  statemine: 0x000001b2, // common-good on Kusama, shares derivation
  statemint: 0x00000162, // common-good on Polkadot, shares derivation
+  unique: 0x00000162,
  xxnetwork: 0x000007a3
 };
@@ -0,0 +1,4 @@
+// Copyright 2017-2022 @polkadot/networks authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index';
@@ -3,4 +3,4 @@

 // Do not edit, auto-generated by @polkadot/dev

-export const packageInfo = { name: '@polkadot/networks', path: 'auto', type: 'auto', version: '9.5.1' };
+export const packageInfo = { name: '@polkadot/networks', path: 'auto', type: 'auto', version: '10.1.1' };
@@ -438,7 +438,7 @@
      "NODL"
    ],
    "decimals": [
-      18
+      11
    ],
    "standardAccount": "*25519",
    "website": "https://nodle.io/"
@@ -659,6 +659,32 @@
    "standardAccount": "*25519",
    "website": "https://xx.network"
  },
+  {
+    "prefix": 56,
+    "network": "pendulum",
+    "displayName": "Pendulum chain",
+    "symbols": [
+      "PEN"
+    ],
+    "decimals": [
+      12
+    ],
+    "standardAccount": "*25519",
+    "website": "https://pendulumchain.org/"
+  },
+  {
+    "prefix": 57,
+    "network": "amplitude",
+    "displayName": "Amplitude chain",
+    "symbols": [
+      "AMPE"
+    ],
+    "decimals": [
+      12
+    ],
+    "standardAccount": "*25519",
+    "website": "https://pendulumchain.org/"
+  },
  {
    "prefix": 63,
    "network": "hydradx",
@@ -906,6 +932,19 @@
    "standardAccount": "*25519",
    "website": "https://invarch.network"
  },
+  {
+    "prefix": 126,
+    "network": "joystream",
+    "displayName": "Joystream",
+    "symbols": [
+      "JOY"
+    ],
+    "decimals": [
+      10
+    ],
+    "standardAccount": "*25519",
+    "website": "https://www.joystream.org"
+  },
  {
    "prefix": 128,
    "network": "clover",
@@ -1036,6 +1075,32 @@
    "standardAccount": "Sr25519",
    "website": "https://efinity.io/"
  },
+  {
+    "prefix": 1221,
+    "network": "peaq",
+    "displayName": "Peaq Network",
+    "symbols": [
+      "PEAQ"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "Sr25519",
+    "website": "https://www.peaq.network/"
+  },
+  {
+    "prefix": 1222,
+    "network": "apex",
+    "displayName": "Apex Network",
+    "symbols": [
+      "APEX"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "Sr25519",
+    "website": "https://www.peaq.network/"
+  },
  {
    "prefix": 1284,
    "network": "moonbeam",
@@ -1158,7 +1223,7 @@
    "network": "tidefi",
    "displayName": "Tidefi",
    "symbols": [
-      "TIFI"
+      "TDFY"
    ],
    "decimals": [
      12
@@ -1244,6 +1309,21 @@
    "standardAccount": "*25519",
    "website": "https://ata.network"
  },
+  {
+    "prefix": 15253,
+    "network": "ice-network",
+    "displayName": "ICE Network",
+    "symbols": [
+      "ICX",
+      "ICY"
+    ],
+    "decimals": [
+      18,
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://icenetwork.io"
+  },
  {
    "prefix": 12191,
    "network": "nftmart",
@@ -12,7 +12,6 @@
  ],
  "references": [
    { "path": "../hw-ledger/tsconfig.build.json" },
-    { "path": "../util/tsconfig.build.json" },
-    { "path": "../x-fetch/tsconfig.build.json" }
+    { "path": "../util/tsconfig.build.json" }
  ]
 }
@@ -22,21 +22,21 @@
    "./detectPackage.cjs"
  ],
  "type": "module",
-  "version": "9.5.1",
+  "version": "10.1.1",
  "browser": {
    "crypto": false,
    "stream": false
  },
  "main": "index.js",
  "dependencies": {
-    "@babel/runtime": "^7.18.3",
-    "@noble/hashes": "1.1.1",
-    "@noble/secp256k1": "1.6.0",
-    "@polkadot/networks": "9.5.1",
-    "@polkadot/util": "9.5.1",
-    "@polkadot/wasm-crypto": "^6.1.1",
-    "@polkadot/x-bigint": "9.5.1",
-    "@polkadot/x-randomvalues": "9.5.1",
+    "@babel/runtime": "^7.18.9",
+    "@noble/hashes": "1.1.2",
+    "@noble/secp256k1": "1.6.3",
+    "@polkadot/networks": "10.1.1",
+    "@polkadot/util": "10.1.1",
+    "@polkadot/wasm-crypto": "^6.3.1",
+    "@polkadot/x-bigint": "10.1.1",
+    "@polkadot/x-randomvalues": "10.1.1",
    "@scure/base": "1.1.1",
    "ed2curve": "^0.3.0",
    "tweetnacl": "^1.0.3"
@@ -45,6 +45,6 @@
    "@types/ed2curve": "^0.2.2"
  },
  "peerDependencies": {
-    "@polkadot/util": "9.5.1"
+    "@polkadot/util": "10.1.1"
  }
 }
@@ -1,6 +1,8 @@
 // Copyright 2017-2022 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0

+export {};
+
 describe('cryptoWaitReady', (): void => {
  it('should return false when it cannot initialize', async (): Promise<void> => {
    const old = global.WebAssembly;
@@ -1,8 +1,6 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import { assert, isNull } from '@polkadot/util';
-
 import { DeriveJunction } from './DeriveJunction';
 import { keyExtractPath } from './extractPath';

@@ -22,7 +20,9 @@ export function keyExtractSuri (suri: string): ExtractResult {
  // eslint-disable-next-line @typescript-eslint/prefer-regexp-exec
  const matches = suri.match(RE_CAPTURE);

-  assert(!isNull(matches), 'Unable to match provided value to a secret URI');
+  if (matches === null) {
+    throw new Error('Unable to match provided value to a secret URI');
+  }

  const [, phrase, , derivePath, , , password] = matches as string[];
  const { path } = keyExtractPath(derivePath);
@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

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

 import { mnemonicToSeedSync } from './bip39';
@@ -25,8 +25,11 @@ import { mnemonicValidate } from './validate';
 * ```
 */
 export function mnemonicToLegacySeed (mnemonic: string, password = '', onlyJs?: boolean, byteLength: 32 | 64 = 32): Uint8Array {
-  assert(mnemonicValidate(mnemonic), 'Invalid bip39 mnemonic specified');
-  assert([32, 64].includes(byteLength), () => `Invalid seed length ${byteLength}, expected 32 or 64`);
+  if (!mnemonicValidate(mnemonic)) {
+    throw new Error('Invalid bip39 mnemonic specified');
+  } else if (![32, 64].includes(byteLength)) {
+    throw new Error(`Invalid seed length ${byteLength}, expected 32 or 64`);
+  }

  return byteLength === 32
    ? !hasBigInt || (!onlyJs && isReady())
@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

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

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

 export function mnemonicToMiniSecret (mnemonic: string, password = '', onlyJs?: boolean): Uint8Array {
-  assert(mnemonicValidate(mnemonic), 'Invalid bip39 mnemonic specified');
+  if (!mnemonicValidate(mnemonic)) {
+    throw new Error('Invalid bip39 mnemonic specified');
+  }

  if (!onlyJs && isReady()) {
    return bip39ToMiniSecret(mnemonic, password);
@@ -0,0 +1,4 @@
+// Copyright 2017-2022 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index';
@@ -3,4 +3,4 @@

 // Do not edit, auto-generated by @polkadot/dev

-export const packageInfo = { name: '@polkadot/util-crypto', path: 'auto', type: 'auto', version: '9.5.1' };
+export const packageInfo = { name: '@polkadot/util-crypto', path: 'auto', type: 'auto', version: '10.1.1' };
@@ -3,7 +3,7 @@

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

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

 import { BN_LE_OPTS } from '../bn';
 import { DEFAULT_PARAMS } from './defaults';
@@ -23,7 +23,9 @@ export function scryptFromU8a (data: Uint8Array): Result {
  // and updates for greater security. However we need some protection against carefully-crafted params that can
  // eat up CPU since these are user inputs. So we need to get very clever here, but atm we only allow the defaults
  // and if no match, bail out
-  assert(N === DEFAULT_PARAMS.N && p === DEFAULT_PARAMS.p && r === DEFAULT_PARAMS.r, 'Invalid injected scrypt params found');
+  if (N !== DEFAULT_PARAMS.N || p !== DEFAULT_PARAMS.p || r !== DEFAULT_PARAMS.r) {
+    throw new Error('Invalid injected scrypt params found');
+  }

  return { params: { N, p, r }, salt };
 }
@@ -3,7 +3,7 @@

 import { Point } from '@noble/secp256k1';

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

 export function secp256k1Compress (publicKey: Uint8Array, onlyJs?: boolean): Uint8Array {
@@ -11,7 +11,9 @@ export function secp256k1Compress (publicKey: Uint8Array, onlyJs?: boolean): Uin
    return publicKey;
  }

-  assert(publicKey.length === 65, 'Invalid publicKey provided');
+  if (publicKey.length !== 65) {
+    throw new Error('Invalid publicKey provided');
+  }

  return !hasBigInt || (!onlyJs && isReady())
    ? wasm(publicKey)
@@ -1,14 +1,16 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0

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

 import { blake2AsU8a } from '../blake2/asU8a';

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

 export function secp256k1DeriveHard (seed: Uint8Array, chainCode: Uint8Array): Uint8Array {
-  assert(isU8a(chainCode) && chainCode.length === 32, 'Invalid chainCode passed to derive');
+  if (!isU8a(chainCode) || chainCode.length !== 32) {
+    throw new Error('Invalid chainCode passed to derive');
+  }

  // NOTE This is specific to the Substrate HDD derivation, so always use the blake2 hasher
  return blake2AsU8a(u8aConcat(HDKD, seed, chainCode), 256);
@@ -3,7 +3,7 @@

 import { Point } from '@noble/secp256k1';

-import { assert, bnToU8a, hasBigInt, u8aConcat } from '@polkadot/util';
+import { bnToU8a, hasBigInt, u8aConcat } from '@polkadot/util';
 import { isReady, secp256k1Expand as wasm } from '@polkadot/wasm-crypto';

 import { BN_BE_256_OPTS } from '../bn';
@@ -13,7 +13,9 @@ export function secp256k1Expand (publicKey: Uint8Array, onlyJs?: boolean): Uint8
    return publicKey.subarray(1);
  }

-  assert(publicKey.length === 33, 'Invalid publicKey provided');
+  if (publicKey.length !== 33) {
+    throw new Error('Invalid publicKey provided');
+  }

  if (!hasBigInt || (!onlyJs && isReady())) {
    return wasm(publicKey).subarray(1);
@@ -5,7 +5,7 @@ import type { Keypair } from '../../types';

 import { getPublicKey } from '@noble/secp256k1';

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

 /**
@@ -13,7 +13,9 @@ import { isReady, secp256k1FromSeed } from '@polkadot/wasm-crypto';
 * @description Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
 */
 export function secp256k1PairFromSeed (seed: Uint8Array, onlyJs?: boolean): Keypair {
-  assert(seed.length === 32, 'Expected valid 32-byte private key as a seed');
+  if (seed.length !== 32) {
+    throw new Error('Expected valid 32-byte private key as a seed');
+  }

  if (!hasBigInt || (!onlyJs && isReady())) {
    const full = secp256k1FromSeed(seed);
@@ -23,7 +25,9 @@ export function secp256k1PairFromSeed (seed: Uint8Array, onlyJs?: boolean): Keyp
    // it seems that the lazy static section yields invalid results on the _first_ run.
    // If this happens, fail outright, we cannot allow invalid return values
    // https://github.com/polkadot-js/wasm/issues/307
-    assert(!u8aEmpty(publicKey), 'Invalid publicKey generated from WASM interface');
+    if (u8aEmpty(publicKey)) {
+      throw new Error('Invalid publicKey generated from WASM interface');
+    }

    return {
      publicKey,
@@ -6,7 +6,7 @@ import type { HashType } from './types';

 import { recoverPublicKey, Signature } from '@noble/secp256k1';

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

 import { secp256k1Compress } from './compress';
@@ -23,7 +23,9 @@ export function secp256k1Recover (msgHash: HexString | Uint8Array | string, sign
    ? wasm(msg, sig, recovery)
    : recoverPublicKey(msg, Signature.fromCompact(sig).toRawBytes(), recovery);

-  assert(publicKey, 'Unable to recover publicKey from signature');
+  if (!publicKey) {
+    throw new Error('Unable to recover publicKey from signature');
+  }

  return hashType === 'keccak'
    ? secp256k1Expand(publicKey, onlyJs)
@@ -6,7 +6,7 @@ import type { HashType } from './types';

 import { Signature, signSync } from '@noble/secp256k1';

-import { assert, bnToU8a, hasBigInt, u8aConcat } from '@polkadot/util';
+import { bnToU8a, hasBigInt, u8aConcat } from '@polkadot/util';
 import { isReady, secp256k1Sign as wasm } from '@polkadot/wasm-crypto';

 import { BN_BE_256_OPTS } from '../bn';
@@ -17,7 +17,9 @@ import { hasher } from './hasher';
 * @description Returns message signature of `message`, using the supplied pair
 */
 export function secp256k1Sign (message: Uint8Array | string, { secretKey }: Partial<Keypair>, hashType: HashType = 'blake2', onlyJs?: boolean): Uint8Array {
-  assert(secretKey?.length === 32, 'Expected valid secp256k1 secretKey, 32-bytes');
+  if (secretKey?.length !== 32) {
+    throw new Error('Expected valid secp256k1 secretKey, 32-bytes');
+  }

  const data = hasher(hashType, message, onlyJs);

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

-import { _0n, assert, BN, bnToU8a, hasBigInt, isU8a, nToU8a, u8aToBigInt } from '@polkadot/util';
+import { _0n, BN, bnToU8a, hasBigInt, isU8a, nToU8a, u8aToBigInt } from '@polkadot/util';
 import { BigInt } from '@polkadot/x-bigint';

 import { BN_BE_256_OPTS, BN_BE_OPTS } from '../bn';
@@ -15,7 +15,9 @@ const N_BN = new BN(N, 'hex');
 function addBi (seckey: Uint8Array, tweak: Uint8Array): Uint8Array {
  let res = u8aToBigInt(tweak, BN_BE_OPTS);

-  assert(res < N_BI, 'Tweak parameter is out of range');
+  if (res >= N_BI) {
+    throw new Error('Tweak parameter is out of range');
+  }

  res += u8aToBigInt(seckey, BN_BE_OPTS);

@@ -23,7 +25,9 @@ function addBi (seckey: Uint8Array, tweak: Uint8Array): Uint8Array {
    res -= N_BI;
  }

-  assert(res !== _0n, 'Invalid resulting private key');
+  if (res === _0n) {
+    throw new Error('Invalid resulting private key');
+  }

  return nToU8a(res, BN_BE_256_OPTS);
 }
@@ -31,7 +35,9 @@ function addBi (seckey: Uint8Array, tweak: Uint8Array): Uint8Array {
 function addBn (seckey: Uint8Array, tweak: Uint8Array): Uint8Array {
  const res = new BN(tweak);

-  assert(res.cmp(N_BN) < 0, 'Tweak parameter is out of range');
+  if (res.cmp(N_BN) >= 0) {
+    throw new Error('Tweak parameter is out of range');
+  }

  res.iadd(new BN(seckey));

@@ -39,14 +45,19 @@ function addBn (seckey: Uint8Array, tweak: Uint8Array): Uint8Array {
    res.isub(N_BN);
  }

-  assert(!res.isZero(), 'Invalid resulting private key');
+  if (res.isZero()) {
+    throw new Error('Invalid resulting private key');
+  }

  return bnToU8a(res, BN_BE_256_OPTS);
 }

 export function secp256k1PrivateKeyTweakAdd (seckey: Uint8Array, tweak: Uint8Array, onlyBn?: boolean): 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');
+  if (!isU8a(seckey) || seckey.length !== 32) {
+    throw new Error('Expected seckey to be an Uint8Array with length 32');
+  } else if (!isU8a(tweak) || tweak.length !== 32) {
+    throw new Error('Expected tweak to be an Uint8Array with length 32');
+  }

  return !hasBigInt || onlyBn
    ? addBn(seckey, tweak)
@@ -4,7 +4,7 @@
 import type { HexString } from '@polkadot/util/types';
 import type { HashType } from './types';

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

 import { hasher } from './hasher';
 import { secp256k1Recover } from './recover';
@@ -16,7 +16,9 @@ import { secp256k1Recover } from './recover';
 export function secp256k1Verify (msgHash: HexString | Uint8Array | string, signature: HexString | Uint8Array | string, address: HexString | Uint8Array | string, hashType: HashType = 'blake2', onlyJs?: boolean): boolean {
  const sig = u8aToU8a(signature);

-  assert(sig.length === 65, `Expected signature with 65 bytes, ${sig.length} found instead`);
+  if (sig.length !== 65) {
+    throw new Error(`Expected signature with 65 bytes, ${sig.length} found instead`);
+  }

  const publicKey = secp256k1Recover(hasher(hashType, msgHash), sig, sig[64], hashType, onlyJs);
  const signerAddr = hasher(hashType, publicKey, onlyJs);
@@ -4,7 +4,7 @@
 import type { HexString } from '@polkadot/util/types';
 import type { KeypairType, VerifyResult } from '../types';

-import { assert, u8aIsWrapped, u8aToU8a, u8aUnwrapBytes, u8aWrapBytes } from '@polkadot/util';
+import { u8aIsWrapped, u8aToU8a, u8aUnwrapBytes, u8aWrapBytes } from '@polkadot/util';

 import { decodeAddress } from '../address/decode';
 import { ed25519Verify } from '../ed25519/verify';
@@ -57,7 +57,9 @@ function verifyDetect (result: VerifyResult, { message, publicKey, signature }:
 }

 function verifyMultisig (result: VerifyResult, { message, publicKey, signature }: VerifyInput): VerifyResult {
-  assert([0, 1, 2].includes(signature[0]), () => `Unknown crypto type, expected signature prefix [0..2], found ${signature[0]}`);
+  if (![0, 1, 2].includes(signature[0])) {
+    throw new Error(`Unknown crypto type, expected signature prefix [0..2], found ${signature[0]}`);
+  }

  const type = CRYPTO_TYPES[signature[0]] || 'none';

@@ -88,7 +90,9 @@ function getVerifyFn (signature: Uint8Array): VerifyFn {
 export function signatureVerify (message: HexString | Uint8Array | string, signature: HexString | Uint8Array | string, addressOrPublicKey: HexString | Uint8Array | string): VerifyResult {
  const signatureU8a = u8aToU8a(signature);

-  assert([64, 65, 66].includes(signatureU8a.length), () => `Invalid signature length, expected [64..66] bytes, found ${signatureU8a.length}`);
+  if (![64, 65, 66].includes(signatureU8a.length)) {
+    throw new Error(`Invalid signature length, expected [64..66] bytes, found ${signatureU8a.length}`);
+  }

  const publicKey = decodeAddress(addressOrPublicKey);
  const input = { message: u8aToU8a(message), publicKey, signature: signatureU8a };
@@ -3,7 +3,7 @@

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

-import { assert, u8aToU8a } from '@polkadot/util';
+import { u8aToU8a } from '@polkadot/util';
 import { sr25519Agree } from '@polkadot/wasm-crypto';

 /**
@@ -14,8 +14,11 @@ export function sr25519Agreement (secretKey: HexString | Uint8Array | string, pu
  const secretKeyU8a = u8aToU8a(secretKey);
  const publicKeyU8a = u8aToU8a(publicKey);

-  assert(publicKeyU8a.length === 32, () => `Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
-  assert(secretKeyU8a.length === 64, () => `Invalid secretKey, received ${secretKeyU8a.length} bytes, expected 64`);
+  if (publicKeyU8a.length !== 32) {
+    throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+  } else if (secretKeyU8a.length !== 64) {
+    throw new Error(`Invalid secretKey, received ${secretKeyU8a.length} bytes, expected 64`);
+  }

  return sr25519Agree(publicKeyU8a, secretKeyU8a);
 }
@@ -3,14 +3,16 @@

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

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

 import { sr25519PairFromU8a } from './pair/fromU8a';
 import { sr25519KeypairToU8a } from './pair/toU8a';

 export function createDeriveFn (derive: (pair: Uint8Array, cc: Uint8Array) => Uint8Array): (keypair: Keypair, chainCode: Uint8Array) => Keypair {
  return (keypair: Keypair, chainCode: Uint8Array): Keypair => {
-    assert(isU8a(chainCode) && chainCode.length === 32, 'Invalid chainCode passed to derive');
+    if (!isU8a(chainCode) || chainCode.length !== 32) {
+      throw new Error('Invalid chainCode passed to derive');
+    }

    return sr25519PairFromU8a(
      derive(sr25519KeypairToU8a(keypair), chainCode)
@@ -3,14 +3,17 @@

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

-import { assert, isU8a, u8aToU8a } from '@polkadot/util';
+import { isU8a, u8aToU8a } from '@polkadot/util';
 import { sr25519DerivePublicSoft } from '@polkadot/wasm-crypto';

 export function sr25519DerivePublic (publicKey: HexString | Uint8Array | string, chainCode: Uint8Array): Uint8Array {
  const publicKeyU8a = u8aToU8a(publicKey);

-  assert(isU8a(chainCode) && chainCode.length === 32, 'Invalid chainCode passed to derive');
-  assert(publicKeyU8a.length === 32, () => `Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+  if (!isU8a(chainCode) || chainCode.length !== 32) {
+    throw new Error('Invalid chainCode passed to derive');
+  } else if (publicKeyU8a.length !== 32) {
+    throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+  }

  return sr25519DerivePublicSoft(publicKeyU8a, chainCode);
 }
@@ -4,7 +4,7 @@
 import type { HexString } from '@polkadot/util/types';
 import type { Keypair } from '../../types';

-import { assert, u8aToU8a } from '@polkadot/util';
+import { u8aToU8a } from '@polkadot/util';
 import { sr25519KeypairFromSeed } from '@polkadot/wasm-crypto';

 import { sr25519PairFromU8a } from './fromU8a';
@@ -16,7 +16,9 @@ import { sr25519PairFromU8a } from './fromU8a';
 export function sr25519PairFromSeed (seed: HexString | Uint8Array | string): Keypair {
  const seedU8a = u8aToU8a(seed);

-  assert(seedU8a.length === 32, () => `Expected a seed matching 32 bytes, found ${seedU8a.length}`);
+  if (seedU8a.length !== 32) {
+    throw new Error(`Expected a seed matching 32 bytes, found ${seedU8a.length}`);
+  }

  return sr25519PairFromU8a(
    sr25519KeypairFromSeed(seedU8a)
@@ -4,7 +4,7 @@
 import type { HexString } from '@polkadot/util/types';
 import type { Keypair } from '../../types';

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

 const SEC_LEN = 64;
 const PUB_LEN = 32;
@@ -13,7 +13,9 @@ const TOT_LEN = SEC_LEN + PUB_LEN;
 export function sr25519PairFromU8a (full: HexString | Uint8Array | string): Keypair {
  const fullU8a = u8aToU8a(full);

-  assert(fullU8a.length === TOT_LEN, () => `Expected keypair with ${TOT_LEN} bytes, found ${fullU8a.length}`);
+  if (fullU8a.length !== TOT_LEN) {
+    throw new Error(`Expected keypair with ${TOT_LEN} bytes, found ${fullU8a.length}`);
+  }

  return {
    publicKey: fullU8a.slice(SEC_LEN, TOT_LEN),
@@ -4,7 +4,7 @@
 import type { HexString } from '@polkadot/util/types';
 import type { Keypair } from '../types';

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

 /**
@@ -12,8 +12,11 @@ import { sr25519Sign as wasmSign } from '@polkadot/wasm-crypto';
 * @description Returns message signature of `message`, using the supplied pair
 */
 export function sr25519Sign (message: HexString | Uint8Array | string, { publicKey, secretKey }: Partial<Keypair>): Uint8Array {
-  assert(publicKey?.length === 32, 'Expected a valid publicKey, 32-bytes');
-  assert(secretKey?.length === 64, 'Expected a valid secretKey, 64-bytes');
+  if (publicKey?.length !== 32) {
+    throw new Error('Expected a valid publicKey, 32-bytes');
+  } else if (secretKey?.length !== 64) {
+    throw new Error('Expected a valid secretKey, 64-bytes');
+  }

  return wasmSign(publicKey, secretKey, u8aToU8a(message));
 }
@@ -3,7 +3,7 @@

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

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

 /**
@@ -14,8 +14,11 @@ export function sr25519Verify (message: HexString | Uint8Array | string, signatu
  const publicKeyU8a = u8aToU8a(publicKey);
  const signatureU8a = u8aToU8a(signature);

-  assert(publicKeyU8a.length === 32, () => `Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
-  assert(signatureU8a.length === 64, () => `Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
+  if (publicKeyU8a.length !== 32) {
+    throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+  } else if (signatureU8a.length !== 64) {
+    throw new Error(`Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
+  }

  return wasmVerify(signatureU8a, u8aToU8a(message), publicKeyU8a);
 }
@@ -4,7 +4,7 @@
 import type { HexString } from '@polkadot/util/types';
 import type { Keypair } from '../types';

-import { assert, u8aToU8a } from '@polkadot/util';
+import { u8aToU8a } from '@polkadot/util';
 import { vrfSign } from '@polkadot/wasm-crypto';

 const EMPTY_U8A = new Uint8Array();
@@ -14,7 +14,9 @@ const EMPTY_U8A = new Uint8Array();
 * @description Sign with sr25519 vrf signing (deterministic)
 */
 export function sr25519VrfSign (message: HexString | Uint8Array | string, { secretKey }: Partial<Keypair>, context: HexString | string | Uint8Array = EMPTY_U8A, extra: HexString | string | Uint8Array = EMPTY_U8A): Uint8Array {
-  assert(secretKey?.length === 64, 'Invalid secretKey, expected 64-bytes');
+  if (secretKey?.length !== 64) {
+    throw new Error('Invalid secretKey, expected 64-bytes');
+  }

  return vrfSign(secretKey, u8aToU8a(context), u8aToU8a(message), u8aToU8a(extra));
 }
@@ -3,7 +3,7 @@

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

-import { assert, u8aToU8a } from '@polkadot/util';
+import { u8aToU8a } from '@polkadot/util';
 import { vrfVerify } from '@polkadot/wasm-crypto';

 const EMPTY_U8A = new Uint8Array();
@@ -16,8 +16,11 @@ export function sr25519VrfVerify (message: HexString | Uint8Array | string, sign
  const publicKeyU8a = u8aToU8a(publicKey);
  const proofU8a = u8aToU8a(signOutput);

-  assert(publicKeyU8a.length === 32, 'Invalid publicKey, expected 32-bytes');
-  assert(proofU8a.length === 96, 'Invalid vrfSign output, expected 96 bytes');
+  if (publicKeyU8a.length !== 32) {
+    throw new Error('Invalid publicKey, expected 32-bytes');
+  } else if (proofU8a.length !== 96) {
+    throw new Error('Invalid vrfSign output, expected 96 bytes');
+  }

  return vrfVerify(publicKeyU8a, u8aToU8a(context), u8aToU8a(message), u8aToU8a(extra), proofU8a);
 }
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 import { arrayRange } from '@polkadot/util';
-import { performance, performanceCmp } from '@polkadot/util/test/performance';
+import { perf, perfCmp } from '@polkadot/util/test/performance';

 import { randomAsU8a } from '..';

@@ -11,7 +11,7 @@ type ExecFn = (input: Uint8Array, onlyJs: boolean) => unknown;
 const GENERATED = arrayRange(256).map(() => [randomAsU8a()]);

 export function performanceWasm (name: string, count: number, exec: ExecFn, inputs = GENERATED): void {
-  performanceCmp(name, ['WebAssembly', 'JavaScript'], count, inputs, exec);
+  perfCmp(name, ['WebAssembly', 'JavaScript'], count, inputs, exec);
 }

-export { performance, performanceCmp };
+export { perf, perfCmp };
@@ -34,19 +34,18 @@
    "./detectPackage.cjs"
  ],
  "type": "module",
-  "version": "9.5.1",
+  "version": "10.1.1",
  "main": "index.js",
  "dependencies": {
-    "@babel/runtime": "^7.18.3",
-    "@polkadot/x-bigint": "9.5.1",
-    "@polkadot/x-global": "9.5.1",
-    "@polkadot/x-textdecoder": "9.5.1",
-    "@polkadot/x-textencoder": "9.5.1",
+    "@babel/runtime": "^7.18.9",
+    "@polkadot/x-bigint": "10.1.1",
+    "@polkadot/x-global": "10.1.1",
+    "@polkadot/x-textdecoder": "10.1.1",
+    "@polkadot/x-textencoder": "10.1.1",
    "@types/bn.js": "^5.1.0",
-    "bn.js": "^5.2.1",
-    "ip-regex": "^4.3.0"
+    "bn.js": "^5.2.1"
  },
  "devDependencies": {
-    "@polkadot/x-randomvalues": "9.5.1"
+    "@polkadot/x-randomvalues": "10.1.1"
  }
 }
@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import { performance } from '../test/performance';
+import { perf } from '../test/performance';
 import { arrayChunk, arrayRange } from '.';

 describe('arrayChunk', (): void => {
@@ -11,5 +11,5 @@ describe('arrayChunk', (): void => {
    ).toEqual([[1, 2, 3], [4, 5, 6], [7]]);
  });

-  performance('arrayChunk', 200_000, [[arrayRange(500), 50]], arrayChunk);
+  perf('arrayChunk', 200_000, [[arrayRange(500), 50]], arrayChunk);
 });
@@ -1,9 +1,6 @@
 // Copyright 2017-2022 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import { isNull } from '../is/null';
-import { isUndefined } from '../is/undefined';
-
 /**
 * @name arrayFilter
 * @summary Filters undefined and (optionally) null values from an array
@@ -19,9 +16,9 @@ import { isUndefined } from '../is/undefined';
 * arrayFilter([0, void 0, true, null, false, ''], false); // [0, true, false, '']
 * ```
 */
-export function arrayFilter <T = unknown> (array: (T | null | undefined)[], allowNulls = true): T[] {
+export function arrayFilter <T = unknown> (array: readonly (T | null | undefined)[], allowNulls = true): T[] {
  return array.filter((v): v is T =>
-    !isUndefined(v) &&
-    (allowNulls || !isNull(v))
+    v !== undefined &&
+    (allowNulls || v !== null)
  );
 }
@@ -18,7 +18,7 @@
 * arrayFlatten([[1, 2], [3, 4], [5]]); // [1, 2, 3, 4, 5]
 * ```
 */
-export function arrayFlatten <T> (arrays: T[][]): T[] {
+export function arrayFlatten <T> (arrays: readonly T[][]): T[] {
  // noop for the single-entry case
  if (arrays.length === 1) {
    return arrays[0];
@@ -10,4 +10,5 @@ export { arrayFilter } from './filter';
 export { arrayFlatten } from './flatten';
 export { arrayRange } from './range';
 export { arrayShuffle } from './shuffle';
+export { arrayUnzip } from './unzip';
 export { arrayZip } from './zip';
@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import { performance } from '../test/performance';
+import { perf } from '../test/performance';
 import { arrayRange, arrayShuffle } from '.';

 const ptest = arrayRange(16284);
@@ -32,5 +32,5 @@ describe('arrayShuffle', (): void => {
    ).not.toEqual(JSON.stringify(out));
  });

-  performance('arrayShuffle', 1000, [[ptest]], arrayShuffle);
+  perf('arrayShuffle', 1000, [[ptest]], arrayShuffle);
 });
@@ -5,7 +5,7 @@
 * @name arrayShuffle
 * @description Shuffles the input array (unlike sort, this is not done in-place)
 */
-export function arrayShuffle <T> (input: T[]): T[] {
+export function arrayShuffle <T> (input: readonly T[]): T[] {
  const result = input.slice();
  let curr = result.length;

@@ -0,0 +1,12 @@
+// Copyright 2017-2022 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { arrayUnzip } from '.';
+
+describe('arrayUnzip', (): void => {
+  it('unzips entries', (): void => {
+    expect(
+      arrayUnzip([['a', 1], ['b', 2], ['c', 3]])
+    ).toEqual([['a', 'b', 'c'], [1, 2, 3]]);
+  });
+});
@@ -0,0 +1,17 @@
+// Copyright 2017-2022 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @name arrayUnzip
+ * @description Splits a single [K, V][] into [K[], V[]]
+ */
+export function arrayUnzip <K, V> (entries: readonly [K, V][]): [K[], V[]] {
+  const keys = new Array<K>(entries.length);
+  const values = new Array<V>(entries.length);
+
+  for (let i = 0; i < entries.length; i++) {
+    [keys[i], values[i]] = entries[i];
+  }
+
+  return [keys, values];
+}
@@ -5,7 +5,7 @@
 * @name arrayZip
 * @description Combines 2 distinct key/value arrays into a single [K, V] array
 */
-export function arrayZip <K, V> (keys: K[], values: V[]): [K, V][] {
+export function arrayZip <K, V> (keys: readonly K[], values: readonly V[]): [K, V][] {
  const result = new Array<[K, V]>(keys.length);

  for (let i = 0; i < keys.length; i++) {
@@ -2,8 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0

 import { isFunction } from './is/function';
-import { isNull } from './is/null';
-import { isUndefined } from './is/undefined';

 type MessageFn = () => string;

@@ -38,7 +36,7 @@ export function assert (condition: unknown, message: string | MessageFn): assert
 * @description Returns when the value is not undefined/null, otherwise throws assertion error
 */
 export function assertReturn <T> (value: T | undefined | null, message: string | MessageFn): T {
-  assert(!isUndefined(value) && !isNull(value), message);
+  assert(value !== undefined && value !== null, message);

  return value;
 }
@@ -5,7 +5,7 @@ import { BN } from '../bn';
 import { SQRT_MAX_SAFE_INTEGER } from './sqrt';
 import { nSqrt } from '.';

-const TESTS: [string | number | BN | bigint, string | number][] = [
+export const SQRT_TESTS: [string | number | BN | bigint, string | number][] = [
  [0, 0],
  [1, 1],
  [4, 2],
@@ -45,7 +45,7 @@ describe('nSqrt', (): void => {
    ).toEqual(true);
  });

-  TESTS.forEach(([value, expected], index): void => {
+  SQRT_TESTS.forEach(([value, expected], index): void => {
    it(`calcs for test #${index}`, (): void => {
      expect(
        nSqrt(value) === BigInt(expected)
@@ -4,7 +4,6 @@
 import type { BN } from '../bn/bn';
 import type { HexString, NumberOptions, ToBigInt, ToBn } from '../types';

-import { objectSpread } from '../object/spread';
 import { u8aToHex } from '../u8a';
 import { nToU8a } from './toU8a';

@@ -15,14 +14,8 @@ const ZERO_STR = '0x00';
 * @name nToHex
 * @summary Creates a hex value from a bigint object.
 */
-export function nToHex <ExtToBn extends ToBn | ToBigInt> (value?: ExtToBn | BN | bigint | number | null, options?: NumberOptions): HexString {
+export function nToHex <ExtToBn extends ToBn | ToBigInt> (value?: ExtToBn | BN | bigint | number | null, { bitLength, isLe = false, isNegative = false }: NumberOptions = {}): HexString {
  return !value
    ? ZERO_STR
-    : u8aToHex(
-      nToU8a(value, objectSpread(
-        // We spread here, the default for hex values is BE (JSONRPC via substrate)
-        { isLe: false, isNegative: false },
-        options
-      ))
-    );
+    : u8aToHex(nToU8a(value, { bitLength, isLe, isNegative }));
 }
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 import { arrayRange } from '../array';
-import { performance } from '../test/performance';
+import { perf } from '../test/performance';
 import { nToU8a } from '.';

 const ptest = arrayRange(65536).map((v) => [v]);
@@ -56,5 +56,5 @@ describe('nToU8a', (): void => {
    ).toEqual(new Uint8Array([46, 251, 255, 255]));
  });

-  performance('nToU8a', 250000, ptest, nToU8a);
+  perf('nToU8a', 250000, ptest, nToU8a);
 });
@@ -6,14 +6,13 @@ import type { NumberOptions, ToBigInt, ToBn } from '../types';

 import { BigInt } from '@polkadot/x-bigint';

-import { objectSpread } from '../object/spread';
 import { _0n, _1n } from './consts';
 import { nToBigInt } from './toBigInt';

 const DIV = BigInt(256);
 const NEG_MASK = BigInt(0xff);

-function toU8a (value: bigint, { isLe, isNegative }: NumberOptions): Uint8Array {
+function toU8a (value: bigint, isLe: boolean, isNegative: boolean): Uint8Array {
  const arr: number[] = [];

  if (isNegative) {
@@ -44,34 +43,29 @@ function toU8a (value: bigint, { isLe, isNegative }: NumberOptions): Uint8Array
 * @name nToU8a
 * @summary Creates a Uint8Array object from a bigint.
 */
-export function nToU8a <ExtToBn extends ToBn | ToBigInt> (value?: ExtToBn | BN | bigint | number | null, options?: NumberOptions): Uint8Array {
-  const opts: NumberOptions = objectSpread(
-    { bitLength: -1, isLe: true, isNegative: false },
-    options
-  );
-
+export function nToU8a <ExtToBn extends ToBn | ToBigInt> (value?: ExtToBn | BN | bigint | number | null, { bitLength = -1, isLe = true, isNegative = false }: NumberOptions = {}): Uint8Array {
  const valueBi = nToBigInt(value);

  if (valueBi === _0n) {
-    return opts.bitLength === -1
+    return bitLength === -1
      ? new Uint8Array()
-      : new Uint8Array(Math.ceil((opts.bitLength || 0) / 8));
+      : new Uint8Array(Math.ceil((bitLength || 0) / 8));
  }

-  const u8a = toU8a(valueBi, opts);
+  const u8a = toU8a(valueBi, isLe, isNegative);

-  if (opts.bitLength === -1) {
+  if (bitLength === -1) {
    return u8a;
  }

-  const byteLength = Math.ceil((opts.bitLength || 0) / 8);
+  const byteLength = Math.ceil((bitLength || 0) / 8);
  const output = new Uint8Array(byteLength);

-  if (opts.isNegative) {
+  if (isNegative) {
    output.fill(0xff);
  }

-  output.set(u8a, opts.isLe ? 0 : byteLength - u8a.length);
+  output.set(u8a, isLe ? 0 : byteLength - u8a.length);

  return output;
 }
@@ -1,32 +1,10 @@
 // Copyright 2017-2022 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0

+import { SQRT_TESTS } from '../bi/sqrt.spec';
 import { SQRT_MAX_SAFE_INTEGER } from './sqrt';
 import { BN, bnSqrt } from '.';

-const TESTS: [string | number | BN | bigint, string | number][] = [
-  [0, 0],
-  [1, 1],
-  [4, 2],
-  [256 * 256, 256],
-  [Number.MAX_SAFE_INTEGER, 94906265],
-  [new BN(Number.MAX_SAFE_INTEGER).iaddn(256), 94906265],
-  [12345678n * 12345679n, 12345678],
-  // test cases below from https://github.com/Aisse-258/bigint-isqrt/blob/f5254b9750841959022461c1353437a07a08f501/test/sqrt-test.js
-  [
-    '54866395443885995655625',
-    '234235768925'
-  ],
-  [
-    '82120471531550314555681345949499512621827274120673745141541602816614526075010755373654280259022317599142038423759320355177481886719814621305828811322920076213800348341464996337890625',
-    '9062034624274524065844376014975805577107171799890766992670739972241112960081909332275390625'
-  ],
-  [
-    '2068290204957779940494571454815902632050207752627007664813877111611972735314294907791993008455381265730624848057015476004143868408297250386512042711005577373327434315310235583583151773358353534031397385969275475421659036494173765903706963544628565027679444680637920371210258368358706248446698622704138943704561842220533563976838506992543814273403403362954987589637283890281226038798503294069403370486523697009383229578343444337394508531937972775639593763364402389410142290440075517598007930025487176173228232153685095699851764630884360483051570513804913157899314303269924424908606245851172031453725690942288677622973423417902662711606364188470325930406288190754356367655606430407552275285889968860367977288564364154999338284288438279464648663835830140826171534470717958048887869721791862539529444820484648908879364324577951008050851801647916673254009490596379549192296404841454780884358889449367135382779230574781333008561195244620152128505091883408484094800737142399855337799331037607433934520934135669364954550499058123797911762228642423567268540444910163468496805547450495819213412636594319148417857753712526066272727725420886898680432958409892237191284583904066400736417812258327303739879128916456683685232170600928808798462776174857486589598776587550843543720784829419478239563366491666155716208452087857080883906200829769222868347286071365156305396955420561718593130305703074908891135467193627721682044757187980688062367562451981939375400543212890625',
-    '45478458691536369397924851088318871329614555665525810477032568598360481742967756704524034986984134271202405190906906195123751965012732122548540879928668891416468847696038707003466943811913626146981446753434347552196868717612248915137033581428310504778371173112125038060138252719589122657221314190626986951627417768579641354255445988772645883238873672997347648890137913979299598785628581961589739331483895853398160785485300758458294999124984266041998145956341386549681176624661615465976970855592467853824812945820721933491609237311130118125761849911376495970746282571994312288380577879004620824004760109618074670810797544446334767103935754106103208789391060008291027361311679876439695844637933763721093782805837690830230712890625'
-  ]
-];
-
 describe('bnSqrt', (): void => {
  it('fails on < 0 roots', (): void => {
    expect(
@@ -46,7 +24,7 @@ describe('bnSqrt', (): void => {
    ).toEqual(true);
  });

-  TESTS.forEach(([value, expected], index): void => {
+  SQRT_TESTS.forEach(([value, expected], index): void => {
    it(`calcs for test #${index}`, (): void => {
      expect(
        bnSqrt(value).eq(new BN(expected))
@@ -18,16 +18,10 @@ describe('bnToHex', (): void => {

  it('converts BN values to a prefixed hex representation (bitLength)', (): void => {
    expect(
-      bnToHex(new BN(128), 16)
+      bnToHex(new BN(128), { bitLength: 16 })
    ).toBe('0x0080');
  });

-  it('converts BN values to a prefixed hex representation (bitLength + le)', (): void => {
-    expect(
-      bnToHex(new BN(128), 16, true)
-    ).toBe('0x8000');
-  });
-
  it('converts BN values to a prefixed hex representation (LE)', (): void => {
    expect(
      bnToHex(new BN(128), { bitLength: 16, isLe: true })
@@ -45,12 +39,4 @@ describe('bnToHex', (): void => {
      bnToHex(new BN(-1234), { bitLength: 32, isNegative: true })
    ).toBe('0xfffffb2e');
  });
-
-  it('handles legacy compatibility', (): void => {
-    expect(
-      bnToHex(new BN(1234), 32)
-    ).toBe(
-      bnToHex(new BN(1234), { bitLength: 32 })
-    );
-  });
 });
@@ -4,13 +4,10 @@
 import type { HexString, NumberOptions, ToBn } from '../types';
 import type { BN } from './bn';

-import { isNumber } from '../is/number';
-import { objectSpread } from '../object/spread';
 import { u8aToHex } from '../u8a';
 import { bnToU8a } from './toU8a';

 const ZERO_STR = '0x00';
-const DEFAULT_OPTS: NumberOptions = { bitLength: -1, isLe: false, isNegative: false };

 /**
 * @name bnToHex
@@ -27,22 +24,8 @@ const DEFAULT_OPTS: NumberOptions = { bitLength: -1, isLe: false, isNegative: fa
 * bnToHex(new BN(0x123456)); // => '0x123456'
 * ```
 */
-function bnToHex <ExtToBn extends ToBn> (value?: ExtToBn | BN | bigint | number | null, options?: NumberOptions): HexString;
-/** @deprecated Use bnToHex (value?: ExtToBn | BN | bigint | number | null, options?: NumberOptions) */
-function bnToHex <ExtToBn extends ToBn> (value?: ExtToBn | BN | bigint | number | null, bitLength?: number, isLe?: boolean): HexString;
-/** @deprecated Use bnToHex (value?: ExtToBn | BN | bigint | number | null, options?: NumberOptions) */
-function bnToHex <ExtToBn extends ToBn> (value?: ExtToBn | BN | bigint | number | null, arg1: number | NumberOptions = DEFAULT_OPTS, arg2 = false): HexString {
+export function bnToHex <ExtToBn extends ToBn> (value?: ExtToBn | BN | bigint | number | null, { bitLength = -1, isLe = false, isNegative = false }: NumberOptions = {}): HexString {
  return !value
    ? ZERO_STR
-    : u8aToHex(
-      bnToU8a(value, objectSpread(
-        // We spread here, the default for hex values is BE (JSONRPC via substrate)
-        { isLe: false, isNegative: false },
-        isNumber(arg1)
-          ? { bitLength: arg1, isLe: arg2 }
-          : arg1
-      ))
-    );
+    : u8aToHex(bnToU8a(value, { bitLength, isLe, isNegative }));
 }
-
-export { bnToHex };
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 import { arrayRange } from '../array';
-import { performance } from '../test/performance';
+import { perf } from '../test/performance';
 import { BN, bnToU8a } from '.';

 const ptest = arrayRange(65536).map((v) => [v]);
@@ -10,42 +10,34 @@ const ptest = arrayRange(65536).map((v) => [v]);
 describe('bnToU8a', (): void => {
  it('converts null values to 0x00', (): void => {
    expect(
-      bnToU8a(null, -1, false)
+      bnToU8a(null)
    ).toEqual(new Uint8Array());
  });

  it('converts null values to 0x00000000 (bitLength)', (): void => {
    expect(
-      bnToU8a(null, 32, false)
+      bnToU8a(null, { bitLength: 32 })
    ).toEqual(new Uint8Array([0, 0, 0, 0]));
  });

  it('converts BN values to a prefixed hex representation', (): void => {
    expect(
-      bnToU8a(new BN(0x123456), -1, false)
+      bnToU8a(new BN(0x123456), { isLe: false })
    ).toEqual(new Uint8Array([0x12, 0x34, 0x56]));
  });

  it('converts BN values to a prefixed hex representation (bitLength)', (): void => {
    expect(
-      bnToU8a(new BN(0x123456), 32, false)
+      bnToU8a(new BN(0x123456), { bitLength: 32, isLe: false })
    ).toEqual(new Uint8Array([0x00, 0x12, 0x34, 0x56]));
  });

  it('converts using little endian (as set)', (): void => {
    expect(
-      bnToU8a(new BN(0x123456), 32, true)
+      bnToU8a(new BN(0x123456), { bitLength: 32, isLe: true })
    ).toEqual(new Uint8Array([0x56, 0x34, 0x12, 0x00]));
  });

-  it('handles backwards compatibility', (): void => {
-    expect(
-      bnToU8a(new BN(1234), 32, false)
-    ).toEqual(
-      bnToU8a(new BN(1234), { bitLength: 32, isLe: false })
-    );
-  });
-
  describe('signed', (): void => {
    it('converts negative numbers (BE)', (): void => {
      expect(
@@ -108,5 +100,5 @@ describe('bnToU8a', (): void => {
    });
  });

-  performance('bnToU8a', 250000, ptest, bnToU8a);
+  perf('bnToU8a', 250000, ptest, bnToU8a);
 });
@@ -4,7 +4,6 @@
 import type { NumberOptions, ToBn } from '../types';
 import type { BN } from './bn';

-import { isNumber } from '../is/number';
 import { bnToBn } from './toBn';

 const DEFAULT_OPTS: NumberOptions = { bitLength: -1, isLe: true, isNegative: false };
@@ -23,15 +22,7 @@ const DEFAULT_OPTS: NumberOptions = { bitLength: -1, isLe: true, isNegative: fal
 * bnToU8a(new BN(0x1234)); // => [0x12, 0x34]
 * ```
 */
-function bnToU8a <ExtToBn extends ToBn> (value?: ExtToBn | BN | bigint | number | null, options?: NumberOptions): Uint8Array;
-/** @deprecated Use bnToU8a(value?: ExtToBn | BN | bigint | number | null, options?: NumberOptions) */
-function bnToU8a <ExtToBn extends ToBn> (value?: ExtToBn | BN | bigint | number | null, bitLength?: number, isLe?: boolean): Uint8Array;
-/** @deprecated Use bnToU8a(value?: ExtToBn | BN | bigint | number | null, options?: NumberOptions) */
-function bnToU8a <ExtToBn extends ToBn> (value?: ExtToBn | BN | bigint | number | null, arg1: number | NumberOptions = DEFAULT_OPTS, arg2 = true): Uint8Array {
-  const { bitLength = -1, isLe = true, isNegative = false } = isNumber(arg1)
-    ? { bitLength: arg1, isLe: arg2 }
-    : arg1;
-
+export function bnToU8a <ExtToBn extends ToBn> (value?: ExtToBn | BN | bigint | number | null, { bitLength = -1, isLe = true, isNegative = false } = DEFAULT_OPTS): Uint8Array {
  const valueBn = bnToBn(value);
  const byteLength = bitLength === -1
    ? Math.ceil(valueBn.bitLength() / 8)
@@ -52,5 +43,3 @@ function bnToU8a <ExtToBn extends ToBn> (value?: ExtToBn | BN | bigint | number

  return output;
 }
-
-export { bnToU8a };
@@ -13,6 +13,7 @@ export * from './bn';
 export * from './buffer';
 export * from './compact';
 export * from './extractTime';
+export * from './float';
 export * from './format';
 export * from './has';
 export * from './hex';
@@ -3,7 +3,7 @@

 import { BN } from '../bn/bn';
 import { hexToU8a } from '../hex/toU8a';
-import { performance } from '../test/performance';
+import { perf } from '../test/performance';
 import { compactFromU8a, compactFromU8aLim } from '.';

 describe('compactFromU8a', (): void => {
@@ -73,10 +73,10 @@ describe('compactFromU8a', (): void => {
    ).toEqual('100000000');
  });

-  performance('compactFromU8a (u8)', 1_000_000, [[new Uint8Array([63 << 2])]], compactFromU8a);
-  performance('compactFromU8a (u16)', 1_000_000, [[new Uint8Array([0b11111101, 0b00000111])]], compactFromU8a);
-  performance('compactFromU8a (u32)', 1_000_000, [[new Uint8Array([254, 255, 3, 0])]], compactFromU8a);
-  performance('compactFromU8aLim (u32)', 1_000_000, [[new Uint8Array([254, 255, 3, 0])]], compactFromU8aLim);
-  performance('compactFromU8a (u48)', 1_000_000, [[hexToU8a('0x0b00407a10f35a')]], compactFromU8a);
-  performance('compactFromU8a (u96)', 250_000, [[new Uint8Array([23, 52, 0x40, 0x7a, 0x10, 0xf3, 0x5a, 0, 0, 18])]], compactFromU8a);
+  perf('compactFromU8a (u8)', 1_000_000, [[new Uint8Array([63 << 2])]], compactFromU8a);
+  perf('compactFromU8a (u16)', 1_000_000, [[new Uint8Array([0b11111101, 0b00000111])]], compactFromU8a);
+  perf('compactFromU8a (u32)', 1_000_000, [[new Uint8Array([254, 255, 3, 0])]], compactFromU8a);
+  perf('compactFromU8aLim (u32)', 1_000_000, [[new Uint8Array([254, 255, 3, 0])]], compactFromU8aLim);
+  perf('compactFromU8a (u48)', 1_000_000, [[hexToU8a('0x0b00407a10f35a')]], compactFromU8a);
+  perf('compactFromU8a (u96)', 250_000, [[new Uint8Array([23, 52, 0x40, 0x7a, 0x10, 0xf3, 0x5a, 0, 0, 18])]], compactFromU8a);
 });
@@ -0,0 +1,4 @@
+// Copyright 2017-2022 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export { floatToU8a } from './toU8a';
@@ -0,0 +1,90 @@
+// Copyright 2017-2022 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { u8aToHex } from '../u8a';
+import { floatToU8a } from '.';
+
+describe('floatToU8a', (): void => {
+  it('throws on invalid bitLength', (): void => {
+    expect(
+      () => floatToU8a(123, { bitLength: 48 as 32 })
+    ).toThrow();
+  });
+
+  describe('32-bit', (): void => {
+    it('correctly encodes +0.0', (): void => {
+      expect(
+        u8aToHex(floatToU8a(+0.0))
+      ).toEqual('0x00000000');
+    });
+
+    it('correctly encodes -0.0', (): void => {
+      expect(
+        u8aToHex(floatToU8a(-0.0))
+      ).toEqual('0x00000080');
+    });
+
+    it('correctly encodes -0.0 (BE)', (): void => {
+      expect(
+        u8aToHex(floatToU8a(-0.0, { isLe: false }))
+      ).toEqual('0x80000000');
+    });
+
+    it('encodes NaN', (): void => {
+      expect(
+        u8aToHex(floatToU8a(Number.NaN, { isLe: true }))
+      ).toEqual('0x0000c07f');
+    });
+
+    describe('equivalency', (): void => {
+      it('encodes number 123.456', (): void => {
+        expect(
+          u8aToHex(floatToU8a(123.456))
+        ).toEqual('0x79e9f642');
+      });
+
+      it('encodes string 123.456', (): void => {
+        expect(
+          u8aToHex(floatToU8a('123.456'))
+        ).toEqual('0x79e9f642');
+      });
+
+      it('encodes Number 123.456', (): void => {
+        class Test extends Number {
+          foo = 'bar';
+        }
+
+        // https://www.h-schmidt.net/FloatConverter/IEEE754.html
+        expect(
+          u8aToHex(floatToU8a(new Test(123.456)))
+        ).toEqual('0x79e9f642');
+      });
+    });
+  });
+
+  describe('64-bit', (): void => {
+    it('correctly encodes +0.0', (): void => {
+      expect(
+        u8aToHex(floatToU8a(+0.0, { bitLength: 64 }))
+      ).toEqual('0x0000000000000000');
+    });
+
+    it('correctly encodes -0.0', (): void => {
+      expect(
+        u8aToHex(floatToU8a(-0.0, { bitLength: 64, isLe: true }))
+      ).toEqual('0x0000000000000080');
+    });
+
+    it('correctly encodes -0.0 (BE)', (): void => {
+      expect(
+        u8aToHex(floatToU8a(-0.0, { bitLength: 64, isLe: false }))
+      ).toEqual('0x8000000000000000');
+    });
+
+    it('encodes NaN', (): void => {
+      expect(
+        u8aToHex(floatToU8a(Number.NaN, { bitLength: 64 }))
+      ).toEqual('0x000000000000f87f');
+    });
+  });
+});
@@ -0,0 +1,32 @@
+// Copyright 2017-2022 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type AnyFloat = number | Number;
+
+interface Options {
+  bitLength?: 32 | 64;
+  isLe?: boolean;
+}
+
+/**
+ * @name floatToU8a
+ * @description Converts a float into a U8a representation (While we don't use BE in SCALE
+ * we still allow for either representation, although, as elsewhere, isLe is default)
+ */
+export function floatToU8a (value: string | AnyFloat = 0.0, { bitLength = 32, isLe = true }: Options = {}): Uint8Array {
+  if (bitLength !== 32 && bitLength !== 64) {
+    throw new Error('Invalid bitLength provided, expected 32 or 64');
+  }
+
+  const result = new Uint8Array(bitLength / 8);
+  const dv = new DataView(result.buffer, result.byteOffset);
+
+  if (bitLength === 32) {
+    dv.setFloat32(0, Number(value), isLe);
+  } else {
+    dv.setFloat64(0, Number(value), isLe);
+  }
+
+  return result;
+}
@@ -33,16 +33,10 @@ describe('formatBalance', (): void => {

    it('formats 123,456,789,000 (decimals=15, old style)', (): void => {
      expect(
-        formatBalance(TESTVAL, { withSi: true }, 15)
+        formatBalance(TESTVAL, { decimals: 15, withSi: true })
      ).toEqual('123.4567 µUnit');
    });

-    it('formats 123,456,789,000 (decimals=36, option)', (): void => {
-      expect(
-        formatBalance(TESTVAL, { decimals: 36, withSi: true })
-      ).toEqual('0.1234 yUnit');
-    });
-
    it('formats 123,456,789,000 (decimals=15, Compact)', (): void => {
      const compact = {
        something: 'else',
@@ -63,85 +57,85 @@ describe('formatBalance', (): void => {

    it('formats 123,456,789,000 (decimals=9)', (): void => {
      expect(
-        formatBalance(TESTVAL, { withSi: true }, 9)
+        formatBalance(TESTVAL, { decimals: 9, withSi: true })
      ).toEqual('123.4567 Unit');
    });

    it('formats 123,456,789,000 (decimals=9, no unit)', (): void => {
      expect(
-        formatBalance(TESTVAL, { withSi: true, withUnit: false }, 9)
+        formatBalance(TESTVAL, { decimals: 9, withSi: true, withUnit: false })
      ).toEqual('123.4567');
    });

    it('formats 123,456,789,000 (decimals=9, unit given)', (): void => {
      expect(
-        formatBalance(TESTVAL, { withSi: true, withUnit: 'FOO' }, 9)
+        formatBalance(TESTVAL, { decimals: 9, withSi: true, withUnit: 'FOO' })
      ).toEqual('123.4567 FOO');
    });

    it('formats 123,456,789,000 (decimals=12, no SI)', (): void => {
      expect(
-        formatBalance(TESTVAL, { withSi: false }, 12)
+        formatBalance(TESTVAL, { decimals: 12, withSi: false })
      ).toEqual('123.4567');
    });

    it('formats 123,456,789,000 (decimals=12, full SI)', (): void => {
      expect(
-        formatBalance(TESTVAL, { withSiFull: true }, 12)
+        formatBalance(TESTVAL, { decimals: 12, withSiFull: true })
      ).toEqual('123.4567 milli Unit');
    });

    it('formats 123,456,789,000 (decimals=12, full SI, no unit)', (): void => {
      expect(
-        formatBalance(TESTVAL, { withSiFull: true, withUnit: false }, 12)
+        formatBalance(TESTVAL, { decimals: 12, withSiFull: true, withUnit: false })
      ).toEqual('123.4567 milli');
    });

    it('formats 123,456,789,000 (decimals=9, full SI)', (): void => {
      expect(
-        formatBalance(TESTVAL, { withSiFull: true }, 9)
+        formatBalance(TESTVAL, { decimals: 9, withSiFull: true })
      ).toEqual('123.4567 Unit');
    });

    it('formats 123,456,789,000 (decimals=6)', (): void => {
      expect(
-        formatBalance(TESTVAL, { withSi: true }, 6)
+        formatBalance(TESTVAL, { decimals: 6, withSi: true })
      ).toEqual('123.4567 kUnit');
    });

    it('formats 123,456,789,000 (decimals=6, unit specified)', (): void => {
      expect(
-        formatBalance(TESTVAL, { withSi: true, withUnit: 'BAR' }, 6)
+        formatBalance(TESTVAL, { decimals: 6, withSi: true, withUnit: 'BAR' })
      ).toEqual('123.4567 kBAR');
    });

    it('formats 123,456,789,000 (decimals=0, unit specified)', (): void => {
      expect(
-        formatBalance(TESTVAL, { withSi: true, withUnit: 'BAR' }, 0)
+        formatBalance(TESTVAL, { decimals: 0, withSi: true, withUnit: 'BAR' })
      ).toEqual('123.4567 BBAR');
    });

    it('formats 123,456,789,000 * 10 (decimals=12)', (): void => {
      expect(
-        formatBalance(TESTVAL.muln(10), { withSi: true }, 12)
+        formatBalance(TESTVAL.muln(10), { decimals: 12, withSi: true })
      ).toEqual('1.2345 Unit');
    });

    it('formats 123,456,789,000 * 100 (decimals=12)', (): void => {
      expect(
-        formatBalance(TESTVAL.muln(100), { withSi: true }, 12)
+        formatBalance(TESTVAL.muln(100), { decimals: 12, withSi: true })
      ).toEqual('12.3456 Unit');
    });

    it('formats 123,456,789,000 * 1000 (decimals=12)', (): void => {
      expect(
-        formatBalance(TESTVAL.muln(1000), { withSi: true }, 12)
+        formatBalance(TESTVAL.muln(1000), { decimals: 12, withSi: true })
      ).toEqual('123.4567 Unit');
    });

    it('formats -123,456,789,000 (decimals=15)', (): void => {
      expect(
-        formatBalance(new BN('-123456789000'), { withSi: true }, 15)
+        formatBalance(new BN('-123456789000'), { decimals: 15, withSi: true })
      ).toEqual('-123.4567 µUnit');
    });
  });
@@ -149,25 +143,25 @@ describe('formatBalance', (): void => {
  describe('Forced formatting', (): void => {
    it('formats 123,456,789,000 (decimals=12, forceUnit=base)', (): void => {
      expect(
-        formatBalance(TESTVAL, { forceUnit: '-' }, 12)
+        formatBalance(TESTVAL, { decimals: 12, forceUnit: '-' })
      ).toEqual('0.1234 Unit');
    });

    it('formats 123,456,789,000 (decimals=9, forceUnit=base)', (): void => {
      expect(
-        formatBalance(TESTVAL, { forceUnit: '-' }, 9)
+        formatBalance(TESTVAL, { decimals: 9, forceUnit: '-' })
      ).toEqual('123.4567 Unit');
    });

    it('formats 123,456,789,000 (decimals=7, forceUnit=base)', (): void => {
      expect(
-        formatBalance(TESTVAL, { forceUnit: '-' }, 7)
+        formatBalance(TESTVAL, { decimals: 7, forceUnit: '-' })
      ).toEqual('12,345.6789 Unit');
    });

    it('formats 123,456,789,000 (decimals=15, forceUnit=µ)', (): void => {
      expect(
-        formatBalance(TESTVAL, { forceUnit: 'µ' }, 15)
+        formatBalance(TESTVAL, { decimals: 15, forceUnit: 'µ' })
      ).toEqual('123.4567 µUnit');
    });
  });
@@ -6,7 +6,6 @@ import type { SiDef, ToBn } from '../types';

 import { bnToBn } from '../bn/toBn';
 import { isBoolean } from '../is/boolean';
-import { isUndefined } from '../is/undefined';
 import { formatDecimal } from './formatDecimal';
 import { calcSi, findSi, SI, SI_MID } from './si';

@@ -45,10 +44,6 @@ interface Options {

 interface BalanceFormatter {
  <ExtToBn extends ToBn> (input?: number | string | BN | bigint | ExtToBn, options?: Options): string;
-  /** @deprecated Use balanceFormat(input?: number | string | BN | bigint | ExtToBn, options?: Options) */
-  <ExtToBn extends ToBn> (input?: number | string | BN | bigint | ExtToBn, options?: boolean, decimals?: number): string;
-  /** @deprecated Use balanceFormat(input?: number | string | BN | bigint | ExtToBn, options?: Options) */
-  <ExtToBn extends ToBn> (input?: number | string | BN | bigint | ExtToBn, options?: Options, decimals?: number): string;
  calcSi (text: string, decimals?: number): SiDef;
  findSi (type: string): SiDef;
  getDefaults (): Defaults;
@@ -90,18 +85,13 @@ function getPrePost (text: string, decimals: number, forceUnit?: string): [SiDef
 }

 // Formats a string/number with <prefix>.<postfix><type> notation
-function _formatBalance <ExtToBn extends ToBn> (input?: number | string | BN | bigint | ExtToBn, options: Options | boolean = true, optDecimals: number = defaultDecimals): string {
+function _formatBalance <ExtToBn extends ToBn> (input?: number | string | BN | bigint | ExtToBn, { decimals = defaultDecimals, forceUnit, withSi = true, withSiFull = false, withUnit = true }: Options = {}): string {
  let text = bnToBn(input).toString();

  if (text.length === 0 || text === '0') {
    return '0';
  }

-  // extract options - the boolean case is for backwards-compat
-  const { decimals = optDecimals, forceUnit = undefined, withSi = true, withSiFull = false, withUnit = true } = isBoolean(options)
-    ? { withSi: options }
-    : options;
-
  // strip the negative sign so we can work with clean groupings, re-add this in the
  // end when we return the result (from here on we work with positive numbers)
  let sign = '';
@@ -147,12 +137,12 @@ formatBalance.getOptions = (decimals: number = defaultDecimals): SiDef[] => {
 // Sets the default decimals to use for formatting (ui-wide)
 // eslint-disable-next-line @typescript-eslint/unbound-method
 formatBalance.setDefaults = ({ decimals, unit }: SetDefaults): void => {
-  defaultDecimals = isUndefined(decimals)
+  defaultDecimals = decimals === undefined
    ? defaultDecimals
    : Array.isArray(decimals)
      ? decimals[0]
      : decimals;
-  defaultUnit = isUndefined(unit)
+  defaultUnit = unit === undefined
    ? defaultUnit
    : Array.isArray(unit)
      ? unit[0]
@@ -3,6 +3,15 @@

 import { BigInt } from '@polkadot/x-bigint';

+// Since we run in very different environments, we have to ensure we have all
+// the types used here for detection (some of these may require Node definitions,
+// which are not available in Deno/browser)
+declare const __dirname: unknown;
+declare const Buffer: unknown;
+declare const module: unknown;
+declare const process: unknown;
+declare const require: unknown;
+
 /** true if the environment has proper BigInt support */
 export const hasBigInt = typeof BigInt === 'function' && typeof BigInt.asIntN === 'function';

@@ -5,7 +5,6 @@ import type { ToBnOptions } from '../types';

 import { BigInt } from '@polkadot/x-bigint';

-import { objectSpread } from '../object/spread';
 import { u8aToBigInt } from '../u8a/toBigInt';
 import { hexToU8a } from './toU8a';

@@ -13,11 +12,8 @@ import { hexToU8a } from './toU8a';
 * @name hexToBigInt
 * @summary Creates a BigInt instance object from a hex string.
 */
-export function hexToBigInt (value?: string | null, options: ToBnOptions = {}): bigint {
+export function hexToBigInt (value?: string | null, { isLe = false, isNegative = false }: ToBnOptions = {}): bigint {
  return !value || value === '0x'
    ? BigInt(0)
-    : u8aToBigInt(
-      hexToU8a(value),
-      objectSpread({ isLe: false, isNegative: false }, options)
-    );
+    : u8aToBigInt(hexToU8a(value), { isLe, isNegative });
 }
@@ -69,17 +69,4 @@ describe('hexToBn', (): void => {
      hexToBn('0x0001000000000000', { isLe: true }).toNumber()
    ).toBe(256);
  });
-
-  it('handles legacy compatibility', (): void => {
-    expect(
-      hexToBn('0x0001000000000000', false).eq(
-        hexToBn('0x0001000000000000', { isLe: false })
-      )
-    ).toBe(true);
-    expect(
-      hexToBn('0x0001000000000000', true).eq(
-        hexToBn('0x0001000000000000', { isLe: true })
-      )
-    ).toBe(true);
-  });
 });
@@ -4,7 +4,6 @@
 import type { ToBnOptions } from '../types';

 import { BN } from '../bn/bn';
-import { isBoolean } from '../is/boolean';
 import { hexStripPrefix } from './stripPrefix';

 /**
@@ -25,19 +24,11 @@ import { hexStripPrefix } from './stripPrefix';
 * hexToBn('0x123480001f'); // => BN(0x123480001f)
 * ```
 */
-function hexToBn (value?: string | null, options?: ToBnOptions): BN;
-/** @deprecated Use hexToBn (value?: string | null, options?: ToBnOptions) */
-function hexToBn (value?: string | null, options?: boolean): BN;
-/** @deprecated Use hexToBn (value?: string | null, options?: ToBnOptions) */
-function hexToBn (value?: string | null, options: ToBnOptions | boolean = {}): BN {
+export function hexToBn (value?: string | null, { isLe = false, isNegative = false }: ToBnOptions = {}): BN {
  if (!value || value === '0x') {
    return new BN(0);
  }

-  // For hex, default to BE
-  const { isLe = false, isNegative = false } = isBoolean(options)
-    ? { isLe: options }
-    : options;
  const stripped = hexStripPrefix(value);
  const bn = new BN(stripped, 16, isLe ? 'le' : 'be');

@@ -47,5 +38,3 @@ function hexToBn (value?: string | null, options: ToBnOptions | boolean = {}): B
    ? bn.fromTwos(stripped.length * 4)
    : bn;
 }
-
-export { hexToBn };
@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0

-import { performanceCmp } from '../test/performance';
+import { perfCmp } from '../test/performance';
 import { hexToU8a as hexToU8aBuffer } from './toU8aBuffer';
 import { hexToU8a } from '.';

@@ -18,6 +18,12 @@ describe('hexToU8a', (): void => {
    ).toHaveLength(0);
  });

+  it('returns an empty Uint8Array when 0x provided', (): void => {
+    expect(
+      hexToU8a('0x')
+    ).toHaveLength(0);
+  });
+
  it('returns a Uint8Array with the correct values', (): void => {
    expect(
      hexToU8a('0x80000a')
@@ -42,19 +48,31 @@ describe('hexToU8a', (): void => {
    );
  });

+  it('converts a non-aligned string', (): void => {
+    expect(
+      hexToU8a('0x123')
+    ).toEqual(new Uint8Array([0x12, 0x30]));
+  });
+
  it('converts known bytes to their correct values', (): void => {
    expect(
      hexToU8a('0x68656c6c6f20776f726c64') // hello world (11 bytes, non-aligned)
    ).toEqual(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64]));
  });

-  it('fails when non-hex value provided', (): void => {
+  it('converts known bytes to their correct values (upper/lower)', (): void => {
+    expect(
+      hexToU8a('0x68656C6c6f20776F726c64') // hello world (11 bytes, non-aligned)
+    ).toEqual(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64]));
+  });
+
+  it.skip('fails when non-hex value provided', (): void => {
    expect(
      () => hexToU8a('notahex')
    ).toThrow(/hex value to convert/);
  });

-  performanceCmp('hexToU8a', ['hexToU8aBuffer', 'hexToU8a'], 20, [[ptest]], (s: string, isSecond) =>
+  perfCmp('hexToU8a', ['hexToU8aBuffer', 'hexToU8a'], 25, [[ptest]], (s: string, isSecond) =>
    isSecond
      ? hexToU8a(s)
      : hexToU8aBuffer(s)
@@ -3,16 +3,23 @@

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

-import { hexStripPrefix } from './stripPrefix';
+const CHR = '0123456789abcdef';
+const U8 = new Array<number>(256);
+const U16 = new Array<number>(256 * 256);

-const CHARS = '0123456789abcdef';
-const UNHEX = new Array<number>(256);
-
-for (let i = 0; i < CHARS.length; i++) {
-  UNHEX[CHARS[i].charCodeAt(0)] = i;
+for (let i = 0; i < CHR.length; i++) {
+  U8[CHR[i].charCodeAt(0) | 0] = i | 0;

  if (i > 9) {
-    UNHEX[CHARS[i].toUpperCase().charCodeAt(0)] = i;
+    U8[CHR[i].toUpperCase().charCodeAt(0) | 0] = i | 0;
+  }
+}
+
+for (let i = 0; i < 256; i++) {
+  const s = i << 8;
+
+  for (let j = 0; j < 256; j++) {
+    U16[s | j] = (U8[i] << 4) | U8[j];
  }
 }

@@ -36,24 +43,27 @@ export function hexToU8a (value?: HexString | string | null, bitLength = -1): Ui
    return new Uint8Array();
  }

-  const str = hexStripPrefix(value);
-  const strLength = str.length / 2;
+  let s = value.startsWith('0x')
+    ? 2
+    : 0;
+
+  const decLength = Math.ceil((value.length - s) / 2);
  const endLength = Math.ceil(
    bitLength === -1
-      ? strLength
+      ? decLength
      : bitLength / 8
  );
  const result = new Uint8Array(endLength);
-  const offset = endLength > strLength
-    ? endLength - strLength
+  const offset = endLength > decLength
+    ? endLength - decLength
    : 0;

-  for (let i = offset, s = 0; i < endLength; i++, s += 2) {
+  for (let i = offset; i < endLength; i++, s += 2) {
    // The big factor here is actually the string lookups. If we do
    // HEX_TO_U16[value.substring()] we get an 10x slowdown. In the
    // same vein using charCodeAt (as opposed to value[s] or value.charAt(s)) is
    // also the faster operation by at least 2x with the character map above
-    result[i] = ((UNHEX[str.charCodeAt(s)] << 4) + UNHEX[str.charCodeAt(s + 1)]) | 0;
+    result[i] = U16[(value.charCodeAt(s) << 8) | value.charCodeAt(s + 1)];
  }

  return result;
@@ -34,7 +34,7 @@ describe('hexToU8a', (): void => {
    );
  });

-  it('fails when non-hex value provided', (): void => {
+  it.skip('fails when non-hex value provided', (): void => {
    expect(
      () => hexToU8a('notahex')
    ).toThrow(/hex value to convert/);
@@ -3,8 +3,6 @@

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

-import { hexStripPrefix } from './stripPrefix';
-
 /**
 * @name hexToU8a
 * @summary Creates a Uint8Array object from a hex string.
@@ -25,7 +23,9 @@ export function hexToU8a (_value?: HexString | string | null, bitLength = -1): U
    return new Uint8Array();
  }

-  const value = hexStripPrefix(_value);
+  const value = _value.startsWith('0x')
+    ? _value.substring(2)
+    : _value;
  const buf = Buffer.from(value, 'hex');
  const valLength = value.length / 2;
  const resultLength = Math.ceil(
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
github-actions[bot]	25f9444c53	[CI Skip] release/stable 10.1.1 skip-checks: true	2022-07-21 05:37:00 +00:00
Jaco	6d46f8b24e	10.1.1 (#1614 )	2022-07-21 08:33:15 +03:00
github-actions[bot]	0189cdabe9	[CI Skip] bump/beta 10.0.3-19-x skip-checks: true	2022-07-20 08:51:57 +00:00
Jaco	9d61c2c96c	Adjust spread check for .entries() (#1613 )	2022-07-20 11:47:55 +03:00
github-actions[bot]	6599b41155	[CI Skip] bump/beta 10.0.3-18-x skip-checks: true	2022-07-20 08:27:48 +00:00
Jaco	9c05257046	Add ability to spread Map entries (optimization) (#1612 )	2022-07-20 11:23:26 +03:00
github-actions[bot]	41e2e67fd0	[CI Skip] bump/beta 10.0.3-17-x skip-checks: true	2022-07-20 06:39:06 +00:00
Jaco	092fbdd923	Align property & lazy signatures (getName & self) (#1611 ) * Align property & lazy signatures (getName & self) * Adjust tests	2022-07-20 09:34:13 +03:00
github-actions[bot]	c1cdc80169	[CI Skip] bump/beta 10.0.3-16-x skip-checks: true	2022-07-19 19:07:58 +00:00
Jaco	306bbdea12	Pass internal this through on objectProperties (#1610 ) * Pass internal this through on objectProperties * Fix property test	2022-07-19 22:03:26 +03:00
github-actions[bot]	f41519e185	[CI Skip] bump/beta 10.0.3-15-x skip-checks: true	2022-07-19 15:33:00 +00:00
Carlo Sala	1a3fd344b5	feat(ledger): add interlay and unique (#1609 )	2022-07-19 18:28:30 +03:00
github-actions[bot]	f798c1dbd5	[CI Skip] bump/beta 10.0.3-14-x skip-checks: true	2022-07-19 08:58:31 +00:00
Jaco	813d358999	hexToU8a lookup optimizations (#1608 ) * hexToU8a lookup optimizations * Non-aligned test	2022-07-19 11:55:01 +03:00
github-actions[bot]	e85eb35413	[CI Skip] bump/beta 10.0.3-13-x skip-checks: true	2022-07-19 05:36:50 +00:00
Jaco	8a50cba394	Additional assert cleanups (#1604 )	2022-07-19 08:33:22 +03:00
github-actions[bot]	20f030e987	[CI Skip] bump/beta 10.0.3-12-x skip-checks: true	2022-07-19 05:28:13 +00:00
Jaco	4a683f41d3	Dev bump (w/ additional deno overrides) (#1607 )	2022-07-19 08:23:42 +03:00
github-actions[bot]	ea7f59ab73	[CI Skip] bump/beta 10.0.3-11-x skip-checks: true	2022-07-18 14:54:47 +00:00
Jaco	60498f7f36	Dev bump (#1606 )	2022-07-18 17:49:02 +03:00
github-actions[bot]	9ad0c46417	[CI Skip] bump/beta 10.0.3-10-x skip-checks: true	2022-07-18 13:45:34 +00:00
Jaco	0fc140f838	Additional speed optimizations (#1605 )	2022-07-18 16:41:53 +03:00
github-actions[bot]	cd63bb695d	[CI Skip] bump/beta 10.0.3-9-x skip-checks: true	2022-07-18 11:55:15 +00:00
Jaco	7eac688074	Small performance adjustments for Uint8Array indexing (#1603 )	2022-07-18 14:51:39 +03:00
github-actions[bot]	820a5e4077	[CI Skip] bump/beta 10.0.3-8-x skip-checks: true	2022-07-18 11:13:19 +00:00
Jaco	bc0f69aef0	Create public/secret pairs on add to keyring (#1602 ) * Create public/secret pairs on add to keyring * Remove comment sort * Adjust pre-compute comment * Adjust tests * Fix expectation	2022-07-18 14:09:38 +03:00
github-actions[bot]	5074adf690	[CI Skip] bump/beta 10.0.3-7-x skip-checks: true	2022-07-18 09:31:32 +00:00
Jaco	8461d105d6	Adjust `nobody` zero-key pair with pre-computed address (#1601 )	2022-07-18 12:27:56 +03:00
github-actions[bot]	cd246e2381	[CI Skip] bump/beta 10.0.3-6-x skip-checks: true	2022-07-17 13:39:12 +00:00
Jaco	8a499bf1bf	Bump ss58registry (#1600 ) * Bump ss58registry * Adjust networks deps	2022-07-17 16:35:42 +03:00
github-actions[bot]	5b2ec8e4d6	[CI Skip] bump/beta 10.0.3-5-x skip-checks: true	2022-07-16 12:44:01 +00:00
Jaco	4a06d1382f	Adjust `isAscii` check to disallow `\t`, `\n`, & `\r` characters (#1599 ) * Adjust `isAscii` check to disallow `\t`, `\n`, & `\r` characters * Readability (& unused code removal) * Only > & <	2022-07-16 15:40:30 +03:00
github-actions[bot]	66ac9e15a6	[CI Skip] bump/beta 10.0.3-4-x skip-checks: true	2022-07-16 08:58:10 +00:00
Jaco	0e55357053	Add arrayUnzip (#1598 )	2022-07-16 11:54:02 +03:00
github-actions[bot]	b4b80bbf67	[CI Skip] bump/beta 10.0.3-3-x skip-checks: true	2022-07-15 08:13:43 +00:00
Jaco	4355b9b066	Bump deps (w/ @noble/secp256k1) (#1597 )	2022-07-15 11:10:00 +03:00
github-actions[bot]	5c92e095ff	[CI Skip] bump/beta 10.0.3-2-x skip-checks: true	2022-07-11 13:35:08 +00:00
Jaco	4fedd594f1	Dedupe sqrt tests between bi/bn (#1596 )	2022-07-11 16:31:41 +03:00
github-actions[bot]	6f05fa6634	[CI Skip] bump/beta 10.0.3-1-x skip-checks: true	2022-07-11 05:19:12 +00:00
Jaco	856e93f4a0	Bump dev (#1595 )	2022-07-11 08:15:26 +03:00
github-actions[bot]	195e42ec11	[CI Skip] bump/beta 10.0.3-0-x skip-checks: true	2022-07-10 08:38:48 +00:00
Jaco	16e90aadfc	Fix .123trigger	2022-07-10 11:35:16 +03:00
github-actions[bot]	bcdf5ba26e	[CI Skip] release/stable 10.0.2 skip-checks: true	2022-07-10 06:28:02 +00:00
Jaco	ae9a04e557	Work-around for Jest + dynamic imports (#1594 ) * Work-around for Jest + dynamic imports * CHANGELOG * 10.0.2	2022-07-10 09:24:11 +03:00
github-actions[bot]	4b37a82fb3	[CI Skip] bump/beta 10.0.2-1-x skip-checks: true	2022-07-08 21:22:55 +00:00
Jaco	1b69bb9dfa	Bump dev deps (#1593 )	2022-07-09 00:19:36 +03:00
github-actions[bot]	e8f703f850	[CI Skip] bump/beta 10.0.2-0-x skip-checks: true	2022-07-08 13:34:11 +00:00
Jaco	3ad4455fe1	Adjust eslint config (#1592 )	2022-07-08 16:30:50 +03:00
github-actions[bot]	1f6a263a8e	[CI Skip] release/stable 10.0.1 skip-checks: true	2022-07-08 05:31:28 +00:00
Jaco	73073529bb	10.0.1 (#1591 )	2022-07-08 08:28:07 +03:00
github-actions[bot]	e1bdac1ba5	[CI Skip] bump/beta 9.7.3-17-x skip-checks: true	2022-07-08 04:47:55 +00:00
Jaco	56c619944c	Bump deps (#1590 ) * Bump deps * Rebump	2022-07-08 07:44:35 +03:00
github-actions[bot]	4c60b98b07	[CI Skip] bump/beta 9.7.3-16-x skip-checks: true	2022-07-07 14:50:24 +00:00
Jaco	2f9f007547	CHANGELOG (#1589 )	2022-07-07 17:46:30 +03:00
github-actions[bot]	d00184fff7	[CI Skip] bump/beta 9.7.3-15-x skip-checks: true	2022-07-07 14:33:54 +00:00
Carlo Sala	e1e3a1699f	feat(networks): add ledger support for Aleph Zero (#1588 )	2022-07-07 17:30:29 +03:00
github-actions[bot]	90a1837978	[CI Skip] bump/beta 9.7.3-14-x skip-checks: true	2022-07-07 07:53:03 +00:00
Jaco	c96ad1a34e	Align BigInt functions with BN (option handling) (#1587 ) * Align BigInt functions with BN (option handling) * CHANGELOG * Pass bitLength parameter	2022-07-07 10:49:40 +03:00
github-actions[bot]	b1eda9efe9	[CI Skip] bump/beta 9.7.3-13-x skip-checks: true	2022-07-07 07:31:23 +00:00
kaelnewandfengwenjun	2184ae8511	add ledger support for stafi (#1569 ) Co-authored-by: fengwenjun <kael@fengwenjun.com>	2022-07-07 10:27:34 +03:00
github-actions[bot]	ce94314992	[CI Skip] bump/beta 9.7.3-12-x skip-checks: true	2022-07-07 07:18:28 +00:00
Jaco	eea3596847	Bump deps (#1586 )	2022-07-07 10:14:14 +03:00
github-actions[bot]	37e78f7abd	[CI Skip] bump/beta 9.7.3-11-x skip-checks: true	2022-07-07 05:35:56 +00:00
Jaco	4bb2c83213	Adjust exports (#1585 )	2022-07-07 08:31:58 +03:00
github-actions[bot]	3828d941a9	[CI Skip] bump/beta 9.7.3-10-x skip-checks: true	2022-07-07 04:57:20 +00:00
Jaco	c92d5cfb20	Remove deprecated call signatures (#1584 )	2022-07-07 07:54:07 +03:00
github-actions[bot]	70d2250b3b	[CI Skip] bump/beta 9.7.3-9-x skip-checks: true	2022-07-06 17:37:27 +00:00
Jakub Pánik	a46279876f	Add HydraDX parachain to genesis (#1583 )	2022-07-06 20:34:05 +03:00
github-actions[bot]	4267c4ac76	[CI Skip] bump/beta 9.7.3-8-x skip-checks: true	2022-07-06 11:04:00 +00:00
Jaco	e09dfcffbe	Adjust issue template (#1582 )	2022-07-06 14:00:36 +03:00
github-actions[bot]	b722291de2	[CI Skip] bump/beta 9.7.3-7-x skip-checks: true	2022-07-06 09:54:00 +00:00
Jaco	4367bb0f68	Adjust for available ESM-only dependencies (#1581 ) * Adjust for available ESM-only dependencies * Flags for jest (sadly, still required mid-2022)	2022-07-06 12:50:36 +03:00
github-actions[bot]	1d71f67e2a	[CI Skip] bump/beta 9.7.3-6-x skip-checks: true	2022-07-05 21:22:56 +00:00
Jaco	2d4995b16e	Additional CI actions (#1580 )	2022-07-06 00:19:30 +03:00
github-actions[bot]	b96cfd36cf	[CI Skip] bump/beta 9.7.3-5-x skip-checks: true	2022-07-05 07:42:41 +00:00
Jaco	9f53838626	Bump dev deps (#1579 )	2022-07-05 10:38:50 +03:00
github-actions[bot]	478dd6ccd9	[CI Skip] bump/beta 9.7.3-4-x skip-checks: true	2022-07-05 07:04:53 +00:00
Jaco	fd313c2e91	Push to deno	2022-07-05 10:01:25 +03:00
github-actions[bot]	66b58ea5f2	[CI Skip] bump/beta 9.7.3-3-x skip-checks: true	2022-07-05 06:59:07 +00:00
Jaco	66acbe04af	Adjust deno exports in x-* (#1578 ) * Adjust deno exports in x-* * Adjust versionDetect	2022-07-05 09:55:57 +03:00
github-actions[bot]	2194cc58d7	[CI Skip] bump/beta 9.7.3-2-x skip-checks: true	2022-07-05 05:38:54 +00:00
Jaco	768f64aec7	Push to deno repo	2022-07-05 08:35:29 +03:00
github-actions[bot]	2176bedd50	[CI Skip] bump/beta 9.7.3-1-x skip-checks: true	2022-07-04 09:38:31 +00:00
Jaco	8273eb5441	Switch on TS isolatedModules (#1577 )	2022-07-04 12:35:03 +03:00
github-actions[bot]	76af1b8822	[CI Skip] bump/beta 9.7.3-0-x skip-checks: true	2022-07-04 07:23:50 +00:00
Jaco	80eb70a382	Adjust some usages to not require @types/node (#1576 )	2022-07-04 10:20:24 +03:00
github-actions[bot]	7e01b2b256	[CI Skip] release/stable 9.7.2 skip-checks: true	2022-07-04 06:15:29 +00:00
Jaco	b30bed8707	9.7.2 (#1575 )	2022-07-04 09:12:22 +03:00
github-actions[bot]	d79813065f	[CI Skip] bump/beta 9.7.2-0-x skip-checks: true	2022-07-04 04:57:36 +00:00
Jaco	7e12949146	Bump deps (#1574 )	2022-07-04 07:54:12 +03:00
github-actions[bot]	5ca6575245	[CI Skip] release/stable 9.7.1 skip-checks: true	2022-07-01 14:45:17 +00:00
Jaco	4cadf3bcb7	9.7.1 (#1572 )	2022-07-01 17:40:21 +03:00
github-actions[bot]	81f8f16b98	[CI Skip] bump/beta 9.6.3-1-x skip-checks: true	2022-06-30 11:38:33 +00:00
Jaco	8edfb1139f	Bump dev deps (#1570 )	2022-06-30 14:35:05 +03:00
github-actions[bot]	69d1d896d1	[CI Skip] bump/beta 9.6.3-0-x skip-checks: true	2022-06-28 07:56:25 +00:00
Jaco	3bc62adf6f	Sprinkle in readonly on array inputs (#1568 )	2022-06-28 10:52:57 +03:00
github-actions[bot]	691a8e9b18	[CI Skip] release/stable 9.6.2 skip-checks: true	2022-06-25 05:26:53 +00:00
Jaco	fc812590e5	Fix `hexToU8a` where `0x` is not correctly converted (#1567 ) * Fix `hexToU8a` where `0x` is not correctly converted * 9.6.2 * CHANGELOG	2022-06-25 08:23:36 +03:00
github-actions[bot]	05499abcd5	[CI Skip] bump/beta 9.6.2-2-x skip-checks: true	2022-06-23 17:05:08 +00:00
Jaco	e375dd8a9d	Bump dev (w/ deno build fix) (#1566 )	2022-06-23 20:01:35 +03:00
github-actions[bot]	3269883e8f	[CI Skip] bump/beta 9.6.2-1-x skip-checks: true	2022-06-23 11:19:10 +00:00
Jaco	c99129ee06	Rebump dev	2022-06-23 14:14:53 +03:00
github-actions[bot]	2514e107bf	[CI Skip] bump/beta 9.6.2-0-x skip-checks: true	2022-06-23 11:08:07 +00:00
Jaco	3c34a0e1f2	Bump dev	2022-06-23 14:04:35 +03:00
github-actions[bot]	f704e371c8	[CI Skip] release/stable 9.6.1 skip-checks: true	2022-06-23 08:14:26 +00:00
Jaco	97e3443e74	9.6.1 (#1565 )	2022-06-23 11:10:14 +03:00
github-actions[bot]	a84e101666	[CI Skip] release/beta 9.5.2-19 skip-checks: true	2022-06-23 07:56:55 +00:00
Jaco	a799918d58	Bump wasm & dev (#1564 )	2022-06-23 10:53:26 +03:00
github-actions[bot]	429390fb62	[CI Skip] release/beta 9.5.2-18 skip-checks: true	2022-06-22 11:38:19 +00:00
Jaco	05d0109b72	Bump dev (w/ 3rd-part from esm.sh) (#1563 )	2022-06-22 14:34:06 +03:00
github-actions[bot]	02b1429979	[CI Skip] release/beta 9.5.2-17 skip-checks: true	2022-06-22 10:46:27 +00:00
Jaco	6e1853d01f	Bump dev (w/ deno ensure filename fixes) (#1562 )	2022-06-22 13:42:58 +03:00
github-actions[bot]	aa9c406d01	[CI Skip] release/beta 9.5.2-16 skip-checks: true	2022-06-22 10:10:41 +00:00
Jaco	f9ec44823d	Added mapping for @noble/secp256k1 to deno.land/x (#1561 )	2022-06-22 13:07:12 +03:00
github-actions[bot]	54218651f9	[CI Skip] release/beta 9.5.2-15 skip-checks: true	2022-06-22 08:56:23 +00:00
Jaco	571c9eff6a	Bump dev (& ignore perf tests on CI) (#1560 )	2022-06-22 11:52:18 +03:00
github-actions[bot]	5b7333b8dd	[CI Skip] release/beta 9.5.2-14 skip-checks: true	2022-06-22 08:17:21 +00:00
Jaco	938fa8b967	Bump dev (w/ publish updates) (#1559 )	2022-06-22 11:13:18 +03:00
github-actions[bot]	b99a69871e	[CI Skip] release/beta 9.5.2-13 skip-checks: true	2022-06-22 06:45:47 +00:00
Jaco	b1da8f575b	Trigger deno build	2022-06-22 09:40:32 +03:00
github-actions[bot]	a960aaf6ae	[CI Skip] release/beta 9.5.2-12 skip-checks: true	2022-06-22 06:34:30 +00:00
Jaco	f88c647ad0	Bump deps (#1558 ) * Bump deps * 3rd party bumps	2022-06-22 09:30:31 +03:00
github-actions[bot]	7ff11925d9	[CI Skip] release/beta 9.5.2-11 skip-checks: true	2022-06-21 13:03:57 +00:00
Jaco	cb5a588489	Bump dev (w/ stable deno publish) (#1557 ) * Bump dev (w/ stable deno publish) * Adjust * Bump dev	2022-06-21 15:59:46 +03:00
github-actions[bot]	09019224e3	[CI Skip] release/beta 9.5.2-10 skip-checks: true	2022-06-21 04:49:51 +00:00
Jaco	2d7031831a	Bump TS to 4.7.4 (#1556 )	2022-06-21 07:44:57 +03:00
github-actions[bot]	faf7ea2b17	[CI Skip] release/beta 9.5.2-9 skip-checks: true	2022-06-21 03:32:33 +00:00
Jaco	af973de694	Bump deps (#1555 )	2022-06-21 06:28:19 +03:00
github-actions[bot]	dfede866b2	[CI Skip] release/beta 9.5.2-8 skip-checks: true	2022-06-20 14:11:41 +00:00
Jaco	0f0b243815	Adjust isNull & isUndefined checks (#1554 )	2022-06-20 17:06:35 +03:00
github-actions[bot]	29f53fe906	[CI Skip] release/beta 9.5.2-7 skip-checks: true	2022-06-20 13:30:11 +00:00
Jaco	225c250634	Adjust asserts (#1548 ) * Adjust asserts * Fix linting & build	2022-06-20 16:26:07 +03:00
github-actions[bot]	c871e9d735	[CI Skip] release/beta 9.5.2-6 skip-checks: true	2022-06-20 10:19:45 +00:00
Jaco	b42ead28e5	Optimize isAsicc check (#1553 )	2022-06-20 13:15:00 +03:00
github-actions[bot]	db0581c051	[CI Skip] release/beta 9.5.2-5 skip-checks: true	2022-06-20 08:54:49 +00:00
Jaco	e7ac095ace	Slight improvment to hexToU8a (#1552 )	2022-06-20 11:49:41 +03:00
github-actions[bot]	a7d9fc48e9	[CI Skip] release/beta 9.5.2-4 skip-checks: true	2022-06-20 08:34:19 +00:00
Jaco	3db2990ce7	Change Date.now() to performance.now() (#1551 ) * Change Date.now() to performance.now() * Adjust	2022-06-20 11:29:59 +03:00
github-actions[bot]	4b7cda243b	[CI Skip] release/beta 9.5.2-3 skip-checks: true	2022-06-20 05:13:47 +00:00
Jaco	c4ceeb8382	Additional float conversion tests (#1550 )	2022-06-20 08:09:51 +03:00
github-actions[bot]	540971d388	[CI Skip] release/beta 9.5.2-2 skip-checks: true	2022-06-19 18:33:38 +00:00
Jaco	b4d65a1c49	floatToU8a adjustment (#1549 )	2022-06-19 21:29:34 +03:00
github-actions[bot]	4fd4660853	[CI Skip] release/beta 9.5.2-1 skip-checks: true	2022-06-19 07:22:23 +00:00
Jaco	4b46c179b2	floatToU8a & u8aToFloat (#1547 ) * floatToU8a & u8aToFloat * test for asserts	2022-06-19 10:17:35 +03:00
github-actions[bot]	3c6d297ecd	[CI Skip] release/beta 9.5.2-0 skip-checks: true	2022-06-18 18:37:12 +00:00
Jaco	4a6e620acc	Adjust isUndefined check (#1546 )	2022-06-18 21:33:19 +03:00