[CI Skip] release/stable 12.2.1

skip-checks: true

.github/workflows/lock.yml

@@ -13,13 +13,13 @@ jobs:
       - uses: dessant/lock-threads@c1b35aecc5cdb1a34539d14196df55838bb2f836
         with:
           github-token: ${{ secrets.GH_PAT_BOT }}
-          issue-lock-inactive-days: '7'
-          issue-lock-comment: >
+          issue-inactive-days: '7'
+          issue-comment: >
             This thread has been automatically locked since there has not been
             any recent activity after it was closed. Please open a new issue
             if you think you have a related problem or query.
-          pr-lock-inactive-days: '2'
-          pr-lock-comment: >
+          pr-inactive-days: '2'
+          pr-comment: >
             This pull request has been automatically locked since there
             has not been any recent activity after it was closed.
             Please open a new issue for related bugs.

CHANGELOG.md

@@ -1,5 +1,52 @@
 # CHANGELOG
 
+## 12.2.1 May 13, 2023
+
+Changes:
+
+- Align `u8aToBigInt` tests with `u8aToBn`
+- Unroll loops on most-frequently used paths for `u8aToBigInt`
+- Add `module` to `package.json` export map (ESM-only)
+- Upgrade dependencies to latest stable versions
+
+
+## 12.1.2 May 1, 2023
+
+Changes:
+
+- Adjust typing for `isChildClass` & `Constructor` usage
+
+
+## 12.1.1 Apr 29, 2023
+
+Changes:
+
+- Add shareable `identity` & `noop` functions
+- Flatten `Buffer | Uint8Array` types (as used) to base-only `Uint8Array`
+- Apply `readonly` specifiers to private class fields where applicable
+- Adjust compilation output for `__internal__` class fields
+- Remove unused types from `util`
+- Upgrade dependencies to latest stable versions
+
+
+## 12.0.1 Apr 22, 2023
+
+Contributed:
+
+- Add Cere genesisHash (Thanks to https://github.com/shamilkhan)
+
+Changes:
+
+- Swap secp256k1 functionality to `@noble/curves`
+- Swap ed25519 functionality to `@noble/curves`
+- Replace `tweetnacl` secretbox usage with slimmer local version
+- Adjust `isCodec` helper with closer API alignment
+- Initial steps to multi-language bip39 support
+- Use Node webcrypto for Node `getRandomValues` support
+- Upgrade dependencies to latest stable versions
+- Drop support for Node 14 (EOL 30 Apr 2023)
+
+
 ## 11.1.3 Apr 1, 2023
 
 Contributed:

CONTRIBUTORS

@@ -1,4 +1,4 @@
-    1577	Jaco                          	11.1.3 (#1789)
+    1613	Jaco                          	12.2.1 (#1829)
       12	Carlo Sala                    	feat(networks): support ledger for pendulum (#1739)
        9	Antoine Estienne              	Add eth uri keyring test (#1291)
        6	Amaury Martiny                	Add tests from Rust (#283)
@@ -48,6 +48,7 @@
        1	Raymond Zhong                 	Add Edgeware ledger app (#1006)
        1	Reto Trinkler                 	Adding 4 as address type of ss58 for Katal Chain (#639)
        1	Rocco Musolino                	remove doc broken link (#697)
+       1	Shamilkhan                    	Add genesis hash for Cere Network (#1806)
        1	Song Zhou                     	Add in ability to encrypt/decrypt msg with keyring (#1070)
        1	Thibaut Sardan                	add hasLedgerSupport prop to networks (#835)
        1	Tomokazu Kozuma               	fix comment (#1119)

package.json

@@ -14,10 +14,10 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "11.1.3",
+  "version": "12.2.1",
   "versions": {
-    "git": "11.1.3",
-    "npm": "11.1.3"
+    "git": "12.2.1",
+    "npm": "12.2.1"
   },
   "workspaces": [
     "packages/*"
@@ -37,10 +37,10 @@
     "test:one": "polkadot-dev-run-test --env browser"
   },
   "devDependencies": {
-    "@polkadot/dev": "^0.72.29",
-    "@types/node": "^18.15.11"
+    "@polkadot/dev": "^0.73.17",
+    "@types/node": "^20.1.3"
   },
   "resolutions": {
-    "typescript": "^5.0.3"
+    "typescript": "^5.0.4"
   }
 }

packages/hw-ledger-transports/package.json

@@ -2,7 +2,7 @@
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "bugs": "https://github.com/polkadot-js/common/issues",
   "engines": {
-    "node": ">=14"
+    "node": ">=16"
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/hw-ledger-transports#readme",
   "license": "Apache-2.0",
@@ -14,18 +14,18 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "11.1.3",
+  "version": "12.2.1",
   "browser": "browser.js",
   "main": "node.js",
   "react-native": "react-native.js",
   "dependencies": {
-    "@ledgerhq/hw-transport": "^6.28.1",
-    "@ledgerhq/hw-transport-webhid": "^6.27.12",
-    "@ledgerhq/hw-transport-webusb": "^6.27.12",
-    "@polkadot/util": "11.1.3",
+    "@ledgerhq/hw-transport": "^6.28.3",
+    "@ledgerhq/hw-transport-webhid": "^6.27.14",
+    "@ledgerhq/hw-transport-webusb": "^6.27.14",
+    "@polkadot/util": "12.2.1",
     "tslib": "^2.5.0"
   },
   "optionalDependencies": {
-    "@ledgerhq/hw-transport-node-hid-singleton": "^6.28.9"
+    "@ledgerhq/hw-transport-node-hid-singleton": "^6.28.11"
   }
 }

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

@@ -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: '11.1.3' };
+export const packageInfo = { name: '@polkadot/hw-ledger-transports', path: 'auto', type: 'auto', version: '12.2.1' };

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

@@ -1,20 +1,13 @@
 // Copyright 2017-2023 @polkadot/hw-ledger authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+// CJS, so we use import * syntax
+import type * as HwTransport from '@ledgerhq/hw-transport';
+
 // u2f is deprecated an therefore not added
 export type TransportType = 'hid' | 'webusb';
 
-// The actual namespaced Transport interface, imported via
-//
-//   import type Transport from '@ledgerhq/hw-transport';
-//
-// does not work on moduleResolution: nodenext, so we just go with a
-// very light interface for Transport (and then TransportStatic).
-
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface Transport {
-  // empty on purpose, just a stub
-}
+export type Transport = HwTransport.default;
 
 export interface TransportDef {
   /** Create a transport to be used in Ledger operations */

packages/hw-ledger/package.json

@@ -2,7 +2,7 @@
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "bugs": "https://github.com/polkadot-js/common/issues",
   "engines": {
-    "node": ">=14"
+    "node": ">=16"
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/hw-ledger#readme",
   "license": "Apache-2.0",
@@ -17,12 +17,12 @@
     "./detectPackage.cjs"
   ],
   "type": "module",
-  "version": "11.1.3",
+  "version": "12.2.1",
   "main": "index.js",
   "dependencies": {
-    "@polkadot/hw-ledger-transports": "11.1.3",
-    "@polkadot/util": "11.1.3",
-    "@zondax/ledger-substrate": "^0.40.6",
+    "@polkadot/hw-ledger-transports": "12.2.1",
+    "@polkadot/util": "12.2.1",
+    "@zondax/ledger-substrate": "^0.40.7",
     "tslib": "^2.5.0"
   }
 }

packages/hw-ledger/src/bundle.ts

@@ -30,16 +30,20 @@ async function wrapError <T extends WrappedResult> (promise: Promise<T>): Promis
   return result;
 }
 
-// A very basic wrapper for a ledger app -
-//  - it connects automatically, creating an app as required
-//  - Promises return errors (instead of wrapper errors)
+/**
+ * @name Ledger
+ *
+ * @description
+ * A very basic wrapper for a ledger app -
+ *   - it connects automatically on use, creating an underlying interface as required
+ *   - Promises reject with errors (unwrapped errors from @zondax/ledger-substrate)
+ */
 export class Ledger {
+  readonly #ledgerName: string;
+  readonly #transportDef: TransportDef;
+
   #app: SubstrateApp | null = null;
 
-  #ledgerName: string;
-
-  #transportDef: TransportDef;
-
   constructor (transport: TransportType, chain: Chain) {
     const ledgerName = ledgerApps[chain];
     const transportDef = transports.find(({ type }) => type === transport);
@@ -85,7 +89,7 @@ export class Ledger {
   }
 
   /**
-   * Signs a transcation on the Ledger device
+   * Signs a transaction on the Ledger device
    */
   public async sign (message: Uint8Array, accountOffset = 0, addressOffset = 0, { account = LEDGER_DEFAULT_ACCOUNT, addressIndex = LEDGER_DEFAULT_INDEX, change = LEDGER_DEFAULT_CHANGE }: Partial<AccountOptions> = {}): Promise<LedgerSignature> {
     return this.withApp(async (app: SubstrateApp): Promise<LedgerSignature> => {

packages/hw-ledger/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Do not edit, auto-generated by @polkadot/dev
 
-export const packageInfo = { name: '@polkadot/hw-ledger', path: 'auto', type: 'auto', version: '11.1.3' };
+export const packageInfo = { name: '@polkadot/hw-ledger', path: 'auto', type: 'auto', version: '12.2.1' };

packages/keyring/package.json

@@ -3,7 +3,7 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "description": "Keyring management",
   "engines": {
-    "node": ">=14"
+    "node": ">=16"
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/keyring#readme",
   "license": "Apache-2.0",
@@ -18,15 +18,15 @@
     "./detectPackage.cjs"
   ],
   "type": "module",
-  "version": "11.1.3",
+  "version": "12.2.1",
   "main": "index.js",
   "dependencies": {
-    "@polkadot/util": "11.1.3",
-    "@polkadot/util-crypto": "11.1.3",
+    "@polkadot/util": "12.2.1",
+    "@polkadot/util-crypto": "12.2.1",
     "tslib": "^2.5.0"
   },
   "peerDependencies": {
-    "@polkadot/util": "11.1.3",
-    "@polkadot/util-crypto": "11.1.3"
+    "@polkadot/util": "12.2.1",
+    "@polkadot/util-crypto": "12.2.1"
   }
 }

packages/keyring/src/bundle.ts

@@ -1,16 +1,16 @@
 // Copyright 2017-2023 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { Keyring } from './keyring.js';
-
+// all external
 // eslint-disable-next-line deprecation/deprecation
 export { decodeAddress, encodeAddress, setSS58Format } from '@polkadot/util-crypto';
 
-export * from './defaults.js';
-
-export { createPair } from './pair/index.js';
+// all named
+export { Keyring } from './keyring.js';
 export { packageInfo } from './packageInfo.js';
+export { createPair } from './pair/index.js';
 export { createTestKeyring } from './testing.js';
 export { createTestPairs } from './testingPairs.js';
 
-export { Keyring };
+// all starred
+export * from './defaults.js';

packages/keyring/src/keyring.ts

@@ -43,7 +43,7 @@ export class Keyring implements KeyringInstance {
 
   readonly #type: KeypairType;
 
-  #ss58?: number;
+  #ss58?: number | undefined;
 
   public decodeAddress = decodeAddress;
 
@@ -246,7 +246,7 @@ export class Keyring implements KeyringInstance {
   public encodeAddress = (address: Uint8Array | string, ss58Format?: number): string => {
     return this.type === 'ethereum'
       ? ethereumEncode(address)
-      : encodeAddress(address, ss58Format === undefined ? this.#ss58 : ss58Format);
+      : encodeAddress(address, ss58Format ?? this.#ss58);
   };
 
   /**

packages/keyring/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Do not edit, auto-generated by @polkadot/dev
 
-export const packageInfo = { name: '@polkadot/keyring', path: 'auto', type: 'auto', version: '11.1.3' };
+export const packageInfo = { name: '@polkadot/keyring', path: 'auto', type: 'auto', version: '12.2.1' };

packages/keyring/src/pair/types.ts

@@ -3,6 +3,6 @@
 
 export interface PairInfo {
   publicKey: Uint8Array;
-  secretKey?: Uint8Array;
+  secretKey?: Uint8Array | undefined;
   seed?: Uint8Array | null;
 }

packages/networks/package.json

@@ -3,7 +3,7 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "description": "A list of all available Substrate networks and their applicable prefixes",
   "engines": {
-    "node": ">=14"
+    "node": ">=16"
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/networks#readme",
   "license": "Apache-2.0",
@@ -15,14 +15,14 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "11.1.3",
+  "version": "12.2.1",
   "main": "index.js",
   "dependencies": {
-    "@polkadot/util": "11.1.3",
-    "@substrate/ss58-registry": "^1.39.0",
+    "@polkadot/util": "12.2.1",
+    "@substrate/ss58-registry": "^1.40.0",
     "tslib": "^2.5.0"
   },
   "devDependencies": {
-    "@polkadot/hw-ledger": "11.1.3"
+    "@polkadot/hw-ledger": "12.2.1"
   }
 }

packages/networks/src/defaults/genesis.ts

@@ -36,6 +36,9 @@ export const knownGenesis: KnownGenesis = {
     '0xb3db41421702df9a7fcac62b53ffeac85f7853cc4e689e0b93aeb3db18c09d82',
     '0x67dddf2673b69e5f875f6f25277495834398eafd67f492e09f3f3345e003d1b5'
   ],
+  cere: [
+    '0x81443836a9a24caaa23f1241897d1235717535711d1d3fe24eae4fdc942c092c'
+  ],
   composable: [
     '0xdaab8df776eb52ec604a5df5d388bb62a050a0aaec4556a64265b9d42755552d'
   ],

packages/networks/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Do not edit, auto-generated by @polkadot/dev
 
-export const packageInfo = { name: '@polkadot/networks', path: 'auto', type: 'auto', version: '11.1.3' };
+export const packageInfo = { name: '@polkadot/networks', path: 'auto', type: 'auto', version: '12.2.1' };

packages/networks/src/test/ss58registry.test.json

@@ -597,7 +597,7 @@
   {
     "prefix": 50,
     "network": "composable",
-    "displayName": "Composable",
+    "displayName": "Composable Finance",
     "symbols": [
       "LAYR"
     ],
@@ -716,7 +716,7 @@
   {
     "prefix": 65,
     "network": "aventus",
-    "displayName": "AvN Mainnet",
+    "displayName": "Aventus Mainnet",
     "symbols": [
       "AVT"
     ],
@@ -1337,6 +1337,19 @@
     "standardAccount": "*25519",
     "website": "https://explorer.mainnet.cloudwalk.io"
   },
+  {
+    "prefix": 2021,
+    "network": "logion",
+    "displayName": "logion network",
+    "symbols": [
+      "LGNT"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://logion.network"
+  },
   {
     "prefix": 2032,
     "network": "interlay",
@@ -1640,6 +1653,19 @@
     "standardAccount": "*25519",
     "website": "https://ata.network"
   },
+  {
+    "prefix": 12155,
+    "network": "impact",
+    "displayName": "Impact Protocol Network",
+    "symbols": [
+      "BSTY"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://impactprotocol.network/"
+  },
   {
     "prefix": 12191,
     "network": "nftmart",

packages/util-crypto/package.json

@@ -3,7 +3,7 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "description": "A collection of useful crypto utilities for @polkadot",
   "engines": {
-    "node": ">=14"
+    "node": ">=16"
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util-crypto#readme",
   "license": "Apache-2.0",
@@ -20,25 +20,25 @@
     "./detectPackage.cjs"
   ],
   "type": "module",
-  "version": "11.1.3",
+  "version": "12.2.1",
   "browser": {
     "crypto": false,
     "stream": false
   },
   "main": "index.js",
   "dependencies": {
+    "@noble/curves": "1.0.0",
     "@noble/hashes": "1.3.0",
-    "@noble/secp256k1": "1.7.1",
-    "@polkadot/networks": "11.1.3",
-    "@polkadot/util": "11.1.3",
-    "@polkadot/wasm-crypto": "^7.0.3",
-    "@polkadot/x-bigint": "11.1.3",
-    "@polkadot/x-randomvalues": "11.1.3",
+    "@polkadot/networks": "12.2.1",
+    "@polkadot/util": "12.2.1",
+    "@polkadot/wasm-crypto": "^7.2.1",
+    "@polkadot/wasm-util": "^7.2.1",
+    "@polkadot/x-bigint": "12.2.1",
+    "@polkadot/x-randomvalues": "12.2.1",
     "@scure/base": "1.1.1",
-    "tslib": "^2.5.0",
-    "tweetnacl": "^1.0.3"
+    "tslib": "^2.5.0"
   },
   "peerDependencies": {
-    "@polkadot/util": "11.1.3"
+    "@polkadot/util": "12.2.1"
   }
 }

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

@@ -4,16 +4,16 @@
 export { addressToEvm } from './addressToEvm.js';
 export { checkAddress } from './check.js';
 export { checkAddressChecksum } from './checksum.js';
-export { createKeyMulti } from './keyMulti.js';
-export { createKeyDerived } from './keyDerived.js';
 export { decodeAddress } from './decode.js';
 export { deriveAddress } from './derive.js';
 export { encodeAddress } from './encode.js';
 export { encodeDerivedAddress } from './encodeDerived.js';
 export { encodeMultiAddress } from './encodeMulti.js';
-export { evmToAddress } from './evmToAddress.js';
 export { addressEq } from './eq.js';
+export { evmToAddress } from './evmToAddress.js';
 export { isAddress } from './is.js';
+export { createKeyDerived } from './keyDerived.js';
+export { createKeyMulti } from './keyMulti.js';
 export { sortAddresses } from './sort.js';
 export { validateAddress } from './validate.js';
 

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

@@ -30,7 +30,9 @@ export function blake2AsU8a (data: HexString | Uint8Array | string, bitLength: 6
 
   return !hasBigInt || (!onlyJs && isReady())
     ? blake2b(u8a, u8aToU8a(key), byteLength)
-    : blake2bJs(u8a, { dkLen: byteLength, key: key || undefined });
+    : key
+      ? blake2bJs(u8a, { dkLen: byteLength, key })
+      : blake2bJs(u8a, { dkLen: byteLength });
 }
 
 /**

packages/util-crypto/src/bundle.ts

@@ -3,9 +3,10 @@
 
 import './bundleInit.js';
 
+// all named
 export { packageInfo } from './packageInfo.js';
 
-// all internal exports
+// all starred
 export * from './address/index.js';
 export * from './base32/index.js';
 export * from './base58/index.js';
@@ -20,8 +21,8 @@ export * from './json/index.js';
 export * from './keccak/index.js';
 export * from './key/index.js';
 export * from './mnemonic/index.js';
-export * from './networks.js';
 export * from './nacl/index.js';
+export * from './networks.js';
 export * from './pbkdf2/index.js';
 export * from './random/index.js';
 export * from './scrypt/index.js';

packages/util-crypto/src/bundleInit.ts

@@ -3,18 +3,8 @@
 
 import '@polkadot/x-bigint/shim';
 
-import { utils as utilsNobleSecp256k1 } from '@noble/secp256k1';
-
-import { u8aConcat } from '@polkadot/util';
-
-import { hmacSha256AsU8a } from './hmac/index.js';
 import { cryptoWaitReady } from './crypto.js';
 
-// Set overrides on the secp256k1 utils
-//   - hmacShaSync - This needs to be set, unset by default
-utilsNobleSecp256k1.hmacSha256Sync = (key: Uint8Array, ...messages: Uint8Array[]) =>
-  hmacSha256AsU8a(key, u8aConcat(...messages));
-
 // start init process immediately
 cryptoWaitReady().catch((): void => {
   // shouldn't happen, logged and caught inside cryptoWaitReady

packages/util-crypto/src/ed25519/pair/fromSecret.ts

@@ -3,8 +3,6 @@
 
 import type { Keypair } from '../../types.js';
 
-import nacl from 'tweetnacl';
-
 /**
  * @name ed25519PairFromSecret
  * @summary Creates a new public/secret keypair from a secret.
@@ -19,6 +17,13 @@ import nacl from 'tweetnacl';
  * ed25519PairFromSecret(...); // => { secretKey: [...], publicKey: [...] }
  * ```
  */
-export function ed25519PairFromSecret (secret: Uint8Array): Keypair {
-  return nacl.sign.keyPair.fromSecretKey(secret);
+export function ed25519PairFromSecret (secretKey: Uint8Array): Keypair {
+  if (secretKey.length !== 64) {
+    throw new Error('Invalid secretKey provided');
+  }
+
+  return {
+    publicKey: secretKey.slice(32),
+    secretKey
+  };
 }

packages/util-crypto/src/ed25519/pair/fromSeed.ts

@@ -3,8 +3,9 @@
 
 import type { Keypair } from '../../types.js';
 
-import nacl from 'tweetnacl';
+import { ed25519 } from '@noble/curves/ed25519';
 
+import { hasBigInt, u8aConcatStrict } from '@polkadot/util';
 import { ed25519KeypairFromSeed, isReady } from '@polkadot/wasm-crypto';
 
 /**
@@ -22,7 +23,7 @@ import { ed25519KeypairFromSeed, isReady } from '@polkadot/wasm-crypto';
  * ```
  */
 export function ed25519PairFromSeed (seed: Uint8Array, onlyJs?: boolean): Keypair {
-  if (!onlyJs && isReady()) {
+  if (!hasBigInt || (!onlyJs && isReady())) {
     const full = ed25519KeypairFromSeed(seed);
 
     return {
@@ -31,5 +32,10 @@ export function ed25519PairFromSeed (seed: Uint8Array, onlyJs?: boolean): Keypai
     };
   }
 
-  return nacl.sign.keyPair.fromSeed(seed);
+  const publicKey = ed25519.getPublicKey(seed);
+
+  return {
+    publicKey,
+    secretKey: u8aConcatStrict([seed, publicKey])
+  };
 }

packages/util-crypto/src/ed25519/sign.ts

@@ -4,9 +4,9 @@
 import type { HexString } from '@polkadot/util/types';
 import type { Keypair } from '../types.js';
 
-import nacl from 'tweetnacl';
+import { ed25519 } from '@noble/curves/ed25519';
 
-import { u8aToU8a } from '@polkadot/util';
+import { hasBigInt, u8aToU8a } from '@polkadot/util';
 import { ed25519Sign as wasmSign, isReady } from '@polkadot/wasm-crypto';
 
 /**
@@ -26,11 +26,14 @@ import { ed25519Sign as wasmSign, isReady } from '@polkadot/wasm-crypto';
 export function ed25519Sign (message: HexString | Uint8Array | string, { publicKey, secretKey }: Partial<Keypair>, onlyJs?: boolean): Uint8Array {
   if (!secretKey) {
     throw new Error('Expected a valid secretKey');
+  } else if (!publicKey) {
+    throw new Error('Expected a valid publicKey');
   }
 
   const messageU8a = u8aToU8a(message);
+  const privateU8a = secretKey.subarray(0, 32);
 
-  return !onlyJs && isReady()
-    ? wasmSign(publicKey as Uint8Array, secretKey.subarray(0, 32), messageU8a)
-    : nacl.sign.detached(messageU8a, secretKey);
+  return !hasBigInt || (!onlyJs && isReady())
+    ? wasmSign(publicKey, privateU8a, messageU8a)
+    : ed25519.sign(messageU8a, privateU8a);
 }

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

@@ -3,9 +3,9 @@
 
 import type { HexString } from '@polkadot/util/types';
 
-import nacl from 'tweetnacl';
+import { ed25519 } from '@noble/curves/ed25519';
 
-import { u8aToU8a } from '@polkadot/util';
+import { hasBigInt, u8aToU8a } from '@polkadot/util';
 import { ed25519Verify as wasmVerify, isReady } from '@polkadot/wasm-crypto';
 
 /**
@@ -33,7 +33,11 @@ export function ed25519Verify (message: HexString | Uint8Array | string, signatu
     throw new Error(`Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
   }
 
-  return !onlyJs && isReady()
-    ? wasmVerify(signatureU8a, messageU8a, publicKeyU8a)
-    : nacl.sign.detached.verify(messageU8a, signatureU8a, publicKeyU8a);
+  try {
+    return !hasBigInt || (!onlyJs && isReady())
+      ? wasmVerify(signatureU8a, messageU8a, publicKeyU8a)
+      : ed25519.verify(signatureU8a, messageU8a, publicKeyU8a);
+  } catch {
+    return false;
+  }
 }

packages/util-crypto/src/helpers.ts

@@ -21,14 +21,14 @@ export function createAsHex <T extends (...args: never[]) => Uint8Array> (fn: T)
 }
 
 /** @internal */
-export function createBitHasher (bitLength: 256 | 512, fn: (data: HexString | Buffer | Uint8Array | string, bitLength: 256 | 512, onlyJs?: boolean) => Uint8Array): (data: HexString | Buffer | Uint8Array | string, onlyJs?: boolean) => Uint8Array {
-  return (data: HexString | Buffer | Uint8Array | string, onlyJs?: boolean): Uint8Array =>
+export function createBitHasher (bitLength: 256 | 512, fn: (data: HexString | Uint8Array | string, bitLength: 256 | 512, onlyJs?: boolean) => Uint8Array): (data: HexString | Uint8Array | string, onlyJs?: boolean) => Uint8Array {
+  return (data: HexString | Uint8Array | string, onlyJs?: boolean): Uint8Array =>
     fn(data, bitLength, onlyJs);
 }
 
 /** @internal */
-export function createDualHasher (wa: DualHash, js: DualHash): (value: HexString | Buffer | Uint8Array | string, bitLength?: 256 | 512, onlyJs?: boolean) => Uint8Array {
-  return (value: HexString | Buffer | Uint8Array | string, bitLength: 256 | 512 = 256, onlyJs?: boolean): Uint8Array => {
+export function createDualHasher (wa: DualHash, js: DualHash): (value: HexString | Uint8Array | string, bitLength?: 256 | 512, onlyJs?: boolean) => Uint8Array {
+  return (value: HexString | Uint8Array | string, bitLength: 256 | 512 = 256, onlyJs?: boolean): Uint8Array => {
     const u8a = u8aToU8a(value);
 
     return !hasBigInt || (!onlyJs && isReady())

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

@@ -1,4 +1,4 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export { hmacShaAsU8a, hmacSha256AsU8a, hmacSha512AsU8a } from './shaAsU8a.js';
+export { hmacSha256AsU8a, hmacSha512AsU8a, hmacShaAsU8a } from './shaAsU8a.js';

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

@@ -5,4 +5,4 @@
  * @summary Create Keccak256/512 values as hex & Uint8Array output
  */
 
-export { keccakAsHex, keccakAsU8a, keccak256AsU8a, keccak512AsU8a } from './asU8a.js';
+export { keccak256AsU8a, keccak512AsU8a, keccakAsHex, keccakAsU8a } from './asU8a.js';

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

@@ -3,7 +3,9 @@
 
 /// <reference types="@polkadot/dev-test/globals.d.ts" />
 
-import { ExtractResult, keyExtractPath } from './extractPath.js';
+import type { ExtractResult } from './extractPath.js';
+
+import { keyExtractPath } from './extractPath.js';
 
 describe('keyExtractPath', (): void => {
   it('extracts properly from soft', (): void => {

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

@@ -3,7 +3,9 @@
 
 /// <reference types="@polkadot/dev-test/globals.d.ts" />
 
-import { ExtractResult, keyExtractSuri } from './extractSuri.js';
+import type { ExtractResult } from './extractSuri.js';
+
+import { keyExtractSuri } from './extractSuri.js';
 
 describe('keyExtractSuri', (): void => {
   it('does not extract from invalid suri', (): void => {

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

@@ -1,7 +1,8 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { DeriveJunction } from './DeriveJunction.js';
+import type { DeriveJunction } from './DeriveJunction.js';
+
 import { keyExtractPath } from './extractPath.js';
 
 export interface ExtractResult {

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

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { Keypair, KeypairType } from '../types.js';
+import type { DeriveJunction } from './DeriveJunction.js';
 
-import { DeriveJunction } from './DeriveJunction.js';
 import { keyHdkdEcdsa } from './hdkdEcdsa.js';
 import { keyHdkdEd25519 } from './hdkdEd25519.js';
 import { keyHdkdSr25519 } from './hdkdSr25519.js';

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

@@ -2,8 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { Keypair } from '../types.js';
-
-import { DeriveJunction } from './DeriveJunction.js';
+import type { DeriveJunction } from './DeriveJunction.js';
 
 export function createSeedDeriveFn (fromSeed: (seed: Uint8Array) => Keypair, derive: (seed: Uint8Array, chainCode: Uint8Array) => Uint8Array): (keypair: Keypair, junction: DeriveJunction) => Keypair {
   return (keypair: Keypair, { chainCode, isHard }: DeriveJunction): Keypair => {

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

@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { Keypair } from '../types.js';
+import type { DeriveJunction } from './DeriveJunction.js';
 
 import { sr25519DeriveHard } from '../sr25519/deriveHard.js';
 import { sr25519DeriveSoft } from '../sr25519/deriveSoft.js';
-import { DeriveJunction } from './DeriveJunction.js';
 
 export function keyHdkdSr25519 (keypair: Keypair, { chainCode, isSoft }: DeriveJunction): Keypair {
   return isSoft

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

@@ -7,6 +7,6 @@
 export { keyExtractPath } from './extractPath.js';
 export { keyExtractSuri } from './extractSuri.js';
 export { keyFromPath } from './fromPath.js';
+export { keyHdkdEcdsa } from './hdkdEcdsa.js';
 export { keyHdkdEd25519 } from './hdkdEd25519.js';
 export { keyHdkdSr25519 } from './hdkdSr25519.js';
-export { keyHdkdEcdsa } from './hdkdEcdsa.js';

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

@@ -3,25 +3,78 @@
 
 /// <reference types="@polkadot/dev-test/globals.d.ts" />
 
-import { entropyToMnemonic, mnemonicToEntropy } from './bip39.js';
-import DEFAULT_WORDLIST from './bip39-en.js';
+import * as lists from './wordlists/index.js';
+import { entropyToMnemonic, generateMnemonic, mnemonicToEntropy, validateMnemonic } from './bip39.js';
 
-describe('wordlist', (): void => {
-  it('has the correct number of words', (): void => {
-    expect(DEFAULT_WORDLIST).toHaveLength(2048);
-  });
+describe('wordlists', (): void => {
+  for (const [lang, words] of Object.entries(lists)) {
+    describe(`language ${lang}`, (): void => {
+      it('has the correct number of words', (): void => {
+        expect(words).toHaveLength(2048);
+      });
 
-  it('has no empty words', (): void => {
-    expect(DEFAULT_WORDLIST.some((n) => !n.length || n.trim() !== n)).toEqual(false);
-  });
+      it('has no empty words', (): void => {
+        expect(
+          words.some((w) => !w.length || w.trim() !== w)
+        ).toEqual(false);
+      });
+    });
+  }
 });
 
 describe('bip39', (): void => {
-  it('has a two-way entropy <-> mnemonic', (): void => {
-    const m = 'seed sock milk update focus rotate barely fade car face mechanic mercy';
+  const m = 'seed sock milk update focus rotate barely fade car face mechanic mercy';
+  const e = mnemonicToEntropy(m);
 
+  it('generates a known entropy', (): void => {
+    expect(e).toEqual(
+      new Uint8Array([194, 249, 194, 50, 119, 69, 163, 120, 68, 162, 142, 34, 74, 50, 40, 197])
+    );
+  });
+
+  it('has a two-way entropy <-> mnemonic (default wordlist)', (): void => {
     expect(
-      entropyToMnemonic(mnemonicToEntropy(m))
+      entropyToMnemonic(mnemonicToEntropy(entropyToMnemonic(e)))
     ).toEqual(m);
   });
+
+  for (const [lang, words] of Object.entries(lists)) {
+    const isUsingList = (test: string, length = 12): void => {
+      const split = test.split(' ');
+
+      expect(
+        split
+      ).toHaveLength(length);
+      expect(
+        split.some((w) => words.indexOf(w) === -1)
+      ).toEqual(false);
+    };
+
+    describe(`language ${lang}`, (): void => {
+      it('has a two-way entropy <-> mnemonic', (): void => {
+        const test = entropyToMnemonic(e, words);
+        const entr = mnemonicToEntropy(test, words);
+
+        isUsingList(test);
+
+        expect(
+          entr
+        ).toEqual(e);
+
+        expect(
+          entropyToMnemonic(entr, words)
+        ).toEqual(test);
+      });
+
+      it('generates a valid mnemonic', (): void => {
+        const test = generateMnemonic(24, words);
+
+        isUsingList(test, 24);
+
+        expect(
+          validateMnemonic(test, words)
+        ).toEqual(true);
+      });
+    });
+  }
 });

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

@@ -19,24 +19,28 @@ import { stringToU8a, u8aToU8a } from '@polkadot/util';
 import { pbkdf2Encode } from '../pbkdf2/index.js';
 import { randomAsU8a } from '../random/index.js';
 import { sha256AsU8a } from '../sha/index.js';
-import DEFAULT_WORDLIST from './bip39-en.js';
+import DEFAULT_WORDLIST from './wordlists/en.js';
 
 const INVALID_MNEMONIC = 'Invalid mnemonic';
 const INVALID_ENTROPY = 'Invalid entropy';
 const INVALID_CHECKSUM = 'Invalid mnemonic checksum';
 
+/** @internal */
 function normalize (str?: string): string {
   return (str || '').normalize('NFKD');
 }
 
+/** @internal */
 function binaryToByte (bin: string): number {
   return parseInt(bin, 2);
 }
 
+/** @internal */
 function bytesToBinary (bytes: number[]): string {
   return bytes.map((x) => x.toString(2).padStart(8, '0')).join('');
 }
 
+/** @internal */
 function deriveChecksumBits (entropyBuffer: Uint8Array): string {
   return bytesToBinary(
     Array.from(sha256AsU8a(entropyBuffer))
@@ -50,7 +54,7 @@ export function mnemonicToSeedSync (mnemonic: string, password?: string): Uint8A
   ).password;
 }
 
-export function mnemonicToEntropy (mnemonic: string): Uint8Array {
+export function mnemonicToEntropy (mnemonic: string, wordlist: string[] = DEFAULT_WORDLIST): Uint8Array {
   const words = normalize(mnemonic).split(' ');
 
   if (words.length % 3 !== 0) {
@@ -60,7 +64,7 @@ export function mnemonicToEntropy (mnemonic: string): Uint8Array {
   // convert word indices to 11 bit binary strings
   const bits = words
     .map((word): string => {
-      const index = DEFAULT_WORDLIST.indexOf(word);
+      const index = wordlist.indexOf(word);
 
       if (index === -1) {
         throw new Error(INVALID_MNEMONIC);
@@ -92,14 +96,14 @@ export function mnemonicToEntropy (mnemonic: string): Uint8Array {
   return entropy;
 }
 
-export function entropyToMnemonic (entropy: Uint8Array): string {
+export function entropyToMnemonic (entropy: Uint8Array, wordlist: string[] = DEFAULT_WORDLIST): string {
   // 128 <= ENT <= 256
   if ((entropy.length % 4 !== 0) || (entropy.length < 16) || (entropy.length > 32)) {
     throw new Error(INVALID_ENTROPY);
   }
 
   const matched = `${bytesToBinary(Array.from(entropy))}${deriveChecksumBits(entropy)}`.match(/(.{1,11})/g);
-  const mapped = matched && matched.map((binary) => DEFAULT_WORDLIST[binaryToByte(binary)]);
+  const mapped = matched && matched.map((b) => wordlist[binaryToByte(b)]);
 
   if (!mapped || (mapped.length < 12)) {
     throw new Error('Unable to map entropy to mnemonic');
@@ -108,13 +112,13 @@ export function entropyToMnemonic (entropy: Uint8Array): string {
   return mapped.join(' ');
 }
 
-export function generateMnemonic (numWords: 12 | 15 | 18 | 21 | 24): string {
-  return entropyToMnemonic(randomAsU8a((numWords / 3) * 4));
+export function generateMnemonic (numWords: 12 | 15 | 18 | 21 | 24, wordlist?: string[]): string {
+  return entropyToMnemonic(randomAsU8a((numWords / 3) * 4), wordlist);
 }
 
-export function validateMnemonic (mnemonic: string): boolean {
+export function validateMnemonic (mnemonic: string, wordlist?: string[]): boolean {
   try {
-    mnemonicToEntropy(mnemonic);
+    mnemonicToEntropy(mnemonic, wordlist);
   } catch {
     return false;
   }

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

@@ -4,6 +4,7 @@
 /// <reference types="@polkadot/dev-test/globals.d.ts" />
 
 import { cryptoWaitReady } from '../index.js';
+import { french as frenchWords } from './wordlists/index.js';
 import { mnemonicGenerate } from './generate.js';
 import { mnemonicValidate } from './validate.js';
 
@@ -16,11 +17,27 @@ describe('mnemonicGenerate', (): void => {
     ).toEqual(true);
   });
 
+  it('generates a french mnemonic', (): void => {
+    const mnemonic = mnemonicGenerate(24, frenchWords);
+    const words = mnemonic.split(' ');
+
+    expect(words).toHaveLength(24);
+    expect(
+      mnemonicValidate(mnemonic, frenchWords)
+    ).toEqual(true);
+    expect(
+      mnemonicValidate(mnemonic)
+    ).toEqual(false);
+    expect(
+      words.every((w) => frenchWords.includes(w))
+    ).toEqual(true);
+  });
+
   for (const onlyJs of [false, true]) {
     describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
       for (const num of [12, 15, 18, 21, 24] as const) {
         it(`generates a valid mnemonic (${num} words)`, (): void => {
-          const mnemonic = mnemonicGenerate(num, onlyJs);
+          const mnemonic = mnemonicGenerate(num, undefined, onlyJs);
           const isValid = mnemonicValidate(mnemonic);
 
           expect(mnemonic.split(' ')).toHaveLength(num);
@@ -29,8 +46,8 @@ describe('mnemonicGenerate', (): void => {
       }
 
       it('generates non-deterministic', (): void => {
-        const m1 = mnemonicGenerate(24, onlyJs);
-        const m2 = mnemonicGenerate(24, onlyJs);
+        const m1 = mnemonicGenerate(24, undefined, onlyJs);
+        const m2 = mnemonicGenerate(24, undefined, onlyJs);
 
         expect(m1 === m2).toEqual(false);
         expect(mnemonicValidate(m1)).toEqual(true);

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

@@ -18,8 +18,8 @@ import { generateMnemonic } from './bip39.js';
  * const mnemonic = mnemonicGenerate(); // => string
  * ```
  */
-export function mnemonicGenerate (numWords: 12 | 15 | 18 | 21 | 24 = 12, onlyJs?: boolean): string {
-  return !hasBigInt || (!onlyJs && isReady())
+export function mnemonicGenerate (numWords: 12 | 15 | 18 | 21 | 24 = 12, wordlist?: string[], onlyJs?: boolean): string {
+  return !hasBigInt || (!wordlist && !onlyJs && isReady())
     ? bip39Generate(numWords)
-    : generateMnemonic(numWords);
+    : generateMnemonic(numWords, wordlist);
 }

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

@@ -7,6 +7,7 @@ import { u8aToHex } from '@polkadot/util';
 
 import { cryptoWaitReady } from '../index.js';
 import tests from '../sr25519/pair/testing.spec.js';
+import { french as frenchWords } from './wordlists/index.js';
 import { mnemonicToEntropy } from './toEntropy.js';
 
 await cryptoWaitReady();
@@ -16,9 +17,20 @@ describe('mnemonicToEntropy', (): void => {
     describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
       tests.forEach(([mnemonic, entropy], index): void => {
         it(`Created correct entropy for ${index}`, (): void => {
-          expect(u8aToHex(mnemonicToEntropy(mnemonic, onlyJs))).toEqual(entropy);
+          expect(u8aToHex(mnemonicToEntropy(mnemonic, undefined, onlyJs))).toEqual(entropy);
         });
       });
     });
   }
+
+  it('has the correct entropy for non-Englist mnemonics', (): void => {
+    const mnemonic = 'pompier circuler pulpe injure aspect abyssal nuque boueux équerre balisage pieuvre médecin petit suffixe soleil cumuler monstre arlequin liasse pixel garrigue noble buisson scandale';
+
+    expect(
+      () => mnemonicToEntropy(mnemonic)
+    ).toThrow();
+    expect(
+      mnemonicToEntropy(mnemonic, frenchWords)
+    ).toEqual(new Uint8Array([189, 230, 55, 17, 65, 33, 40, 4, 106, 9, 11, 88, 227, 26, 229, 76, 59, 123, 200, 55, 177, 232, 158, 66, 34, 54, 93, 54, 255, 74, 137, 70]));
+  });
 });

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

@@ -6,8 +6,8 @@ import { bip39ToEntropy, isReady } from '@polkadot/wasm-crypto';
 
 import { mnemonicToEntropy as jsToEntropy } from './bip39.js';
 
-export function mnemonicToEntropy (mnemonic: string, onlyJs?: boolean): Uint8Array {
-  return !hasBigInt || (!onlyJs && isReady())
+export function mnemonicToEntropy (mnemonic: string, wordlist?: string[], onlyJs?: boolean): Uint8Array {
+  return !hasBigInt || (!wordlist && !onlyJs && isReady())
     ? bip39ToEntropy(mnemonic)
-    : jsToEntropy(mnemonic);
+    : jsToEntropy(mnemonic, wordlist);
 }

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

@@ -7,6 +7,7 @@ import { u8aEq, u8aToHex } from '@polkadot/util';
 
 import { cryptoWaitReady } from '../index.js';
 import tests from '../sr25519/pair/testing.spec.js';
+import { korean as koreanWords } from './wordlists/index.js';
 import { mnemonicToMiniSecret } from './toMiniSecret.js';
 
 const MNEMONIC = 'seed sock milk update focus rotate barely fade car face mechanic mercy';
@@ -19,31 +20,42 @@ describe('mnemonicToMiniSecret', (): void => {
     it(`generates Wasm & Js equivalents for password=${password || 'undefined'}`, (): void => {
       expect(
         u8aEq(
-          mnemonicToMiniSecret(MNEMONIC, password, true),
-          mnemonicToMiniSecret(MNEMONIC, password, false)
+          mnemonicToMiniSecret(MNEMONIC, password, undefined, true),
+          mnemonicToMiniSecret(MNEMONIC, password, undefined, false)
         )
       ).toEqual(true);
     });
   }
 
+  it('creates a known minisecret from a non-english mnemonic', (): void => {
+    const mnemonic = '엉덩이 능동적 숫자 팩시밀리 비난 서적 파출소 도움 독창적 인생 상류 먼지 답변 음반 수박 사업 노란색 공사 우체국 특급 도대체 금지 굉장히 고무신';
+
+    expect(
+      () => mnemonicToMiniSecret(mnemonic, 'testing')
+    ).toThrow();
+    expect(
+      u8aToHex(mnemonicToMiniSecret(mnemonic, 'testing', koreanWords))
+    ).toEqual('0xefa278a62535581767a2f49cb542ed91b65fb911e1b05e7a09c702b257f10c13');
+  });
+
   for (const onlyJs of [false, true]) {
     describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
       it('generates a valid seed', (): void => {
         expect(
-          u8aToHex(mnemonicToMiniSecret(MNEMONIC, undefined, onlyJs))
+          u8aToHex(mnemonicToMiniSecret(MNEMONIC, undefined, undefined, onlyJs))
         ).toEqual(SEED);
       });
 
       it('fails with non-mnemonics', (): void => {
         expect(
-          () => mnemonicToMiniSecret('foo bar baz', undefined, onlyJs)
+          () => mnemonicToMiniSecret('foo bar baz', undefined, undefined, onlyJs)
         ).toThrow(/mnemonic specified/);
       });
 
       tests.forEach(([mnemonic, , seed], index): void => {
         it(`Created correct seed for ${index}`, (): void => {
           expect(
-            u8aToHex(mnemonicToMiniSecret(mnemonic, 'Substrate', onlyJs))
+            u8aToHex(mnemonicToMiniSecret(mnemonic, 'Substrate', undefined, onlyJs))
           ).toEqual(
             // mini returned here, only check first 32-bytes (64 hex + 2 prefix)
             seed.substring(0, 66)

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

@@ -8,16 +8,14 @@ import { pbkdf2Encode } from '../pbkdf2/index.js';
 import { mnemonicToEntropy } from './toEntropy.js';
 import { mnemonicValidate } from './validate.js';
 
-export function mnemonicToMiniSecret (mnemonic: string, password = '', onlyJs?: boolean): Uint8Array {
-  if (!mnemonicValidate(mnemonic)) {
+export function mnemonicToMiniSecret (mnemonic: string, password = '', wordlist?: string[], onlyJs?: boolean): Uint8Array {
+  if (!mnemonicValidate(mnemonic, wordlist, onlyJs)) {
     throw new Error('Invalid bip39 mnemonic specified');
-  }
-
-  if (!onlyJs && isReady()) {
+  } else if (!wordlist && !onlyJs && isReady()) {
     return bip39ToMiniSecret(mnemonic, password);
   }
 
-  const entropy = mnemonicToEntropy(mnemonic);
+  const entropy = mnemonicToEntropy(mnemonic, wordlist);
   const salt = stringToU8a(`mnemonic${password}`);
 
   // return the first 32 bytes as the seed

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

@@ -32,10 +32,10 @@ for (const onlyJsMnemonic of [false, true]) {
               // do iterations to check and re-check that all matches
               for (const count of arrayRange(NUM_CHECKS)) {
                 it(`check=${count + 1}`, (): void => {
-                  const minisecret = mnemonicToMiniSecret(mnemonic, count ? `${count}` : '', onlyJsMnemonic);
+                  const minisecret = mnemonicToMiniSecret(mnemonic, count ? `${count}` : '', undefined, onlyJsMnemonic);
                   const edpub = ed25519PairFromSeed(minisecret).publicKey;
                   const srpub = sr25519PairFromSeed(minisecret).publicKey;
-                  const testmini = mnemonicToMiniSecret(mnemonic, count ? `${count}` : '', onlyJsMini);
+                  const testmini = mnemonicToMiniSecret(mnemonic, count ? `${count}` : '', undefined, onlyJsMini);
 
                   // explicit minisecret compare
                   expect(

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

@@ -4,6 +4,7 @@
 /// <reference types="@polkadot/dev-test/globals.d.ts" />
 
 import { cryptoWaitReady } from '../index.js';
+import { french as frenchWords } from './wordlists/index.js';
 import { mnemonicValidate } from './validate.js';
 
 await cryptoWaitReady();
@@ -13,15 +14,26 @@ describe('mnemonicValidate', (): void => {
     describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
       it('returns true on valid', (): void => {
         expect(
-          mnemonicValidate('seed sock milk update focus rotate barely fade car face mechanic mercy', onlyJs)
+          mnemonicValidate('seed sock milk update focus rotate barely fade car face mechanic mercy', undefined, onlyJs)
         ).toEqual(true);
       });
 
       it('returns false on invalid', (): void => {
         expect(
-          mnemonicValidate('wine photo extra cushion basket dwarf humor cloud truck job boat submit', onlyJs)
+          mnemonicValidate('wine photo extra cushion basket dwarf humor cloud truck job boat submit', undefined, onlyJs)
         ).toEqual(false);
       });
     });
   }
+
+  it('allows usage of a different wordlist', (): void => {
+    const mnemonic = 'pompier circuler pulpe injure aspect abyssal nuque boueux équerre balisage pieuvre médecin petit suffixe soleil cumuler monstre arlequin liasse pixel garrigue noble buisson scandale';
+
+    expect(
+      mnemonicValidate(mnemonic, frenchWords)
+    ).toEqual(true);
+    expect(
+      mnemonicValidate(mnemonic)
+    ).toEqual(false);
+  });
 });

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

@@ -19,8 +19,8 @@ import { validateMnemonic } from './bip39.js';
  * const isValidMnemonic = mnemonicValidate(mnemonic); // => boolean
  * ```
  */
-export function mnemonicValidate (mnemonic: string, onlyJs?: boolean): boolean {
-  return !hasBigInt || (!onlyJs && isReady())
+export function mnemonicValidate (mnemonic: string, wordlist?: string[], onlyJs?: boolean): boolean {
+  return !hasBigInt || (!wordlist && !onlyJs && isReady())
     ? bip39Validate(mnemonic)
-    : validateMnemonic(mnemonic);
+    : validateMnemonic(mnemonic, wordlist);
 }

packages/util-crypto/src/mnemonic/wordlists/index.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2023 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export { default as english } from './en.js';
+export { default as spanish } from './es.js';
+export { default as french } from './fr.js';
+export { default as italian } from './it.js';
+export { default as japanese } from './jp.js';
+export { default as korean } from './ko.js';
+export { default as chineseSimplified } from './zh-s.js';
+export { default as chineseTraditional } from './zh-t.js';

packages/util-crypto/src/nacl/box/fromSecret.spec.ts

@@ -1,29 +0,0 @@
-// Copyright 2017-2023 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { naclBoxPairFromSecret } from '../index.js';
-
-describe('naclBoxPairFromSecret', (): void => {
-  const secretKey = new Uint8Array([
-    18, 52, 86, 120, 144, 18, 52, 86,
-    120, 144, 18, 52, 86, 120, 144, 18,
-    18, 52, 86, 120, 144, 18, 52, 86,
-    120, 144, 18, 52, 86, 120, 144, 18
-  ]);
-
-  it('generates a valid publicKey/secretKey pair', (): void => {
-    expect(
-      naclBoxPairFromSecret(secretKey)
-    ).toEqual({
-      publicKey: new Uint8Array([
-        206, 110, 228, 222, 155, 43, 229, 254,
-        38, 117, 157, 116, 224, 87, 139, 171,
-        17, 195, 144, 167, 106, 36, 161, 28,
-        25, 232, 127, 47, 219, 165, 44, 102
-      ]),
-      secretKey
-    });
-  });
-});

packages/util-crypto/src/nacl/box/fromSecret.ts

@@ -1,24 +0,0 @@
-// Copyright 2017-2023 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Keypair } from '../../types.js';
-
-import nacl from 'tweetnacl';
-
-/**
- * @name naclBoxPairFromSecret
- * @summary Creates a new public/secret box keypair from a secret.
- * @description
- * Returns a object containing a box `publicKey` & `secretKey` generated from the supplied secret.
- * @example
- * <BR>
- *
- * ```javascript
- * import { naclBoxPairFromSecret } from '@polkadot/util-crypto';
- *
- * naclBoxPairFromSecret(...); // => { secretKey: [...], publicKey: [...] }
- * ```
- */
-export function naclBoxPairFromSecret (secret: Uint8Array): Keypair {
-  return nacl.box.keyPair.fromSecretKey(secret.slice(0, 32));
-}

packages/util-crypto/src/nacl/decrypt.ts

@@ -1,7 +1,7 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import nacl from 'tweetnacl';
+import { naclSecretboxOpen } from './tweetnacl.js';
 
 /**
  * @name naclDecrypt
@@ -18,5 +18,5 @@ import nacl from 'tweetnacl';
  * ```
  */
 export function naclDecrypt (encrypted: Uint8Array, nonce: Uint8Array, secret: Uint8Array): Uint8Array | null {
-  return nacl.secretbox.open(encrypted, nonce, secret) || null;
+  return naclSecretboxOpen(encrypted, nonce, secret);
 }

packages/util-crypto/src/nacl/encrypt.ts

@@ -1,9 +1,8 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import nacl from 'tweetnacl';
-
 import { randomAsU8a } from '../random/asU8a.js';
+import { naclSecretbox } from './tweetnacl.js';
 
 interface Encrypted {
   encrypted: Uint8Array;
@@ -26,7 +25,7 @@ interface Encrypted {
  */
 export function naclEncrypt (message: Uint8Array, secret: Uint8Array, nonce: Uint8Array = randomAsU8a(24)): Encrypted {
   return {
-    encrypted: nacl.secretbox(message, nonce, secret),
+    encrypted: naclSecretbox(message, nonce, secret),
     nonce
   };
 }

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

@@ -6,6 +6,3 @@
  */
 export { naclDecrypt } from './decrypt.js';
 export { naclEncrypt } from './encrypt.js';
-export { naclBoxPairFromSecret } from './box/fromSecret.js';
-export { naclOpen } from './open.js';
-export { naclSeal } from './seal.js';

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

@@ -1,102 +0,0 @@
-// Copyright 2017-2023 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { ed25519PairFromString } from '../ed25519/index.js';
-import { keyExtractPath, keyFromPath } from '../key/index.js';
-import { naclBoxPairFromSecret, naclOpen, naclSeal } from './index.js';
-
-describe('naclOpen', (): void => {
-  it('opens a sealed message by the sender', (): void => {
-    const message = new Uint8Array([1, 2, 3, 4, 5, 4, 3, 2, 1]);
-    const sender = ed25519PairFromString('sender');
-    const receiver = ed25519PairFromString('receiver');
-    const senderBox = naclBoxPairFromSecret(sender.secretKey);
-    const receiverBox = naclBoxPairFromSecret(receiver.secretKey);
-    const { nonce, sealed } = naclSeal(message, senderBox.secretKey, receiverBox.publicKey);
-
-    expect(
-      naclOpen(sealed, nonce, senderBox.publicKey, receiverBox.secretKey)
-    ).toEqual(
-      message
-    );
-  });
-
-  it('polkadot does double ratchet', () => {
-    const sender = ed25519PairFromString('sender');
-    const receiver = ed25519PairFromString('receiver');
-
-    // Make id key for identifying each other
-    const senderIdKey = keyFromPath(sender, keyExtractPath('//1//1//1//1').path, 'ed25519');
-    const receiverIdKey = keyFromPath(receiver, keyExtractPath('//2//2//2//2').path, 'ed25519');
-
-    // Receiver sends encrypting public key to receive message to decrypt with his private key
-    const receiverIdBoxKey = naclBoxPairFromSecret(receiverIdKey.secretKey);
-
-    // console.log(`Receiver sends receiver's public key to sender ${receiverIdBoxKey.publicKey.toString()}`);
-
-    // Sender encrypts message to send with the public key the receiver sent and send it to receiver
-    const senderIdBoxKey = naclBoxPairFromSecret(senderIdKey.secretKey);
-    const message = new Uint8Array([1, 2, 3, 4, 5, 4, 3, 2, 1]);
-    const { nonce, sealed } = naclSeal(message, senderIdBoxKey.secretKey, receiverIdBoxKey.publicKey);
-
-    // console.log(`Sender sends encrypted message to receiver ${sealed.toString()}, ${nonce.toString()}`);
-
-    // Receiver opens encrypted message from the sender
-    let opened = naclOpen(sealed, nonce, senderIdBoxKey.publicKey, receiverIdBoxKey.secretKey);
-
-    // console.log(`The sealed message is ${opened?.toString() || 'null'}`);
-
-    // Oh no the Id key is hacked, derive Id key again from another index
-    const senderIdKey2 = keyFromPath(sender, keyExtractPath('//1//1//1//2').path, 'ed25519');
-    const receiverIdKey2 = keyFromPath(receiver, keyExtractPath('//2//2//2//3').path, 'ed25519');
-
-    // Receiver sends encrypting public key to receive message to decrypt with his private key
-    const receiverIdBoxKey2 = naclBoxPairFromSecret(receiverIdKey2.secretKey);
-
-    // console.log(`Receiver sends receiver's public key to sender ${receiverIdBoxKey2.publicKey.toString()}`);
-
-    // Sender encrypts message to send with the public key the receiver sent and send it to receiver
-    const senderIdBoxKey2 = naclBoxPairFromSecret(senderIdKey2.secretKey);
-    const message2 = new Uint8Array([1, 2, 3, 4, 5, 4, 3, 2, 1]);
-    let ctx = naclSeal(message2, senderIdBoxKey2.secretKey, receiverIdBoxKey2.publicKey);
-    const sealed2 = ctx.sealed;
-    const nonce2 = ctx.nonce;
-
-    // console.log(`Sender sends encrypted message to receiver ${sealed.toString()}, ${nonce.toString()}`);
-
-    // Receiver opens encrypted message from the sender
-    opened = naclOpen(sealed2, nonce2, senderIdBoxKey2.publicKey, receiverIdBoxKey2.secretKey);
-    // console.log(`The sealed message is ${opened?.toString() || 'null'}`);
-
-    // This time derive key for each message to send and receive
-    // Receiver sends encrypting public key to receive message to decrypt with his private key
-    const receiverIdBoxKey2One = naclBoxPairFromSecret(receiverIdBoxKey2.secretKey);
-
-    // console.log(`Receiver sends receiver's public key to sender ${receiverIdBoxKey2One.publicKey.toString()}`);
-
-    // Sender encrypts message to send with the public key the receiver sent and send it to receiver
-    const senderIdBoxKey2One = naclBoxPairFromSecret(senderIdBoxKey2.secretKey);
-    const message3 = new Uint8Array([1, 2, 3, 4, 5, 4, 3, 2, 1]);
-
-    ctx = naclSeal(message3, senderIdBoxKey2One.secretKey, receiverIdBoxKey2One.publicKey);
-
-    // const sealed3 = ctx.sealed;
-    // const nonce3 = ctx.nonce;
-
-    // console.log(`Sender sends encrypted message to receiver ${sealed3.toString()}, ${nonce3.toString()}`);
-
-    // Receiver opens encrypted message from the sender
-    opened = naclOpen(sealed2, nonce2, senderIdBoxKey2One.publicKey, receiverIdBoxKey2One.secretKey);
-
-    expect(opened).toEqual(message3);
-    // console.log(`The sealed message is ${opened?.toString() || 'null'}`);
-  });
-
-  it('returns null on invalid', (): void => {
-    expect(
-      naclOpen(new Uint8Array(), new Uint8Array(24), new Uint8Array(32), new Uint8Array(32))
-    ).toEqual(null);
-  });
-});

packages/util-crypto/src/nacl/open.ts

@@ -1,22 +0,0 @@
-// Copyright 2017-2023 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import nacl from 'tweetnacl';
-
-/**
- * @name naclOpen
- * @summary Opens a message using the receiver's secretKey and nonce
- * @description
- * Returns a message sealed by the sender, using the receiver's `secret` and `nonce`.
- * @example
- * <BR>
- *
- * ```javascript
- * import { naclOpen } from '@polkadot/util-crypto';
- *
- * naclOpen([...], [...], [...]); // => [...]
- * ```
- */
-export function naclOpen (sealed: Uint8Array, nonce: Uint8Array, senderBoxPublic: Uint8Array, receiverBoxSecret: Uint8Array): Uint8Array | null {
-  return nacl.box.open(sealed, nonce, senderBoxPublic, receiverBoxSecret) || null;
-}

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

@@ -1,26 +0,0 @@
-// Copyright 2017-2023 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { ed25519PairFromString } from '../ed25519/index.js';
-import { naclBoxPairFromSecret, naclSeal } from './index.js';
-
-describe('naclSeal', (): void => {
-  it('seals a message', (): void => {
-    const message = new Uint8Array([1, 2, 3, 4, 5, 4, 3, 2, 1]);
-    const sender = ed25519PairFromString('sender');
-    const receiver = ed25519PairFromString('receiver');
-    const senderBox = naclBoxPairFromSecret(sender.secretKey);
-    const receiverBox = naclBoxPairFromSecret(receiver.secretKey);
-    const senderBoxSecret = senderBox.secretKey;
-    const receiverBoxPublic = receiverBox.publicKey;
-
-    expect(
-      naclSeal(message, senderBoxSecret, receiverBoxPublic, new Uint8Array(24))
-    ).toEqual({
-      nonce: new Uint8Array(24),
-      sealed: new Uint8Array([137, 195, 104, 255, 67, 199, 40, 235, 148, 177, 180, 73, 239, 131, 215, 80, 61, 191, 167, 213, 152, 138, 5, 47, 135])
-    });
-  });
-});

packages/util-crypto/src/nacl/seal.ts

@@ -1,32 +0,0 @@
-// Copyright 2017-2023 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import nacl from 'tweetnacl';
-
-import { randomAsU8a } from '../random/asU8a.js';
-
-interface Sealed {
-  sealed: Uint8Array;
-  nonce: Uint8Array;
-}
-
-/**
- * @name naclSeal
- * @summary Seals a message using the sender's encrypting secretKey, receiver's public key, and nonce
- * @description
- * Returns an encrypted message which can be open only by receiver's secretKey. If the `nonce` was not supplied, a random value is generated.
- * @example
- * <BR>
- *
- * ```javascript
- * import { naclSeal } from '@polkadot/util-crypto';
- *
- * naclSeal([...], [...], [...], [...]); // => [...]
- * ```
- */
-export function naclSeal (message: Uint8Array, senderBoxSecret: Uint8Array, receiverBoxPublic: Uint8Array, nonce: Uint8Array = randomAsU8a(24)): Sealed {
-  return {
-    nonce,
-    sealed: nacl.box(message, nonce, receiverBoxPublic, senderBoxSecret)
-  };
-}

packages/util-crypto/src/nacl/tweetnacl-secretbox.spec.ts

@@ -0,0 +1,161 @@
+// Copyright 2017-2023 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+// Adapted from https://github.com/dchest/tweetnacl-js/blob/6a9594a35a27f9c723c5f1c107e376d1c65c23b3/test/04-secretbox.quick.js
+// Adapted from https://github.com/dchest/tweetnacl-js/blob/6a9594a35a27f9c723c5f1c107e376d1c65c23b3/test/04-secretbox.js
+//
+// Changes made:
+//  - Jest-like test environment (not tape)
+//  - Combine "quick" and "random" tests into single file
+//
+// Original headers:
+//
+// Ported in 2014 by Dmitry Chestnykh and Devi Mandiri.
+// Public domain.
+//
+// Implementation derived from TweetNaCl version 20140427.
+// See for details: http://tweetnacl.cr.yp.to/
+
+import { stringToU8a, u8aEq } from '@polkadot/util';
+
+import { base64Decode } from '../base64/index.js';
+import { naclSecretbox, naclSecretboxOpen } from './tweetnacl.js';
+import { TEST_DATA } from './tweetnacl-secretbox-data.spec.js';
+
+describe('tweetnacl/secretbox', (): void => {
+  describe('tweetnacl/test/04-secretbox.quick.js', (): void => {
+    it('naclSecretbox and naclSecretboxOpen', (): void => {
+      const key = new Uint8Array(32);
+      const nonce = new Uint8Array(24);
+
+      for (let i = 0; i < key.length; i++) {
+        key[i] = i & 0xff;
+      }
+
+      for (let i = 0; i < nonce.length; i++) {
+        nonce[i] = (32 + i) & 0xff;
+      }
+
+      const msg = stringToU8a('message to encrypt');
+      const box = naclSecretbox(msg, nonce, key);
+      const openedMsg = naclSecretboxOpen(box, nonce, key);
+
+      expect(
+        !!openedMsg && u8aEq(openedMsg, msg)
+      ).toEqual(true);
+    });
+
+    it('naclSecretbox.open with invalid box', (): void => {
+      const key = new Uint8Array(32);
+      const nonce = new Uint8Array(24);
+
+      expect(
+        naclSecretboxOpen(new Uint8Array(0), nonce, key)
+      ).toBe(null);
+
+      expect(
+        naclSecretboxOpen(new Uint8Array(10), nonce, key)
+      ).toBe(null);
+
+      expect(
+        naclSecretboxOpen(new Uint8Array(100), nonce, key)
+      ).toBe(null);
+    });
+
+    it('naclSecretbox.open with invalid nonce', (): void => {
+      const key = new Uint8Array(32);
+      const nonce = new Uint8Array(24);
+
+      for (let i = 0; i < nonce.length; i++) {
+        nonce[i] = i & 0xff;
+      }
+
+      const msg = stringToU8a('message to encrypt');
+      const box = naclSecretbox(msg, nonce, key);
+      const unbox = naclSecretboxOpen(box, nonce, key);
+
+      expect(
+        !!unbox && u8aEq(unbox, msg)
+      ).toBe(true);
+
+      nonce[0] = 255;
+
+      expect(
+        naclSecretboxOpen(box, nonce, key)
+      ).toBe(null);
+    });
+
+    it('naclSecretbox.open with invalid key', (): void => {
+      const key = new Uint8Array(32);
+
+      for (let i = 0; i < key.length; i++) {
+        key[i] = i & 0xff;
+      }
+
+      const nonce = new Uint8Array(24);
+      const msg = stringToU8a('message to encrypt');
+      const box = naclSecretbox(msg, nonce, key);
+      const unbox = naclSecretboxOpen(box, nonce, key);
+
+      expect(
+        !!unbox && u8aEq(unbox, msg)
+      ).toBe(true);
+
+      key[0] = 255;
+
+      expect(
+        naclSecretboxOpen(box, nonce, key)
+      ).toBe(null);
+    });
+
+    it('naclSecretbox with message lengths of 0 to 1024', (): void => {
+      const key = new Uint8Array(32);
+      const nonce = new Uint8Array(24);
+      const fullMsg = new Uint8Array(1024);
+
+      for (let i = 0; i < key.length; i++) {
+        key[i] = i & 0xff;
+      }
+
+      for (let i = 0; i < fullMsg.length; i++) {
+        fullMsg[i] = i & 0xff;
+      }
+
+      for (let i = 0; i < fullMsg.length; i++) {
+        const msg = fullMsg.subarray(0, i);
+        const box = naclSecretbox(msg, nonce, key);
+        const unbox = naclSecretboxOpen(box, nonce, key);
+
+        expect(
+          !!unbox && u8aEq(unbox, msg)
+        ).toBe(true);
+      }
+    });
+  });
+
+  describe('tweetnacl/test/04-secretbox.js', (): void => {
+    for (let i = 0; i < TEST_DATA.length; i++) {
+      const [keyBase64, nonceBase64, msgBase64, expBase64] = TEST_DATA[i];
+
+      it(`is ok on "${msgBase64}"`, (): void => {
+        const key = base64Decode(keyBase64);
+        const nonce = base64Decode(nonceBase64);
+        const msg = base64Decode(msgBase64);
+        const goodBox = base64Decode(expBase64);
+        const box = naclSecretbox(msg, nonce, key);
+
+        expect(
+          u8aEq(box, goodBox)
+        ).toBe(true);
+
+        const unbox = naclSecretboxOpen(goodBox, nonce, key);
+
+        expect(
+          !!unbox && u8aEq(unbox, msg)
+        ).toBe(true);
+      });
+    }
+  });
+});

packages/util-crypto/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Do not edit, auto-generated by @polkadot/dev
 
-export const packageInfo = { name: '@polkadot/util-crypto', path: 'auto', type: 'auto', version: '11.1.3' };
+export const packageInfo = { name: '@polkadot/util-crypto', path: 'auto', type: 'auto', version: '12.2.1' };

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

@@ -17,7 +17,7 @@ interface Result {
   salt: Uint8Array;
 }
 
-export function pbkdf2Encode (passphrase?: HexString | Buffer | Uint8Array | string, salt: Buffer | Uint8Array = randomAsU8a(), rounds = 2048, onlyJs?: boolean): Result {
+export function pbkdf2Encode (passphrase?: HexString | Uint8Array | string, salt: Uint8Array = randomAsU8a(), rounds = 2048, onlyJs?: boolean): Result {
   const u8aPass = u8aToU8a(passphrase);
   const u8aSalt = u8aToU8a(salt);
 

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

@@ -40,9 +40,8 @@ describe('secp256k1Compress', (): void => {
     });
   }
 
-  perfWasm('secp256k1Compress', 100000, (input, onlyJs) => secp256k1Compress(input, onlyJs),
-    [[
-      hexToU8a('0x04b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb1307763fe926c273235fd979a134076d00fd1683cbd35868cb485d4a3a640e52184af')
-    ]]
+  perfWasm('secp256k1Compress', 100000, (input, onlyJs) => secp256k1Compress(input, onlyJs), [[
+    hexToU8a('0x04b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb1307763fe926c273235fd979a134076d00fd1683cbd35868cb485d4a3a640e52184af')
+  ]]
   );
 });

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { Point } from '@noble/secp256k1';
+import { secp256k1 } from '@noble/curves/secp256k1';
 
 import { hasBigInt } from '@polkadot/util';
 import { isReady, secp256k1Compress as wasm } from '@polkadot/wasm-crypto';
@@ -17,5 +17,5 @@ export function secp256k1Compress (publicKey: Uint8Array, onlyJs?: boolean): Uin
 
   return !hasBigInt || (!onlyJs && isReady())
     ? wasm(publicKey)
-    : Point.fromHex(publicKey).toRawBytes(true);
+    : secp256k1.ProjectivePoint.fromHex(publicKey).toRawBytes(true);
 }

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

@@ -40,9 +40,8 @@ describe('secp256k1Expand', (): void => {
     });
   }
 
-  perfWasm('secp256k1Expand', 2000, (input, onlyJs) => secp256k1Expand(input, onlyJs),
-    [[
-      hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077')
-    ]]
+  perfWasm('secp256k1Expand', 2000, (input, onlyJs) => secp256k1Expand(input, onlyJs), [[
+    hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077')
+  ]]
   );
 });

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { Point } from '@noble/secp256k1';
+import { secp256k1 } from '@noble/curves/secp256k1';
 
 import { bnToU8a, hasBigInt, u8aConcat } from '@polkadot/util';
 import { isReady, secp256k1Expand as wasm } from '@polkadot/wasm-crypto';
@@ -21,10 +21,10 @@ export function secp256k1Expand (publicKey: Uint8Array, onlyJs?: boolean): Uint8
     return wasm(publicKey).subarray(1);
   }
 
-  const { x, y } = Point.fromHex(publicKey);
+  const { px, py } = secp256k1.ProjectivePoint.fromHex(publicKey);
 
   return u8aConcat(
-    bnToU8a(x, BN_BE_256_OPTS),
-    bnToU8a(y, BN_BE_256_OPTS)
+    bnToU8a(px, BN_BE_256_OPTS),
+    bnToU8a(py, BN_BE_256_OPTS)
   );
 }

packages/util-crypto/src/secp256k1/pair/fromSeed.ts

@@ -3,7 +3,7 @@
 
 import type { Keypair } from '../../types.js';
 
-import { getPublicKey } from '@noble/secp256k1';
+import { secp256k1 } from '@noble/curves/secp256k1';
 
 import { hasBigInt, u8aEmpty } from '@polkadot/util';
 import { isReady, secp256k1FromSeed } from '@polkadot/wasm-crypto';
@@ -36,7 +36,7 @@ export function secp256k1PairFromSeed (seed: Uint8Array, onlyJs?: boolean): Keyp
   }
 
   return {
-    publicKey: getPublicKey(seed, true),
+    publicKey: secp256k1.getPublicKey(seed, true),
     secretKey: seed
   };
 }

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

@@ -4,7 +4,7 @@
 import type { HexString } from '@polkadot/util/types';
 import type { HashType } from './types.js';
 
-import { recoverPublicKey, Signature } from '@noble/secp256k1';
+import { secp256k1 } from '@noble/curves/secp256k1';
 
 import { hasBigInt, u8aToU8a } from '@polkadot/util';
 import { isReady, secp256k1Recover as wasm } from '@polkadot/wasm-crypto';
@@ -21,7 +21,11 @@ export function secp256k1Recover (msgHash: HexString | Uint8Array | string, sign
   const msg = u8aToU8a(msgHash);
   const publicKey = !hasBigInt || (!onlyJs && isReady())
     ? wasm(msg, sig, recovery)
-    : recoverPublicKey(msg, Signature.fromCompact(sig).toRawBytes(), recovery);
+    : secp256k1.Signature
+      .fromCompact(sig)
+      .addRecoveryBit(recovery)
+      .recoverPublicKey(msg)
+      .toRawBytes();
 
   if (!publicKey) {
     throw new Error('Unable to recover publicKey from signature');

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

@@ -4,7 +4,7 @@
 import type { Keypair } from '../types.js';
 import type { HashType } from './types.js';
 
-import { Signature, signSync } from '@noble/secp256k1';
+import { secp256k1 } from '@noble/curves/secp256k1';
 
 import { bnToU8a, hasBigInt, u8aConcat } from '@polkadot/util';
 import { isReady, secp256k1Sign as wasm } from '@polkadot/wasm-crypto';
@@ -27,12 +27,11 @@ export function secp256k1Sign (message: Uint8Array | string, { secretKey }: Part
     return wasm(data, secretKey);
   }
 
-  const [sigBytes, recoveryParam] = signSync(data, secretKey, { canonical: true, recovered: true });
-  const { r, s } = Signature.fromHex(sigBytes);
+  const signature = secp256k1.sign(data, secretKey, { lowS: true });
 
   return u8aConcat(
-    bnToU8a(r, BN_BE_256_OPTS),
-    bnToU8a(s, BN_BE_256_OPTS),
-    new Uint8Array([recoveryParam || 0])
+    bnToU8a(signature.r, BN_BE_256_OPTS),
+    bnToU8a(signature.s, BN_BE_256_OPTS),
+    new Uint8Array([signature.recovery || 0])
   );
 }

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

@@ -5,4 +5,4 @@
  * @summary Implements Sha-256/512 hashing functions for a variety of input and outputs
  */
 
-export { shaAsU8a, sha256AsU8a, sha512AsU8a } from './asU8a.js';
+export { sha256AsU8a, sha512AsU8a, shaAsU8a } from './asU8a.js';

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

@@ -1,6 +1,8 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+// all external
 export { perf, perfCmp } from '@polkadot/util/test';
 
+// all local
 export { perfWasm } from './performance.js';

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

@@ -23,7 +23,7 @@ import { xxhash64 } from './xxhash64.js';
  * xxhashAsU8a('abc'); // => 0x44bc2cf5ad770999
  * ```
  */
-export function xxhashAsU8a (data: HexString | Buffer | Uint8Array | string, bitLength: 64 | 128 | 192 | 256 | 320 | 384 | 448 | 512 = 64, onlyJs?: boolean): Uint8Array {
+export function xxhashAsU8a (data: HexString | Uint8Array | string, bitLength: 64 | 128 | 192 | 256 | 320 | 384 | 448 | 512 = 64, onlyJs?: boolean): Uint8Array {
   const rounds = Math.ceil(bitLength / 64);
   const u8a = u8aToU8a(data);
 

packages/util-crypto/src/xxhash/xxhash64.ts

@@ -16,6 +16,7 @@ import { BigInt } from '@polkadot/x-bigint';
 //   - support only for Uint8Array inputs
 //   - no constructor function, straight fill & digest
 //   - update code removed, only called once, no streams
+//   - inline single-use functions
 
 interface State {
   seed: bigint;
@@ -74,22 +75,8 @@ function fromU8a (u8a: Uint8Array, p: number, count: 2 | 4): bigint {
   return result;
 }
 
-function toU8a (h64: bigint): Uint8Array {
-  const result = new Uint8Array(8);
-
-  for (let i = 7; i >= 0; i--) {
-    result[i] = Number(h64 % _256n);
-
-    h64 = h64 / _256n;
-  }
-
-  return result;
-}
-
-function state (initSeed: bigint | number): State {
-  const seed = BigInt(initSeed);
-
-  return {
+function init (seed: bigint, input: Uint8Array): State {
+  const state = {
     seed,
     u8a: new Uint8Array(32),
     u8asize: 0,
@@ -98,9 +85,7 @@ function state (initSeed: bigint | number): State {
     v3: seed,
     v4: seed - P64_1
   };
-}
 
-function init (state: State, input: Uint8Array): State {
   if (input.length < 32) {
     state.u8a.set(input);
     state.u8asize = input.length;
@@ -132,7 +117,7 @@ function init (state: State, input: Uint8Array): State {
 }
 
 export function xxhash64 (input: Uint8Array, initSeed: bigint | number): Uint8Array {
-  const { seed, u8a, u8asize, v1, v2, v3, v4 } = init(state(initSeed), input);
+  const { seed, u8a, u8asize, v1, v2, v3, v4 } = init(BigInt(initSeed), input);
   let p = 0;
   let h64 = U64 & (BigInt(input.length) + (
     input.length >= 32
@@ -156,6 +141,15 @@ export function xxhash64 (input: Uint8Array, initSeed: bigint | number): Uint8Ar
 
   h64 = U64 & (P64_2 * (h64 ^ (h64 >> _33n)));
   h64 = U64 & (P64_3 * (h64 ^ (h64 >> _29n)));
+  h64 = U64 & (h64 ^ (h64 >> _32n));
 
-  return toU8a(U64 & (h64 ^ (h64 >> _32n)));
+  const result = new Uint8Array(8);
+
+  for (let i = 7; i >= 0; i--) {
+    result[i] = Number(h64 % _256n);
+
+    h64 = h64 / _256n;
+  }
+
+  return result;
 }

packages/util/package.json

@@ -3,7 +3,7 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "description": "A collection of useful utilities for @polkadot",
   "engines": {
-    "node": ">=14"
+    "node": ">=16"
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util#readme",
   "license": "Apache-2.0",
@@ -18,7 +18,7 @@
     "./detectPackage.cjs"
   ],
   "type": "module",
-  "version": "11.1.3",
+  "version": "12.2.1",
   "main": "index.js",
   "exports": {
     "./hex/toU8a": {
@@ -35,15 +35,15 @@
     }
   },
   "dependencies": {
-    "@polkadot/x-bigint": "11.1.3",
-    "@polkadot/x-global": "11.1.3",
-    "@polkadot/x-textdecoder": "11.1.3",
-    "@polkadot/x-textencoder": "11.1.3",
+    "@polkadot/x-bigint": "12.2.1",
+    "@polkadot/x-global": "12.2.1",
+    "@polkadot/x-textdecoder": "12.2.1",
+    "@polkadot/x-textencoder": "12.2.1",
     "@types/bn.js": "^5.1.1",
     "bn.js": "^5.2.1",
     "tslib": "^2.5.0"
   },
   "devDependencies": {
-    "@polkadot/x-randomvalues": "11.1.3"
+    "@polkadot/x-randomvalues": "12.2.1"
   }
 }

packages/util/src/array/chunk.ts

@@ -18,7 +18,7 @@
 export function arrayChunk <T> (array: T[], chunkSize: number): T[][] {
   const outputSize = Math.ceil(array.length / chunkSize);
 
-  // noop for the single-split case
+  // shortcut for the single-split case
   if (outputSize === 1) {
     return [array];
   }

packages/util/src/array/flatten.ts

@@ -19,7 +19,7 @@
  * ```
  */
 export function arrayFlatten <T> (arrays: readonly T[][]): T[] {
-  // noop for the empty & single-entry case
+  // shortcuts for the empty & single-entry case
   if (arrays.length === 0) {
     return [];
   } else if (arrays.length === 1) {

packages/util/src/array/unzip.ts

@@ -6,10 +6,11 @@
  * @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);
+  const count = entries.length;
+  const keys = new Array<K>(count);
+  const values = new Array<V>(count);
 
-  for (let i = 0; i < entries.length; i++) {
+  for (let i = 0; i < count; i++) {
     [keys[i], values[i]] = entries[i];
   }
 

packages/util/src/array/zip.ts

@@ -6,9 +6,10 @@
  * @description Combines 2 distinct key/value arrays into a single [K, V] array
  */
 export function arrayZip <K, V> (keys: readonly K[], values: readonly V[]): [K, V][] {
-  const result = new Array<[K, V]>(keys.length);
+  const count = keys.length;
+  const result = new Array<[K, V]>(count);
 
-  for (let i = 0; i < keys.length; i++) {
+  for (let i = 0; i < count; i++) {
     result[i] = [keys[i], values[i]];
   }
 

packages/util/src/bi/index.ts

@@ -5,10 +5,12 @@
  * @summary Utility methods to convert to and from `bigint` objects
  */
 
-export * from './consts.js';
-
+// all named
+export { nMax, nMin } from './min.js';
 export { nSqrt } from './sqrt.js';
 export { nToBigInt } from './toBigInt.js';
-export { nMax, nMin } from './min.js';
 export { nToHex } from './toHex.js';
 export { nToU8a } from './toU8a.js';
+
+// all starred
+export * from './consts.js';

packages/util/src/bi/toHex.ts

@@ -11,6 +11,6 @@ import { nToU8a } from './toU8a.js';
  * @name nToHex
  * @summary Creates a hex value from a bigint object.
  */
-export function nToHex <ExtToBn extends ToBn | ToBigInt> (value?: ExtToBn | BN | bigint | number | null, { bitLength, isLe = false, isNegative = false }: NumberOptions = {}): HexString {
+export function nToHex <ExtToBn extends ToBn | ToBigInt> (value?: ExtToBn | BN | bigint | number | null, { bitLength = -1, isLe = false, isNegative = false }: NumberOptions = {}): HexString {
   return u8aToHex(nToU8a(value || 0, { bitLength, isLe, isNegative }));
 }

packages/util/src/bn/index.ts

@@ -5,8 +5,7 @@
  * @summary Utility methods to convert to and from `BN` objects
  */
 
-export * from './consts.js';
-
+// all named
 export { BN } from './bn.js';
 export { bnFromHex } from './fromHex.js';
 export { bnMax, bnMin } from './min.js';
@@ -14,3 +13,6 @@ export { bnSqrt } from './sqrt.js';
 export { bnToBn } from './toBn.js';
 export { bnToHex } from './toHex.js';
 export { bnToU8a } from './toU8a.js';
+
+// all starred
+export * from './consts.js';

packages/util/src/bn/min.ts

@@ -1,8 +1,9 @@
 // Copyright 2017-2023 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import type { BN } from './bn.js';
+
 import { createCmp } from '../bi/helpers.js';
-import { BN } from './bn.js';
 
 /**
  * @name bnMax

packages/util/src/buffer/toU8a.ts

@@ -15,6 +15,6 @@
  * bufferToU8a(Buffer.from([1, 2, 3]));
  * ```
  */
-export function bufferToU8a (buffer?: Buffer | number[] | null): Uint8Array {
+export function bufferToU8a (buffer?: Uint8Array | number[] | null): Uint8Array {
   return new Uint8Array(buffer || []);
 }

packages/util/src/bundle.ts

@@ -4,8 +4,11 @@
 /**
  * @summary Utility methods for this package are split into groups
  */
+
+// all named
 export { packageInfo } from './packageInfo.js';
 
+// all starred
 export * from './array/index.js';
 export * from './assert.js';
 export * from './bi/index.js';
@@ -22,6 +25,7 @@ export * from './lazy.js';
 export * from './logger.js';
 export * from './memoize.js';
 export * from './nextTick.js';
+export * from './noop.js';
 export * from './number/index.js';
 export * from './object/index.js';
 export * from './promisify.js';

packages/util/src/compact/index.ts

@@ -23,6 +23,6 @@
  */
 
 export { compactAddLength } from './addLength.js';
-export { compactStripLength } from './stripLength.js';
 export { compactFromU8a, compactFromU8aLim } from './fromU8a.js';
+export { compactStripLength } from './stripLength.js';
 export { compactToU8a } from './toU8a.js';

packages/util/src/format/formatBalance.ts

@@ -162,16 +162,16 @@ formatBalance.getOptions = (decimals: number = defaultDecimals): SiDef[] => {
 
 // Sets the default decimals to use for formatting (ui-wide)
 formatBalance.setDefaults = ({ decimals, unit }: SetDefaults): void => {
-  defaultDecimals = decimals === undefined
-    ? defaultDecimals
-    : Array.isArray(decimals)
+  defaultDecimals = (
+    Array.isArray(decimals)
       ? decimals[0]
-      : decimals;
-  defaultUnit = unit === undefined
-    ? defaultUnit
-    : Array.isArray(unit)
+      : decimals
+  ) ?? defaultDecimals;
+  defaultUnit = (
+    Array.isArray(unit)
       ? unit[0]
-      : unit;
+      : unit
+  ) ?? defaultUnit;
 
   SI[SI_MID].text = defaultUnit;
 };

packages/util/src/has.ts

@@ -1,6 +1,8 @@
 // Copyright 2017-2023 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import type { BufferObjConstructor } from './types.js';
+
 import { BigInt } from '@polkadot/x-bigint';
 import { xglobal } from '@polkadot/x-global';
 
@@ -11,10 +13,6 @@ declare const __dirname: unknown;
 declare const module: unknown;
 declare const require: unknown;
 
-// We define a scappy low-level interface to mock Buffer
-// (this removes the need for the node typings in built bundles)
-interface BufTyp extends Function { isBuffer: (value: unknown) => boolean; }
-
 /** true if the environment has proper BigInt support */
 export const hasBigInt = typeof BigInt === 'function' && typeof BigInt.asIntN === 'function';
 
@@ -34,7 +32,7 @@ export const hasWasm = typeof WebAssembly !== 'undefined';
 // that some bundlers such as parcel would add (this is a check, not a use)
 
 /** true if the environment has support for Buffer (typically Node.js) */
-export const hasBuffer = typeof xglobal.Buffer === 'function' && typeof (xglobal.Buffer as BufTyp).isBuffer === 'function';
+export const hasBuffer = typeof xglobal.Buffer === 'function' && typeof (xglobal.Buffer as unknown as BufferObjConstructor).isBuffer === 'function';
 
 /** true if the environment has process available (typically Node.js) */
 export const hasProcess = typeof xglobal.process === 'object';

packages/util/src/is/ascii.ts

@@ -24,7 +24,7 @@ function isAsciiStr (str: AnyString): boolean {
 }
 
 /** @internal */
-function isAsciiBytes (u8a: Uint8Array | Buffer | number[]): boolean {
+function isAsciiBytes (u8a: Uint8Array | number[]): boolean {
   const count = u8a.length | 0;
 
   for (let i = 0; i < count; i++) {

packages/util/src/is/buffer.ts

@@ -1,16 +1,13 @@
 // Copyright 2017-2023 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import type { BufferObj, BufferObjConstructor } from '../types.js';
+
 import { xglobal } from '@polkadot/x-global';
 
 import { hasBuffer } from '../has.js';
 import { isFunction } from './function.js';
 
-// We define a scappy low-level interface to mock Buffer
-// (this removes the need for the node typings in built bundles)
-interface BufTyp extends Function { isBuffer: (value: unknown) => boolean }
-interface BufObj { readDoubleLE: (...args: unknown[]) => unknown }
-
 /**
  * @name isBuffer
  * @summary Tests for a `Buffer` object instance.
@@ -27,5 +24,5 @@ interface BufObj { readDoubleLE: (...args: unknown[]) => unknown }
  */
 export function isBuffer (value: unknown): value is Buffer {
   // we do check a function first, since it is slightly faster than isBuffer itself
-  return hasBuffer && isFunction(value && (value as unknown as BufObj).readDoubleLE) && (xglobal.Buffer as BufTyp).isBuffer(value);
+  return hasBuffer && !!value && isFunction((value as unknown as BufferObj).readDoubleLE) && (xglobal.Buffer as unknown as BufferObjConstructor).isBuffer(value);
 }

packages/util/src/is/childClass.ts

@@ -20,7 +20,7 @@ import { isClass } from './class.js';
  * console.log('isChildClass', isChildClass(BN, Uint8Array); // => false
  * ```
  */
-export function isChildClass <P extends Constructor> (Parent: P, Child?: Constructor | null | unknown): Child is P {
+export function isChildClass <P extends Constructor> (Parent: P, Child?: unknown): Child is P {
   // https://stackoverflow.com/questions/30993434/check-if-a-constructor-inherits-another-in-es6/30993664
   return isClass(Child) && isClass(Parent)
     // eslint-disable-next-line no-prototype-builtins