[CI Skip] release/stable 5.0.1

skip-checks: true

.123trigger

@@ -1 +1,8 @@
-4
+7
+
+3.2.2
+3.2.3
+3.2.4
+
+4.0.2
+4.1.2

.babelrc.js

@@ -1,5 +0,0 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-module.exports = require('./babel.config.js');

.codeclimate.yml

@@ -1,4 +1,20 @@
+checks:
+  argument-count:
+    config:
+      threshold: 5
+  method-complexity:
+    config:
+      threshold: 7
+  method-count:
+    config:
+      threshold: 25
+  method-lines:
+    config:
+      threshold: 30
+
 exclude_patterns:
 - "**/*.spec.js"
 - "**/*.spec.ts"
 - "docs/**/*.js"
+- "**/test/**/*.js"
+- "packages/wasm-crypto-wasm/src/fflate.ts"

.eslintignore

@@ -1,8 +0,0 @@
-.eslintrc.js
-.github/**
-.vscode/**
-.yarn/**
-**/binaryen/*
-**/build/*
-**/coverage/*
-**/node_modules/*

.eslintrc.js

@@ -1,15 +1,19 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
 
-const base = require('@polkadot/dev/config/eslint');
+const base = require('@polkadot/dev/config/eslint.cjs');
 
 module.exports = {
   ...base,
+  ignorePatterns: [
+    ...base.ignorePatterns,
+    '**/target/*',
+    'packages/bytes/*'
+  ],
   parserOptions: {
     ...base.parserOptions,
     project: [
-      './tsconfig.json'
+      './tsconfig.eslint.json'
     ]
   }
 };

.github/workflows/auto-approve.yml

@@ -0,0 +1,16 @@
+name: bot
+
+on:
+  pull_request:
+    types: [labeled]
+
+jobs:
+  approve:
+    if: "! startsWith(github.event.head_commit.message, '[CI Skip]') && (!github.event.pull_request || github.event.pull_request.head.repo.full_name == github.repository)"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: jacogr/action-approve@master
+        with:
+          authors: jacogr
+          labels: -auto
+          token: ${{ secrets.GH_PAT_BOT }}

.github/workflows/auto-merge.yml

@@ -0,0 +1,16 @@
+name: bot
+
+on:
+  pull_request:
+    types: [labeled]
+
+jobs:
+  merge:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: jacogr/action-merge@master
+        with:
+          checks: build,lint,test
+          labels: -auto
+          strategy: squash
+          token: ${{ secrets.GH_PAT_BOT }}

.github/workflows/lock.yml

@@ -0,0 +1,25 @@
+name: 'Lock Threads'
+
+on:
+  schedule:
+    - cron: '20 1/3 * * *'
+
+jobs:
+  lock:
+    runs-on: ubuntu-latest
+    env:
+      YARN_ENABLE_SCRIPTS: false
+    steps:
+      - uses: dessant/lock-threads@v2
+        with:
+          github-token: ${{ secrets.GH_PAT_BOT }}
+          issue-lock-inactive-days: '7'
+          issue-lock-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: >
+            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.

.github/workflows/pr-any.yml

@@ -8,9 +8,12 @@ jobs:
         step: ['lint', 'test', 'build']
     name: ${{ matrix.step }}
     runs-on: ubuntu-latest
+    env:
+      YARN_ENABLE_SCRIPTS: false
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v2
     - name: ${{ matrix.step }}
       run: |
         yarn install --immutable | grep -v 'YN0013'
+        ./scripts/install-build-deps.sh
         yarn ${{ matrix.step }}

.github/workflows/push-master.yml

@@ -6,29 +6,25 @@ on:
 
 jobs:
   master:
+    if: "! startsWith(github.event.head_commit.message, '[CI Skip]')"
     strategy:
       matrix:
         step: ['build:release']
     name: ${{ matrix.step }}
-    if: "! startsWith(github.event.head_commit.message, '[CI Skip]') && github.repository == 'polkadot-js/wasm'"
     runs-on: ubuntu-latest
+    env:
+      YARN_ENABLE_SCRIPTS: false
+      CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
+      GH_PAT: ${{ secrets.GH_PAT }}
+      GH_RELEASE_GITHUB_API_TOKEN: ${{ secrets.GH_PAT }}
+      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v2
       with:
+        fetch-depth: 0
         token: ${{ secrets.GH_PAT }}
     - name: build
-      env:
-        CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
-        GH_PAT: ${{ secrets.GH_PAT }}
-        GH_RELEASE_GITHUB_API_TOKEN: ${{ secrets.GH_PAT }}
-        NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
       run: |
         yarn install --immutable | grep -v 'YN0013'
+        ./scripts/install-build-deps.sh
         yarn ${{ matrix.step }}
-
-  dummy:
-    runs-on: ubuntu-latest
-    steps:
-    - name: dummy
-      run: |
-        echo "Dummy skip step"

.github/workflows/semgrep.yml

@@ -0,0 +1,20 @@
+name: Semgrep
+on:
+  pull_request: {}
+  push:
+    branches:
+      - master
+
+jobs:
+  check:
+    if: "! startsWith(github.event.head_commit.message, '[CI Skip]') && (!github.event.pull_request || github.event.pull_request.head.repo.full_name == github.repository)"
+    runs-on: ubuntu-latest
+    env:
+      YARN_ENABLE_SCRIPTS: false
+    steps:
+      - uses: actions/checkout@v2
+      - uses: returntocorp/semgrep-action@v1
+        with:
+          auditOn: push
+          publishToken: ${{ secrets.SEMGREP_APP_TOKEN }}
+          publishDeployment: 1395

.github/workflows/stale.yml

@@ -0,0 +1,19 @@
+name: 'Close stale issues and PRs'
+on:
+  schedule:
+    - cron: '35 1/3 * * *'
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    env:
+      YARN_ENABLE_SCRIPTS: false
+    steps:
+      - uses: actions/stale@v3
+        with:
+          repo-token: ${{ secrets.GH_PAT_BOT }}
+          stale-issue-message: 'This issue has been open for 21 days with no activity and is not labelled as an enhancement. It will be closed in 7 days.'
+          stale-issue-label: 'stale'
+          exempt-issue-labels: '-size-l,-size-m,-size-s,-size-xl,-size-xs,[bug]'
+          days-before-stale: 21
+          days-before-close: 7

.gitignore

@@ -1,26 +1,31 @@
-binaryen*
+binaryen/
+bindgen/
 build/
 build-docs/
+bytes/
 coverage/
 docs/.vuepress/dist/
 node_modules/
 pkg/
 target/
 tmp/
+wabt/
 .DS_Store
 .env.local
 .env.development.local
 .env.test.local
 .env.production.local
 .npmrc
+.pnp.*
 .yarn/*
 !.yarn/releases
 !.yarn/plugins
-.pnp.*
+!.yarn/sdks
 cc-test-reporter
 lerna-debug.log*
 npm-debug.log*
 package-lock.json
 report.*.json
+tsconfig.*buildinfo
 yarn-debug.log*
 yarn-error.log*

.mailmap

@@ -0,0 +1,3 @@
+Jaco <jacogr@gmail.com>
+github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> <action@github.com>
+github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> Github Actions <action@github.com>

.nvmrc

@@ -1 +0,0 @@
-10

.prettierignore

@@ -0,0 +1,4 @@
+build
+coverage
+packages
+scripts

.prettierrc.cjs

@@ -0,0 +1,4 @@
+// Copyright 2017-2022 @polkadot/dev authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+module.exports = require('@polkadot/dev/config/prettier.cjs');

.vscode/settings.json

@@ -1,11 +0,0 @@
-{
-  "editor.tabSize": 2,
-  "files.eol": "\n",
-  "npm.packageManager": "yarn",
-  "eslint.enable": true,
-  "eslint.validate": [
-    "javascript",
-    "typescript",
-    "typescriptreact"
-  ]
-}

.yarnrc.yml

@@ -5,7 +5,9 @@ enableProgressBars: false
 nodeLinker: node-modules
 
 plugins:
-  - path: .yarn/plugins/@yarnpkg/plugin-interactive-tools.js
+  - path: .yarn/plugins/@yarnpkg/plugin-interactive-tools.cjs
     spec: "@yarnpkg/plugin-interactive-tools"
+  - path: .yarn/plugins/@yarnpkg/plugin-version.cjs
+    spec: "@yarnpkg/plugin-version"
 
-yarnPath: .yarn/releases/yarn-2.1.1.js
+yarnPath: .yarn/releases/yarn-3.2.0.cjs

CHANGELOG.md

@@ -1,92 +1,317 @@
 # CHANGELOG
 
+## 5.0.1 Mar 19, 2022
+
+- **Breaking change** For users of React Native, you are now required to add `import '@polkadot/wasm-crypto/initOnlyAsm'` at your project top-level to ensure that asm.js is initialized. (Or alternatively `import '@polkadot/wasm-crypto/initWasmAsm'` to future-proof when WASM does become available)
+- **Breaking change** For users who used to map the `data` and `empty` of the internal `wasm-crypto-{wasm, asmjs}` packages in their bundlers, swap to one of the `@polkadot/wasm-crypto/init*` top-level imports to set the type of interfaces you would prefer.
+
+Changes:
+
+- Add (optional) `@polkadot/wasm-crypto/init{OnlyAsm, OnlyWasm, WasmAsm}` to allow specific interface types
+- Add work-around for lazy secp256k1 init in asm.js environments
+- Optimize asm.js output size
+- Use latest `wasm-bindgen`, `binaryen` & `wabt` packages in build
+- Additional workaround for Vite bundling
+
+
+## 4.6.1 Mar 12, 2022
+
+Changes:
+
+- Adjust ed25519 internals, consistency in code
+- Ensure package path is available under ESM & CJS
+- JS wrapped bytes interoperability test
+- Adjust for bundlers where `import.meta.url` is undefined
+
+
+## 4.5.1 Dec 3, 2021
+
+Changes:
+
+- Add `secp256k1{Compress, Expand, Recover, Sign}` functions
+- Remove all occurences of `.unwrap()` (match everywhere)
+- Adjust and optimize WASM function JS interface construction
+- Simplify base64 bytes decoding on construction
+
+
+## 4.4.1 Nov 22, 2021
+
+Changes:
+
+- Add `hmacSha256` & `hmacSha512` functions
+
+
+## 4.3.1 Nov 19, 2021
+
+Contributed:
+
+- Updated package.json to include repo (Thanks to https://github.com/v-zhzhou)
+
+Changes:
+
+- Add `keccak512` function
+- Add `sha256` function
+
+
+## 4.2.1 Aug 28, 2021
+
+Contributed:
+
+- Add sr25519 agreement external (Thanks to https://github.com/shelvenzhou)
+
+Changes:
+
+- Adjust tests to align with JS coding standards
+- Allow for optional build with Rust stable bootstrap
+
+
+## 4.1.2 Jul 9, 2021
+
+Changes:
+
+- Bump `@polkadot/dev` to allow for bundles with new-format
+
+
+## 4.1.1 Jul 7, 2021
+
+Changes:
+
+- Add an explicit `engines` field to `package.json`
+- Allow building as a completely stand-alone browser bundle (experimental)
+
+
+## 4.0.2 Mar 5, 2021
+
+Changes:
+
+- Add import indirection for both CJS & ESM (where generated source file is commonjs)
+
+
+## 4.0.1 Mar 4, 2021
+
+**Important** In the 4.0 version the default package type has been changed to ESM modules by default. This should not affect usage, however since the output formats changed, a new major version is required.
+
+Changes:
+
+- Build to ESM by default (with cjs versions via export map)
+
+
+## 3.2.4 Feb 24, 2021
+
+Changes:
+
+- Cleanup implicit dependencies, perform base64 decoding using base64-js
+
+
+## 3.2.3 Feb 16, 2021
+
+Changes:
+
+- Change package detect import to use `.js` source, not `.json`
+
+
+## 3.2.2 Jan 24, 2021
+
+Changes:
+
+- Remove `module` field in `package.json`
+
+
+## 3.2.1 Jan 22, 2021
+
+Contributed:
+
+- Expose sr25519 `ext_vrf_{sign, verify}` methods (Thanks to https://github.com/stiiifff)
+
+Changes:
+
+- Add explicit `.editorconfig` for Rust sources
+- Remove unused code bundles (`vrf_{sign,verify}_extra`, `secp256k1` with tests)
+- Test run wrapper cleanups
+
+
+## 3.1.1 Dec 19, 2020
+
+Changes:
+
+- Single-instance package detection
+- Adjust WASM inflate with localized methods
+
+
+## 3.0.1 Dec 13, 2020
+
+**Important** This assumes `@polkadot/util` 5+ peerDependencies
+**Important** While this package contains no external interface changes, it doe now compile and ship both cjs and esm modules. This means that modern bundlers will have more information for tree-shaking available. Additionally when using Node with `.mjs` extensions, the esm version imports will be used on recent Node versions. Adding an export map, as here, may have some impacts so a major semver bump is advised. There may be (small) dragons hiding in the dark corners...
+
+Changes:
+
+- Build and expose both cjs and esm via exports map
+- Split wasm and asmjs files into the `@polkadot/wasm-crypto-{wasm,asmjs}` packages
+- Add fflate WASM compression, with 180K raw savings (37K over-the-wire)
+- Convert the package to full TypeScript sources
+
+
+## 2.0.1 Nov 8, 2020
+
+Changes:
+
+- Rework generation of WASM interfaces (proper cross-platform JS support)
+- Remove explicit `crypto` dependency, this is now applied by `@polkadot/x-randomvalues`
+- Build via xargo for panic abort, an overall small sizes without stack (Pinned nightly)
+- Move Rust library sources in to `rs/` subfolder
+
+
+## 1.4.1 Aug 27, 2020
+
+Changes:
+
+- Re-add the BTC/ETH compatible `bip39ToSeed` dropped in the previous version (ETH-compatible pairs)
+
+
 ## 1.3.1 Aug 9, 2020
 
+Changes:
+
 - Add `scrypt` function for KDF generation
 - Remove `bip39ToSeed`, we only use the `bip39ToMiniSecret` variant in Substrate
 - Update ed25519-dalek to 1.0.0-pre.4
 - Rework generation based on latest wasm-pack generator
 
+
 ## 1.2.1 Feb 29, 2020
 
+Changes:
+
 - Adjust build process for smaller wasm bundle outputs (~50K dropped from base bundle)
 - Unpin nightly from nightly-2020-02-17 version
 - Swap to yarn 2 and add support for use by yarn 2 projects
 
+
 ## 1.1.1 Feb 24, 2020
 
 - **Important** The sr25519 interface dropped the use of `verify_simple_preaudit_deprecated` for signature verification, instead it now uses `verify_simple`. Only schnorrkel 0.8+ signatures will now pass verification. This is a follow-up of the 0.1 signing support that was dropped in a previous version.
+
+Changes:
+
 - Rework schnorrkel signatures test vectors based on the above change (Rust, WASM and ASM.js tests)
 - Rust nightly pinned to last-known-working 2020-02-17 on CI (compiler issues, should to be reverted in a future release)
 
+
 ## 1.0.1 Feb 15, 2020
 
+Changes:
+
 - No functionality changes from 0.20.1. The interfaces here are stable in the current iteration.
 
+
 ## 0.20.1 Jan 30, 2020
 
+Changes:
+
 - Pull in schnorrkel 0.8.5 for full Substrate 2.x compatibility
 
+
 ## 0.14.1 Sep 09, 2019
 
+Changes:
+
 - No functionality changes at all, everything done is "under the hood" to give the codebase better maintainability
 
+
 ## 0.13.1 Jul 20, 2019
 
+Changes:
+
 - Added an asm.js fallback which is active for React Native via the `"react-native"` entry in `package.json`. Ensure that you run the build step with the `NODE_OPTIONS=--max_old_space_size=8192` flags, since the asm.js bundle is large. (For RN the full command would therefore be `NODE_OPTIONS=--max_old_space_size=8192 npm start`)
 
+
 ## 0.12.1 Jul 17, 2019
 
+Changes:
+
 - Remove deprecated `@polkadot/wasm-schnorrkel` & `@polkadot/wasm-dalek-ed25519` source (all combined in `@polkadot/wasm-crypto`, was kept for historical purposes)
 - Security dependency bumps
 - Updated Rust `hex-literal` for recent versions of the compiler (used in tests only)
 
+
 ## 0.11.1 May 31, 2019
 
+Changes:
+
 - Security dependency bumps
 
+
 ## 0.10.1 May 09, 2019
 
+Changes:
+
 - w3f/schnorrkel updated to 0.1.1 as per substrate
 - Added known subkey signature test (Rust & JS)
 
+
 ## 0.9.1 Apr 29, 2019
 
+Changes:
+
 - Dependency bumps
 
+
 ## 0.8.1 Mar 31, 2019
 
+Changes:
+
 - Pull ed25519 & sr25519 into `@polkadot/wasm-crypto` as well (smaller final size)
 - Disable build/publish of `wasm-dalek-ed25519` & `wasm-schnorrkel`
 - Improve error messaging, instead of `__wasm_malloc of null`
 
+
 ## 0.7.1 Mar 30, 2019
 
+Changes:
+
 - Fix build scripts to properly attach errors in the log (dropped in 0.6.1)
 
+
 ## 0.6.1 Mar 27, 2019
 
+Changes:
+
 - Log init errors for both non-WebAssembly usage as well as WebAssembly errors
 
+
 ## 0.5.1 Mar 23, 2019
 
+Changes:
+
 - Add password argument to bip39ToSeed
 
+
 ## 0.4.1 Mar 23, 2019
 
+Changes:
+
 - Add bip39ToSeed
 
+
 ## 0.3.1 Mar 23, 2019
 
+Changes:
+
 - Add wasm-dalek-ed25519 for all used crypto there
 - Add keccak256
 - Try secp256k1 (bloating code, not used atm)
 
+
 ## 0.2.1 Mar 20, 2019
 
+Changes:
+
 - Add basic crypto functions, creation of wasm-crypto package
 - blake2, bip39, sha2, xxhash
 
+
 ## 0.1.1 Mar 18, 2019
 
+Changes:
+
 - Initial release

CONTRIBUTORS

@@ -0,0 +1,5 @@
+     384	Jaco                          	5.0.1 (#312)
+       1	Evgeny                        	Fixed type (#121)
+       1	Shunfan Zhou                  	Support sr25519 agreement (#209)
+       1	Steve Degosserie              	Expose Schnorrkel's VRF capabilities (#170)
+       1	Zhongpeng Zhou                	Update package.json to include the repository (#220)

babel.config.cjs

@@ -0,0 +1,4 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+module.exports = require('@polkadot/dev/config/babel-config-cjs.cjs');

babel.config.js

@@ -1,5 +0,0 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-module.exports = require('@polkadot/dev/config/babel');

docs/404.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="initial-scale=0.5, maximum-scale=1">
+    <meta http-equiv="refresh" content="0;URL='https://polkadot.js.org/docs/'" />
+    <title>Redirecting to https://polkadot.js.org/docs/</title>
+  </head>
+  <body>
+    Redirecting to <a href="https://polkadot.js.org/docs/">https://polkadot.js.org/docs/</a>
+  </body>
+</html>

docs/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="initial-scale=0.5, maximum-scale=1">
+    <meta http-equiv="refresh" content="0;URL='https://polkadot.js.org/docs/'" />
+    <title>Redirecting to https://polkadot.js.org/docs/</title>
+  </head>
+  <body>
+    Redirecting to <a href="https://polkadot.js.org/docs/">https://polkadot.js.org/docs/</a>
+  </body>
+</html>

jest.config.cjs

@@ -0,0 +1,13 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const config = require('@polkadot/dev/config/jest.cjs');
+
+module.exports = {
+  ...config,
+  moduleNameMapper: {
+    '@polkadot/wasm-crypto-(asmjs|wasm)(.*)$': '<rootDir>/packages/wasm-crypto-$1/build/$2',
+    // eslint-disable-next-line sort-keys
+    '@polkadot/wasm-crypto(.*)$': '<rootDir>/packages/wasm-crypto/src/$1'
+  }
+};

jest.config.js

@@ -1,15 +0,0 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-const config = require('@polkadot/dev/config/jest');
-
-module.exports = Object.assign({}, config, {
-  moduleNameMapper: {
-    '@polkadot/wasm-(schnorrkel)(.*)$': '<rootDir>/packages/wasm-$1/src/$2'
-  },
-  modulePathIgnorePatterns: [
-    '<rootDir>/packages/wasm-schnorrkel/build'
-  ],
-  resolver: './jest.resolver.js'
-});

jest.resolver.js

@@ -1,11 +0,0 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-const path = require('path');
-
-module.exports = function resolver (file, config) {
-  return file.includes('package.json')
-    ? path.join(config.basedir.replace('/src', '/'), file)
-    : config.defaultResolver(file, config);
-};

lerna.json

@@ -1,13 +0,0 @@
-{
-  "npmClient": "yarn",
-  "useWorkspaces": true,
-  "command": {
-    "publish": {
-      "allowBranch": "master"
-    }
-  },
-  "packages": [
-    "packages/*"
-  ],
-  "version": "1.3.1"
-}

package.json

@@ -1,25 +1,41 @@
 {
-  "repository": "https://github.com/polkadot-js/wasm",
   "author": "Jaco Greeff <jacogr@gmail.com>",
-  "license": "Apache-2",
+  "bugs": "https://github.com/polkadot-js/wasm/issues",
+  "homepage": "https://github.com/polkadot-js/wasm#readme",
+  "license": "Apache-2.0",
+  "packageManager": "yarn@3.2.0",
   "private": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/polkadot-js/wasm.git"
+  },
+  "sideEffects": false,
+  "version": "5.0.1",
   "workspaces": [
     "packages/*"
   ],
-  "resolutions": {
-    "babel-core": "^7.0.0-bridge.0"
-  },
   "scripts": {
-    "build": "NIGHTLY= ./scripts/build.sh",
-    "build:release": "NIGHTLY= ./scripts/build-release.sh",
-    "lint": "polkadot-dev-run-lint",
+    "build": "yarn build:wasm",
+    "build:js": "./scripts/build-js.sh",
+    "build:release": "polkadot-ci-ghact-build",
+    "build:rollup": "polkadot-exec-rollup --config",
+    "build:wasm": "./scripts/build.sh",
     "clean": "./scripts/clean.sh",
+    "lint": "polkadot-dev-run-lint",
     "postinstall": "polkadot-dev-yarn-only",
-    "test": "./scripts/test-rust.sh"
+    "test": "yarn test:wasm:rust",
+    "test:wasm:js": "yarn test:wasm:js:jest && yarn test:wasm:js:node",
+    "test:wasm:js:jest": "polkadot-dev-run-test ./test/jest.spec.js",
+    "test:wasm:js:node": "cd packages/wasm-crypto && node ./test/wasm.cjs && node ./test/asm.cjs",
+    "test:wasm:rust": "cd packages/wasm-crypto && RUST_BACKTRACE=full cargo test --release -- --nocapture"
   },
   "devDependencies": {
-    "@babel/core": "^7.11.1",
-    "@polkadot/dev": "^0.55.35"
+    "@babel/core": "^7.17.8",
+    "@polkadot/dev": "^0.65.97",
+    "fflate": "^0.7.3",
+    "override-require": "^1.1.1"
   },
-  "version": "1.3.1"
+  "resolutions": {
+    "typescript": "^4.6.2"
+  }
 }

packages/wasm-crypto-asmjs/package.json

@@ -0,0 +1,31 @@
+{
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/polkadot-js/wasm/issues",
+  "contributors": [],
+  "description": "Asm.js content for wasm-crypto",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "homepage": "https://github.com/polkadot-js/wasm/tree/master/packages/wasm-crypto-asmjs#readme",
+  "license": "Apache-2.0",
+  "maintainers": [],
+  "name": "@polkadot/wasm-crypto-asmjs",
+  "repository": {
+    "directory": "packages/wasm-crypto-asmjs",
+    "type": "git",
+    "url": "https://github.com/polkadot-js/wasm.git"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "version": "5.0.1",
+  "main": "index.js",
+  "dependencies": {
+    "@babel/runtime": "^7.17.8"
+  },
+  "devDependencies": {
+    "@polkadot/util": "^8.5.1"
+  },
+  "peerDependencies": {
+    "@polkadot/util": "*"
+  }
+}

packages/wasm-crypto-asmjs/src/bundle.ts

@@ -0,0 +1,8 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto-asmjs authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { asmJsInit as _asmJsInit } from './cjs/data.js';
+
+export { packageInfo } from './packageInfo';
+
+export const asmJsInit = _asmJsInit;

packages/wasm-crypto-asmjs/src/cjs/data.d.ts

@@ -0,0 +1,4 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto-asmjs authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export declare const asmJsInit: null;

packages/wasm-crypto-asmjs/src/cjs/data.js

@@ -0,0 +1,6 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto-asmjs authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const asmJsInit = null;
+
+exports.asmJsInit = asmJsInit;

packages/wasm-crypto-asmjs/src/cjs/package.json

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

packages/wasm-crypto-asmjs/src/detectOther.ts

@@ -0,0 +1,4 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto-asmjs authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export default [];

packages/wasm-crypto-asmjs/src/detectPackage.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2022 @polkadot/wasm-crypto-asmjs authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+
+import { detectPackage } from '@polkadot/util';
+
+import others from './detectOther';
+import { packageInfo } from './packageInfo';
+
+detectPackage(packageInfo, null, others);

packages/wasm-crypto-asmjs/src/index.ts

@@ -0,0 +1,6 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto-asmjs authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import './detectPackage';
+
+export * from './bundle';

packages/wasm-crypto-asmjs/src/packageInfo.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2022 @polkadot/wasm-crypto-asmjs authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+
+export const packageInfo = { name: '@polkadot/wasm-crypto-asmjs', path: 'auto', type: 'auto', version: '5.0.1' };

packages/wasm-crypto-asmjs/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "references": []
+}

packages/wasm-crypto-wasm/package.json

@@ -0,0 +1,31 @@
+{
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/polkadot-js/wasm/issues",
+  "contributors": [],
+  "description": "Wasm content for wasm-crypto",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "homepage": "https://github.com/polkadot-js/wasm/tree/master/packages/wasm-crypto-wasm#readme",
+  "license": "Apache-2.0",
+  "maintainers": [],
+  "name": "@polkadot/wasm-crypto-wasm",
+  "repository": {
+    "directory": "packages/wasm-crypto-wasm",
+    "type": "git",
+    "url": "https://github.com/polkadot-js/wasm.git"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "version": "5.0.1",
+  "main": "index.js",
+  "dependencies": {
+    "@babel/runtime": "^7.17.8"
+  },
+  "devDependencies": {
+    "@polkadot/util": "^8.5.1"
+  },
+  "peerDependencies": {
+    "@polkadot/util": "*"
+  }
+}

packages/wasm-crypto-wasm/src/base64.ts

@@ -0,0 +1,22 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+export function base64Decode (data: string): Uint8Array {
+  const bytes = [];
+  let byte = 0;
+  let bits = 0;
+
+  for (let i = 0; i < data.length && data[i] !== '='; i++) {
+    // each character represents 6 bits
+    byte = (byte << 6) | chars.indexOf(data[i]);
+
+    // each byte needs to contain 8 bits
+    if ((bits += 6) >= 8) {
+      bytes.push((byte >>> (bits -= 8)) & 0xff);
+    }
+  }
+
+  return Uint8Array.from(bytes);
+}

packages/wasm-crypto-wasm/src/bundle.ts

@@ -0,0 +1,10 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto-wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { base64Decode } from './base64';
+import { bytes, sizeUncompressed } from './bytes';
+import { unzlibSync } from './fflate';
+
+export { packageInfo } from './packageInfo';
+
+export const wasmBytes = unzlibSync(base64Decode(bytes), new Uint8Array(sizeUncompressed));

packages/wasm-crypto-wasm/src/bytes.ts

@@ -0,0 +1,10 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto-wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { bytes as _bytes, sizeCompressed as _sizeCompressed, sizeUncompressed as _sizeUncompressed } from './cjs/bytes';
+
+export const bytes = _bytes;
+
+export const sizeCompressed = _sizeCompressed;
+
+export const sizeUncompressed = _sizeUncompressed;

packages/wasm-crypto-wasm/src/cjs/bytes.d.ts

@@ -0,0 +1,6 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto-wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export declare const bytes = '';
+export declare const sizeCompressed = 0;
+export declare const sizeUncompressed = 0;

packages/wasm-crypto-wasm/src/cjs/bytes.js

@@ -0,0 +1,8 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto-wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+exports.bytes = '';
+
+exports.sizeCompressed = 0;
+
+exports.sizeUncompressed = 0;

packages/wasm-crypto-wasm/src/cjs/package.json

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

packages/wasm-crypto-wasm/src/detectOther.ts

@@ -0,0 +1,4 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto-wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export default [];

packages/wasm-crypto-wasm/src/detectPackage.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2022 @polkadot/wasm-crypto-wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+
+import { detectPackage } from '@polkadot/util';
+
+import others from './detectOther';
+import { packageInfo } from './packageInfo';
+
+detectPackage(packageInfo, null, others);

packages/wasm-crypto-wasm/src/fflate.ts

@@ -0,0 +1,342 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// MIT License
+//
+// Copyright (c) 2020 Arjun Barrett
+//
+// Copied from https://github.com/101arrowz/fflate/blob/73c737941ec89d85cdf0ad39ee6f26c5fdc95fd7/src/index.ts
+// This only contains the unzlibSync function, no compression, no async, no workers
+//
+// These 2 issues are addressed as a short-term, stop-gap solution
+//   - https://github.com/polkadot-js/api/issues/2963
+//   - https://github.com/101arrowz/fflate/issues/17
+//
+// Only tweaks make here are some TS adjustments (we use strict null checks), the code is otherwise as-is with
+// only the single required function provided (compression is still being done in the build with fflate)
+
+/* eslint-disable */
+
+// inflate state
+type InflateState = {
+  // lmap
+  l?: Uint16Array;
+  // dmap
+  d?: Uint16Array;
+  // lbits
+  m?: number;
+  // dbits
+  n?: number;
+  // final
+  f?: number;
+  // pos
+  p?: number;
+  // byte
+  b?: number;
+  // lstchk
+  i?: boolean;
+};
+
+// aliases for shorter compressed code (most minifers don't do this)
+const u8 = Uint8Array, u16 = Uint16Array, u32 = Uint32Array;
+
+// code length index map
+const clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+
+// fixed length extra bits
+const fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);
+
+// fixed distance extra bits
+// see fleb note
+const fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);
+
+// get base, reverse index map from extra bits
+const freb = (eb: Uint8Array, start: number) => {
+  const b = new u16(31);
+  for (let i = 0; i < 31; ++i) {
+    b[i] = start += 1 << eb[i - 1];
+  }
+  // numbers here are at max 18 bits
+  const r = new u32(b[30]);
+  for (let i = 1; i < 30; ++i) {
+    for (let j = b[i]; j < b[i + 1]; ++j) {
+      r[j] = ((j - b[i]) << 5) | i;
+    }
+  }
+  return [b, r] as const;
+}
+
+const [fl, revfl] = freb(fleb, 2);
+// we can ignore the fact that the other numbers are wrong; they never happen anyway
+fl[28] = 258, revfl[258] = 28;
+const [fd] = freb(fdeb, 0);
+
+// map of value to reverse (assuming 16 bits)
+const rev = new u16(32768);
+for (let i = 0; i < 32768; ++i) {
+  // reverse table algorithm from SO
+  let x = ((i & 0xAAAA) >>> 1) | ((i & 0x5555) << 1);
+  x = ((x & 0xCCCC) >>> 2) | ((x & 0x3333) << 2);
+  x = ((x & 0xF0F0) >>> 4) | ((x & 0x0F0F) << 4);
+  rev[i] = (((x & 0xFF00) >>> 8) | ((x & 0x00FF) << 8)) >>> 1;
+}
+
+// create huffman tree from u8 "map": index -> code length for code index
+// mb (max bits) must be at most 15
+// TODO: optimize/split up?
+const hMap = ((cd: Uint8Array, mb: number, r: 0 | 1) => {
+  const s = cd.length;
+  // index
+  let i = 0;
+  // u16 "map": index -> # of codes with bit length = index
+  const l = new u16(mb);
+  // length of cd must be 288 (total # of codes)
+  for (; i < s; ++i) ++l[cd[i] - 1];
+  // u16 "map": index -> minimum code for bit length = index
+  const le = new u16(mb);
+  for (i = 0; i < mb; ++i) {
+    le[i] = (le[i - 1] + l[i - 1]) << 1;
+  }
+  let co: Uint16Array;
+  if (r) {
+    // u16 "map": index -> number of actual bits, symbol for code
+    co = new u16(1 << mb);
+    // bits to remove for reverser
+    const rvb = 15 - mb;
+    for (i = 0; i < s; ++i) {
+      // ignore 0 lengths
+      if (cd[i]) {
+        // num encoding both symbol and bits read
+        const sv = (i << 4) | cd[i];
+        // free bits
+        const r = mb - cd[i];
+        // start value
+        let v = le[cd[i] - 1]++ << r;
+        // m is end value
+        for (const m = v | ((1 << r) - 1); v <= m; ++v) {
+          // every 16 bit value starting with the code yields the same result
+          co[rev[v] >>> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i = 0; i < s; ++i) co[i] = rev[le[cd[i] - 1]++] >>> (15 - cd[i]);
+  }
+  return co;
+});
+
+// fixed length tree
+const flt = new u8(288);
+for (let i = 0; i < 144; ++i) flt[i] = 8;
+for (let i = 144; i < 256; ++i) flt[i] = 9;
+for (let i = 256; i < 280; ++i) flt[i] = 7;
+for (let i = 280; i < 288; ++i) flt[i] = 8;
+// fixed distance tree
+const fdt = new u8(32);
+for (let i = 0; i < 32; ++i) fdt[i] = 5;
+
+// fixed length map
+const flrm = hMap(flt, 9, 1);
+// fixed distance map
+const fdrm = hMap(fdt, 5, 1);
+
+// read d, starting at bit p and mask with m
+const bits = (d: Uint8Array, p: number, m: number) => {
+  const o = p >>> 3;
+  return ((d[o] | (d[o + 1] << 8)) >>> (p & 7)) & m;
+}
+
+// read d, starting at bit p continuing for at least 16 bits
+const bits16 = (d: Uint8Array, p: number) => {
+  const o = p >>> 3;
+  return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >>> (p & 7));
+}
+
+// get end of byte
+const shft = (p: number) => (p >>> 3) + (p & 7 && 1);
+
+// typed array slice - allows garbage collector to free original reference,
+// while being more compatible than .slice
+const slc = <T extends Uint8Array | Uint16Array | Uint32Array>(v: T, s: number, e?: number): T => {
+  if (s == null || s < 0) s = 0;
+  if (e == null || e > v.length) e = v.length;
+  // can't use .constructor in case user-supplied
+  const n = new (v instanceof u16 ? u16 : v instanceof u32 ? u32 : u8)(e - s) as T;
+  n.set(v.subarray(s, e));
+  return n;
+}
+
+// find max of array
+const max = (a: Uint8Array | number[]) => {
+  let m = a[0];
+  for (let i = 1; i < a.length; ++i) {
+    if (a[i] > m) m = a[i];
+  }
+  return m;
+};
+
+// expands raw DEFLATE data
+const inflt = (dat: Uint8Array, buf?: Uint8Array, st?: InflateState) => {
+  const noSt = !st || st.i;
+  if (!st) st = {};
+  // source length
+  const sl = dat.length;
+  // have to estimate size
+  const noBuf = !buf || !noSt;
+  // Assumes roughly 33% compression ratio average
+  if (!buf) buf = new u8(sl * 3);
+  // ensure buffer can fit at least l elements
+  const cbuf = (l: number) => {
+    let bl = buf!.length;
+    // need to increase size to fit
+    if (l > bl) {
+      // Double or set to necessary, whichever is greater
+      const nbuf = new u8(Math.max(bl << 1, l));
+      nbuf.set(buf!);
+      buf = nbuf;
+    }
+  };
+  //  last chunk         bitpos           bytes
+  let final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+  if (final && !lm) return buf;
+  // total bits
+  const tbts = sl << 3;
+  do {
+    if (!lm) {
+      // BFINAL - this is only 1 when last chunk is next
+      st.f = final = bits(dat, pos, 1);
+      // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman
+      const type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        // go to end of byte boundary
+        const s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;
+        if (t > sl) {
+          if (noSt) throw 'unexpected EOF';
+          break;
+        }
+        // ensure size
+        if (noBuf) cbuf(bt + l);
+        // Copy over uncompressed data
+        buf.set(dat.subarray(s, t), bt);
+        // Get new bitpos, update byte count
+        st.b = bt += l, st.p = pos = t << 3;
+        continue;
+      }
+      else if (type == 1) lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        //  literal                            lengths
+        const hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        const tl = hLit + bits(dat, pos + 5, 31) + 1;
+        pos += 14;
+        // length+distance tree
+        const ldt = new u8(tl);
+        // code length tree
+        const clt = new u8(19);
+        for (let i = 0; i < hcLen; ++i) {
+          // use index map to get real code
+          clt[clim[i]] = bits(dat, pos + i * 3, 7);
+        }
+        pos += hcLen * 3;
+        // code lengths bits
+        const clb = max(clt), clbmsk = (1 << clb) - 1;
+        if (!noSt && pos + tl * (clb + 7) > tbts) break;
+        // code lengths map
+        const clm = hMap(clt, clb, 1);
+        for (let i = 0; i < tl;) {
+          const r = clm[bits(dat, pos, clbmsk)];
+          // bits read
+          pos += r & 15;
+          // symbol
+          const s = r >>> 4;
+          // code length to copy
+          if (s < 16) {
+            ldt[i++] = s;
+          } else {
+            //  copy   count
+            let c = 0, n = 0;
+            if (s == 16) n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+            else if (s == 17) n = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s == 18) n = 11 + bits(dat, pos, 127), pos += 7;
+            while (n--) ldt[i++] = c;
+          }
+        }
+        //    length tree                 distance tree
+        const lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        // max length bits
+        lbt = max(lt);
+        // max dist bits
+        dbt = max(dt);
+        lm = hMap(lt, lbt, 1);
+        dm = hMap(dt, dbt, 1);
+      } else throw 'invalid block type';
+      if (pos > tbts) throw 'unexpected EOF';
+    }
+    // Make sure the buffer can hold this + the largest possible addition
+    // maximum chunk size (practically, theoretically infinite) is 2^17;
+    if (noBuf) cbuf(bt + 131072);
+    const lms = (1 << lbt!) - 1, dms = (1 << dbt!) - 1;
+    const mxa = lbt! + dbt! + 18;
+    while (noSt || pos + mxa < tbts) {
+      // bits read, code
+      const c = lm[bits16(dat, pos) & lms], sym = c >>> 4;
+      pos += c & 15;
+      if (pos > tbts) throw 'unexpected EOF';
+      if (!c) throw 'invalid length/literal';
+      if (sym < 256) buf[bt++] = sym;
+      else if (sym == 256) {
+        lm = undefined;
+        break;
+      }
+      else {
+        let add = sym - 254;
+        // no extra bits needed if less
+        if (sym > 264) {
+          // index
+          const i = sym - 257, b = fleb[i];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i];
+          pos += b;
+        }
+        // dist
+        const d = dm![bits16(dat, pos) & dms], dsym = d >>> 4;
+        if (!d) throw 'invalid distance';
+        pos += d & 15;
+        let dt = fd[dsym];
+        if (dsym > 3) {
+          const b = fdeb[dsym];
+          dt += bits16(dat, pos) & ((1 << b) - 1), pos += b;
+        }
+        if (pos > tbts) throw 'unexpected EOF';
+        if (noBuf) cbuf(bt + 131072);
+        const end = bt + add;
+        for (; bt < end; bt += 4) {
+          buf[bt] = buf[bt - dt];
+          buf[bt + 1] = buf[bt + 1 - dt];
+          buf[bt + 2] = buf[bt + 2 - dt];
+          buf[bt + 3] = buf[bt + 3 - dt];
+        }
+        bt = end;
+      }
+    }
+    st.l = lm, st.p = pos, st.b = bt;
+    if (lm) final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+  } while (!final);
+  return bt == buf.length ? buf : slc(buf, 0, bt);
+}
+
+// zlib valid
+const zlv = (d: Uint8Array) => {
+  if ((d[0] & 15) != 8 || (d[0] >>> 4) > 7 || ((d[0] << 8 | d[1]) % 31)) throw 'invalid zlib data';
+  if (d[1] & 32) throw 'invalid zlib data: preset dictionaries not supported';
+}
+
+/**
+ * Expands Zlib data
+ * @param data The data to decompress
+ * @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.
+ * @returns The decompressed version of the data
+ */
+export function unzlibSync(data: Uint8Array, out?: Uint8Array) {
+  return inflt((zlv(data), data.subarray(2, -4)), out);
+}

packages/wasm-crypto-wasm/src/index.ts

@@ -0,0 +1,6 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto-wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import './detectPackage';
+
+export * from './bundle';

packages/wasm-crypto-wasm/src/packageInfo.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2022 @polkadot/wasm-crypto-wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+
+export const packageInfo = { name: '@polkadot/wasm-crypto-wasm', path: 'auto', type: 'auto', version: '5.0.1' };

packages/wasm-crypto-wasm/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "references": []
+}

packages/wasm-crypto/Cargo.toml

@@ -3,32 +3,36 @@
 
 [package]
 authors = ["Jaco Greeff <jacogr@gmail.com>"]
-description = "WASM bindings to Rust crypto libaries."
+description = "WASM bindings to Rust crypto libraries."
 edition = "2018"
 license = "Apache-2.0"
 name = "wasm"
 publish = false
 repository = "https://github.com/polkadot-js/wasm/"
+resolver = "2"
 version = "0.0.0"
 
 [lib]
-crate-type = ["cdylib", "rlib"]
+crate-type = ["cdylib"]
 
 [dependencies]
-backtrace = "0.3.38"
 blake2-rfc = "0.2.18"
 byteorder = "1.3.1"
-ed25519-dalek = { version = "1.0.0-pre.4", features = ["nightly"] }
+curve25519-dalek = { version = "2.1.0", default-features = false }
+ed25519-dalek = { version = "1.0.0-pre.4", features = [] }
+getrandom = { version="0.2.3", features = ["js"] }
 hmac = "0.7.0"
-# libsecp256k1 = "0.2.2"
+libsecp256k1 = { version = "0.7.0", default-features = false, features=["hmac", "lazy-static-context"] }
+merlin = { version = "2.0", default-features = false }
 pbkdf2 = { version = "0.3.0", default-features = false }
-schnorrkel = { version = "0.9.1", features = ["nightly", "preaudit_deprecated", "u64_backend"] }
+rand = { version="0.7.3", default-features = false, features = ["wasm-bindgen"] }
+schnorrkel = { version = "0.9.1", features = ["preaudit_deprecated", "u64_backend"] }
 scrypt = { version = "0.2", default-features = false }
 sha2 = "0.8.1"
 tiny-bip39 = { version = "0.7", default-features = false }
 tiny-keccak = { version = "2.0.1", features = ["keccak"] }
 twox-hash = "1.5.0"
-wasm-bindgen = "=0.2.65"
+wasm-bindgen = "=0.2.79"
 wee_alloc = "0.4.3"
 
 [dev-dependencies]
@@ -36,8 +40,11 @@ hex-literal = "0.2.0"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 
 [profile.release]
+codegen-units = 1
+debug = false
+debug-assertions = false
+incremental = false
 lto = true
 opt-level = "z"
-
-[package.metadata.wasm-pack.profile.release]
-wasm-opt = false
+panic = "abort"
+rpath = false

packages/wasm-crypto/README.md

@@ -12,7 +12,7 @@ Use it -
 
 ```js
 const { u8aToHex } = require('@polkadot/util');
-const { bio39Generate, bip39ToSeed, waitReady } = require('@polkadot/wasm-crypto');
+const { bip39Generate, bip39ToSeed, waitReady } = require('@polkadot/wasm-crypto');
 
 async function main () {
   // first wait until the WASM has been loaded (async init)

packages/wasm-crypto/Xargo.toml

@@ -0,0 +1,2 @@
+[dependencies]
+std = { default-features = false, features = ["panic_immediate_abort"] }

packages/wasm-crypto/package.json

@@ -1,30 +1,44 @@
 {
-  "name": "@polkadot/wasm-crypto",
-  "version": "1.3.1",
   "author": "Jaco Greeff <jacogr@gmail.com>",
-  "files": [
-    "crypto-polyfill.js",
-    "exports.js",
-    "index.d.ts",
-    "index.js",
-    "wasm.d.ts",
-    "wasm.js",
-    "wasm_asm.js",
-    "wasm_asm_stub.js",
-    "wasm_promise.js",
-    "wasm_wasm.js"
-  ],
-  "react-native": {
-    "./wasm_asm_stub.js": "./wasm_asm.js"
+  "bugs": "https://github.com/polkadot-js/wasm/issues",
+  "contributors": [],
+  "description": "A wasm interface layer for use by @polkadot/util-crypto",
+  "engines": {
+    "node": ">=14.0.0"
   },
+  "homepage": "https://github.com/polkadot-js/wasm/tree/master/packages/wasm-crypto#readme",
+  "license": "Apache-2.0",
+  "maintainers": [],
+  "name": "@polkadot/wasm-crypto",
+  "repository": {
+    "directory": "packages/wasm-crypto",
+    "type": "git",
+    "url": "https://github.com/polkadot-js/wasm.git"
+  },
+  "sideEffects": [
+    "./detectPackage.js",
+    "./detectPackage.cjs",
+    "./initOnlyAsm.js",
+    "./initOnlyAsm.cjs",
+    "./initOnlyWasm.js",
+    "./initOnlyWasm.cjs",
+    "./initWasmAsm.js",
+    "./initWasmAsm.cjs"
+  ],
+  "type": "module",
+  "version": "5.0.1",
   "main": "index.js",
-  "types": "index.d.ts",
+  "dependencies": {
+    "@babel/runtime": "^7.17.8",
+    "@polkadot/wasm-crypto-asmjs": "^5.0.1",
+    "@polkadot/wasm-crypto-wasm": "^5.0.1"
+  },
   "devDependencies": {
-    "@polkadot/dev": "^0.55.35",
-    "@polkadot/util": "^3.0.1",
-    "override-require": "^1.1.1"
+    "@polkadot/util": "^8.5.1",
+    "@polkadot/x-randomvalues": "^8.5.1"
   },
   "peerDependencies": {
-    "@polkadot/util": "*"
+    "@polkadot/util": "*",
+    "@polkadot/x-randomvalues": "*"
   }
 }

packages/wasm-crypto/src/bridge.ts

@@ -0,0 +1,91 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+import type { WasmCryptoInstance } from './types';
+
+import { assert, stringToU8a, u8aToString } from '@polkadot/util';
+
+type PopFirst<T extends unknown[]> =
+  T extends [WasmCryptoInstance, ...infer N]
+    ? N
+    : [];
+
+interface Bridge {
+  cachegetInt32: Int32Array | null;
+  cachegetUint8: Uint8Array | null;
+  type: 'wasm' | 'asm';
+  wasm: WasmCryptoInstance | null;
+  wasmPromise: Promise<void> | null;
+}
+
+export const __bridge: Bridge = {
+  cachegetInt32: null,
+  cachegetUint8: null,
+  type: 'wasm',
+  wasm: null,
+  wasmPromise: null
+};
+
+export function withWasm <T, F extends (wasm: WasmCryptoInstance, ...params: never[]) => T> (fn: F): (...params: PopFirst<Parameters<F>>) => ReturnType<F> {
+  return (...params: PopFirst<Parameters<F>>): ReturnType<F> => {
+    assert(__bridge.wasm, 'The WASM interface has not been initialized. Ensure that you wait for the initialization Promise with waitReady() from @polkadot/wasm-crypto (or cryptoWaitReady() from @polkadot/util-crypto) before attempting to use WASM-only interfaces.');
+
+    return fn(__bridge.wasm, ...params) as ReturnType<F>;
+  };
+}
+
+export function getWasm (): WasmCryptoInstance {
+  return __bridge.wasm!;
+}
+
+export function getInt32 (): Int32Array {
+  if (__bridge.cachegetInt32 === null || __bridge.cachegetInt32.buffer !== __bridge.wasm!.memory.buffer) {
+    __bridge.cachegetInt32 = new Int32Array(__bridge.wasm!.memory.buffer);
+  }
+
+  return __bridge.cachegetInt32;
+}
+
+export function getUint8 (): Uint8Array {
+  if (__bridge.cachegetUint8 === null || __bridge.cachegetUint8.buffer !== __bridge.wasm!.memory.buffer) {
+    __bridge.cachegetUint8 = new Uint8Array(__bridge.wasm!.memory.buffer);
+  }
+
+  return __bridge.cachegetUint8;
+}
+
+export function getU8a (ptr: number, len: number): Uint8Array {
+  return getUint8().subarray(ptr / 1, ptr / 1 + len);
+}
+
+export function getString (ptr: number, len: number): string {
+  return u8aToString(getU8a(ptr, len));
+}
+
+export function allocU8a (arg: Uint8Array): [number, number] {
+  const ptr = __bridge.wasm!.__wbindgen_malloc(arg.length * 1);
+
+  getUint8().set(arg, ptr / 1);
+
+  return [ptr, arg.length];
+}
+
+export function allocString (arg: string): [number, number] {
+  return allocU8a(stringToU8a(arg));
+}
+
+export function resultU8a (): Uint8Array {
+  const r0 = getInt32()[8 / 4 + 0];
+  const r1 = getInt32()[8 / 4 + 1];
+  const ret = getU8a(r0, r1).slice();
+
+  __bridge.wasm!.__wbindgen_free(r0, r1 * 1);
+
+  return ret;
+}
+
+export function resultString (): string {
+  return u8aToString(resultU8a());
+}

packages/wasm-crypto/src/bundle.ts

@@ -0,0 +1,222 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { __bridge, allocString, allocU8a, getWasm, resultString, resultU8a, withWasm } from './bridge';
+import { setWasmOnlyPromise } from './init';
+
+export { packageInfo } from './packageInfo';
+
+export const bip39Generate = withWasm((wasm, words: 12 | 15 | 18 | 21 | 24): string => {
+  wasm.ext_bip39_generate(8, words);
+
+  return resultString();
+});
+
+export const bip39ToEntropy = withWasm((wasm, phrase: string): Uint8Array => {
+  wasm.ext_bip39_to_entropy(8, ...allocString(phrase));
+
+  return resultU8a();
+});
+
+export const bip39ToMiniSecret = withWasm((wasm, phrase: string, password: string): Uint8Array => {
+  wasm.ext_bip39_to_mini_secret(8, ...allocString(phrase), ...allocString(password));
+
+  return resultU8a();
+});
+
+export const bip39ToSeed = withWasm((wasm, phrase: string, password: string): Uint8Array => {
+  wasm.ext_bip39_to_seed(8, ...allocString(phrase), ...allocString(password));
+
+  return resultU8a();
+});
+
+export const bip39Validate = withWasm((wasm, phrase: string): boolean => {
+  const ret = wasm.ext_bip39_validate(...allocString(phrase));
+
+  return ret !== 0;
+});
+
+export const ed25519KeypairFromSeed = withWasm((wasm, seed: Uint8Array): Uint8Array => {
+  wasm.ext_ed_from_seed(8, ...allocU8a(seed));
+
+  return resultU8a();
+});
+
+export const ed25519Sign = withWasm((wasm, pubkey: Uint8Array, seckey: Uint8Array, message: Uint8Array): Uint8Array => {
+  wasm.ext_ed_sign(8, ...allocU8a(pubkey), ...allocU8a(seckey), ...allocU8a(message));
+
+  return resultU8a();
+});
+
+export const ed25519Verify = withWasm((wasm, signature: Uint8Array, message: Uint8Array, pubkey: Uint8Array): boolean => {
+  const ret = wasm.ext_ed_verify(...allocU8a(signature), ...allocU8a(message), ...allocU8a(pubkey));
+
+  return ret !== 0;
+});
+
+let secpLazyInit = false;
+
+export const secp256k1FromSeed = withWasm((wasm, seckey: Uint8Array): Uint8Array => {
+  // HACK In an asm.js environment, the static initialization seems to trip up the
+  // first usage of the keypair generation
+  // https://github.com/polkadot-js/wasm/issues/307
+  if (!secpLazyInit && __bridge.type === 'asm') {
+    wasm.ext_secp_from_seed(8, ...allocU8a(seckey));
+    resultU8a();
+  }
+
+  secpLazyInit = true;
+  wasm.ext_secp_from_seed(8, ...allocU8a(seckey));
+
+  return resultU8a();
+});
+
+export const secp256k1Compress = withWasm((wasm, pubkey: Uint8Array): Uint8Array => {
+  wasm.ext_secp_pub_compress(8, ...allocU8a(pubkey));
+
+  return resultU8a();
+});
+
+export const secp256k1Expand = withWasm((wasm, pubkey: Uint8Array): Uint8Array => {
+  wasm.ext_secp_pub_expand(8, ...allocU8a(pubkey));
+
+  return resultU8a();
+});
+
+export const secp256k1Recover = withWasm((wasm, msgHash: Uint8Array, sig: Uint8Array, recovery: number): Uint8Array => {
+  wasm.ext_secp_recover(8, ...allocU8a(msgHash), ...allocU8a(sig), recovery);
+
+  return resultU8a();
+});
+
+export const secp256k1Sign = withWasm((wasm, msgHash: Uint8Array, seckey: Uint8Array): Uint8Array => {
+  wasm.ext_secp_sign(8, ...allocU8a(msgHash), ...allocU8a(seckey));
+
+  return resultU8a();
+});
+
+export const sr25519DeriveKeypairHard = withWasm((wasm, pair: Uint8Array, cc: Uint8Array): Uint8Array => {
+  wasm.ext_sr_derive_keypair_hard(8, ...allocU8a(pair), ...allocU8a(cc));
+
+  return resultU8a();
+});
+
+export const sr25519DeriveKeypairSoft = withWasm((wasm, pair: Uint8Array, cc: Uint8Array): Uint8Array => {
+  wasm.ext_sr_derive_keypair_soft(8, ...allocU8a(pair), ...allocU8a(cc));
+
+  return resultU8a();
+});
+
+export const sr25519DerivePublicSoft = withWasm((wasm, pubkey: Uint8Array, cc: Uint8Array): Uint8Array => {
+  wasm.ext_sr_derive_public_soft(8, ...allocU8a(pubkey), ...allocU8a(cc));
+
+  return resultU8a();
+});
+
+export const sr25519KeypairFromSeed = withWasm((wasm, seed: Uint8Array): Uint8Array => {
+  wasm.ext_sr_from_seed(8, ...allocU8a(seed));
+
+  return resultU8a();
+});
+
+export const sr25519Sign = withWasm((wasm, pubkey: Uint8Array, secret: Uint8Array, message: Uint8Array): Uint8Array => {
+  wasm.ext_sr_sign(8, ...allocU8a(pubkey), ...allocU8a(secret), ...allocU8a(message));
+
+  return resultU8a();
+});
+
+export const sr25519Verify = withWasm((wasm, signature: Uint8Array, message: Uint8Array, pubkey: Uint8Array): boolean => {
+  const ret = wasm.ext_sr_verify(...allocU8a(signature), ...allocU8a(message), ...allocU8a(pubkey));
+
+  return ret !== 0;
+});
+
+export const sr25519Agree = withWasm((wasm, pubkey: Uint8Array, secret: Uint8Array): Uint8Array => {
+  wasm.ext_sr_agree(8, ...allocU8a(pubkey), ...allocU8a(secret));
+
+  return resultU8a();
+});
+
+export const vrfSign = withWasm((wasm, secret: Uint8Array, context: Uint8Array, message: Uint8Array, extra: Uint8Array): Uint8Array => {
+  wasm.ext_vrf_sign(8, ...allocU8a(secret), ...allocU8a(context), ...allocU8a(message), ...allocU8a(extra));
+
+  return resultU8a();
+});
+
+export const vrfVerify = withWasm((wasm, pubkey: Uint8Array, context: Uint8Array, message: Uint8Array, extra: Uint8Array, outAndProof: Uint8Array): boolean => {
+  const ret = wasm.ext_vrf_verify(...allocU8a(pubkey), ...allocU8a(context), ...allocU8a(message), ...allocU8a(extra), ...allocU8a(outAndProof));
+
+  return ret !== 0;
+});
+
+export const blake2b = withWasm((wasm, data: Uint8Array, key: Uint8Array, size: number): Uint8Array => {
+  wasm.ext_blake2b(8, ...allocU8a(data), ...allocU8a(key), size);
+
+  return resultU8a();
+});
+
+export const hmacSha256 = withWasm((wasm, key: Uint8Array, data: Uint8Array): Uint8Array => {
+  wasm.ext_hmac_sha256(8, ...allocU8a(key), ...allocU8a(data));
+
+  return resultU8a();
+});
+
+export const hmacSha512 = withWasm((wasm, key: Uint8Array, data: Uint8Array): Uint8Array => {
+  wasm.ext_hmac_sha512(8, ...allocU8a(key), ...allocU8a(data));
+
+  return resultU8a();
+});
+
+export const keccak256 = withWasm((wasm, data: Uint8Array): Uint8Array => {
+  wasm.ext_keccak256(8, ...allocU8a(data));
+
+  return resultU8a();
+});
+
+export const keccak512 = withWasm((wasm, data: Uint8Array): Uint8Array => {
+  wasm.ext_keccak512(8, ...allocU8a(data));
+
+  return resultU8a();
+});
+
+export const pbkdf2 = withWasm((wasm, data: Uint8Array, salt: Uint8Array, rounds: number): Uint8Array => {
+  wasm.ext_pbkdf2(8, ...allocU8a(data), ...allocU8a(salt), rounds);
+
+  return resultU8a();
+});
+
+export const scrypt = withWasm((wasm, password: Uint8Array, salt: Uint8Array, log2n: number, r: number, p: number): Uint8Array => {
+  wasm.ext_scrypt(8, ...allocU8a(password), ...allocU8a(salt), log2n, r, p);
+
+  return resultU8a();
+});
+
+export const sha256 = withWasm((wasm, data: Uint8Array): Uint8Array => {
+  wasm.ext_sha256(8, ...allocU8a(data));
+
+  return resultU8a();
+});
+
+export const sha512 = withWasm((wasm, data: Uint8Array): Uint8Array => {
+  wasm.ext_sha512(8, ...allocU8a(data));
+
+  return resultU8a();
+});
+
+export const twox = withWasm((wasm, data: Uint8Array, rounds: number) => {
+  wasm.ext_twox(8, ...allocU8a(data), rounds);
+
+  return resultU8a();
+});
+
+export function isReady (): boolean {
+  return !!getWasm();
+}
+
+export function waitReady (): Promise<boolean> {
+  return (
+    __bridge.wasmPromise || setWasmOnlyPromise()
+  )
+    .then(() => isReady())
+    .catch(() => false);
+}

packages/wasm-crypto/src/detectOther.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { packageInfo as asmInfo } from '@polkadot/wasm-crypto-asmjs/packageInfo';
+import { packageInfo as wasmInfo } from '@polkadot/wasm-crypto-wasm/packageInfo';
+
+export default [asmInfo, wasmInfo];

packages/wasm-crypto/src/detectPackage.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+
+import { detectPackage } from '@polkadot/util';
+
+import others from './detectOther';
+import { packageInfo } from './packageInfo';
+
+detectPackage(packageInfo, null, others);

packages/wasm-crypto/src/imports.ts

@@ -0,0 +1,94 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable camelcase */
+
+import { getRandomValues } from '@polkadot/x-randomvalues';
+
+import { getString, getU8a } from './bridge';
+
+const DEFAULT_CRYPTO = { getRandomValues };
+const DEFAULT_SELF = { crypto: DEFAULT_CRYPTO };
+
+const heap: Array<unknown> = new Array(32).fill(undefined).concat(undefined, null, true, false);
+let heapNext = heap.length;
+
+function getObject (idx: number): unknown {
+  return heap[idx];
+}
+
+function dropObject (idx: number) {
+  if (idx < 36) {
+    return;
+  }
+
+  heap[idx] = heapNext;
+  heapNext = idx;
+}
+
+function takeObject (idx: number): unknown {
+  const ret = getObject(idx);
+
+  dropObject(idx);
+
+  return ret;
+}
+
+function addObject (obj: unknown): number {
+  if (heapNext === heap.length) {
+    heap.push(heap.length + 1);
+  }
+
+  const idx = heapNext;
+
+  heapNext = heap[idx] as number;
+  heap[idx] = obj;
+
+  return idx;
+}
+
+export function __wbindgen_is_undefined (idx: number): boolean {
+  return getObject(idx) === undefined;
+}
+
+export function __wbindgen_throw (ptr: number, len: number): boolean {
+  throw new Error(getString(ptr, len));
+}
+
+export function __wbg_self_1b7a39e3a92c949c (): number {
+  return addObject(DEFAULT_SELF);
+}
+
+export function __wbg_require_604837428532a733 (ptr: number, len: number): never {
+  throw new Error(`Unable to require ${getString(ptr, len)}`);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function __wbg_crypto_968f1772287e2df0 (_idx: number): number {
+  return addObject(DEFAULT_CRYPTO);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function __wbg_getRandomValues_a3d34b4fee3c2869 (_idx: number): number {
+  return addObject(DEFAULT_CRYPTO.getRandomValues);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function __wbg_getRandomValues_f5e14ab7ac8e995d (_arg0: number, ptr: number, len: number): void {
+  DEFAULT_CRYPTO.getRandomValues(getU8a(ptr, len));
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function __wbg_randomFillSync_d5bd2d655fdf256a (_idx: number, _ptr: number, _len: number): never {
+  throw new Error('randomFillsync is not available');
+
+  // getObject(idx).randomFillSync(getU8a(ptr, len));
+}
+
+export function __wbindgen_object_drop_ref (idx: number): void {
+  takeObject(idx);
+}
+
+export function abort (): never {
+  throw new Error('abort');
+}

packages/wasm-crypto/src/index.ts

@@ -0,0 +1,6 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import './detectPackage';
+
+export * from './bundle';

packages/wasm-crypto/src/init.ts

@@ -0,0 +1,41 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AsmCreator, WasmCryptoInstance } from './types';
+
+import { assert } from '@polkadot/util';
+import { wasmBytes } from '@polkadot/wasm-crypto-wasm';
+
+import { __bridge } from './bridge';
+import * as imports from './imports';
+
+async function createPromise (wasmBytes: Uint8Array | null, asmFn: AsmCreator | null): Promise<void> {
+  try {
+    assert(typeof WebAssembly !== 'undefined' && wasmBytes && wasmBytes.length, 'WebAssembly is not available in your environment');
+
+    const source = await WebAssembly.instantiate(wasmBytes, { wbg: imports });
+
+    __bridge.wasm = source.instance.exports as unknown as WasmCryptoInstance;
+  } catch (error) {
+    // if we have a valid supplied asm.js, return that
+    if (asmFn) {
+      __bridge.type = 'asm';
+      __bridge.wasm = asmFn(imports);
+    } else {
+      console.error('FATAL: Unable to initialize @polkadot/wasm-crypto');
+      console.error(error);
+
+      __bridge.wasm = null;
+    }
+  }
+}
+
+export function setPromise (wasmBytes: Uint8Array | null, asmFn: AsmCreator | null): Promise<void> {
+  __bridge.wasmPromise = createPromise(wasmBytes, asmFn);
+
+  return __bridge.wasmPromise;
+}
+
+export function setWasmOnlyPromise (): Promise<void> {
+  return setPromise(wasmBytes, null);
+}

packages/wasm-crypto/src/initOnlyAsm.ts

@@ -0,0 +1,8 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { asmJsInit } from '@polkadot/wasm-crypto-asmjs';
+
+import { setPromise } from './init';
+
+setPromise(null, asmJsInit).catch(() => undefined);

packages/wasm-crypto/src/initOnlyWasm.ts

@@ -0,0 +1,6 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { setWasmOnlyPromise } from './init';
+
+setWasmOnlyPromise().catch(() => undefined);

packages/wasm-crypto/src/initWasmAsm.ts

@@ -0,0 +1,9 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { asmJsInit } from '@polkadot/wasm-crypto-asmjs';
+import { wasmBytes } from '@polkadot/wasm-crypto-wasm';
+
+import { setPromise } from './init';
+
+setPromise(wasmBytes, asmJsInit).catch(() => undefined);

packages/wasm-crypto/src/js/crypto-polyfill.js

@@ -1,21 +0,0 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-const crypto = require('crypto');
-
-if (!global.crypto) {
-  global.crypto = {};
-}
-
-if (!global.crypto.getRandomValues) {
-  global.crypto.getRandomValues = function (arr) {
-    const buffer = crypto.randomBytes(arr.length);
-
-    return buffer.reduce((arr, value, index) => {
-      arr[index] = value;
-
-      return arr;
-    }, arr);
-  };
-}

packages/wasm-crypto/src/js/exports.js

@@ -1,51 +0,0 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-/* eslint-disable sort-keys */
-
-const { assert } = require('@polkadot/util');
-
-const INIT_ERRROR = '@polkadot/wasm-crypto has not been initialized';
-
-module.exports = function (stubbed) {
-  const wrapReady = (fn) =>
-    (...params) => {
-      assert(stubbed.isReady(), INIT_ERRROR);
-
-      return fn(...params);
-    };
-
-  return {
-    bip39Generate: wrapReady(stubbed.ext_bip39_generate),
-    bip39ToEntropy: wrapReady(stubbed.ext_bip39_to_entropy),
-    bip39ToMiniSecret: wrapReady(stubbed.ext_bip39_to_mini_secret),
-    bip39ToSeed: wrapReady(stubbed.ext_bip39_to_seed),
-    bip39Validate: wrapReady(stubbed.ext_bip39_validate),
-
-    ed25519KeypairFromSeed: wrapReady(stubbed.ext_ed_from_seed),
-    ed25519Sign: wrapReady(stubbed.ext_ed_sign),
-    ed25519Verify: wrapReady(stubbed.ext_ed_verify),
-
-    sr25519DeriveKeypairHard: wrapReady(stubbed.ext_sr_derive_keypair_hard),
-    sr25519DeriveKeypairSoft: wrapReady(stubbed.ext_sr_derive_keypair_soft),
-    sr25519DerivePublicSoft: wrapReady(stubbed.ext_sr_derive_public_soft),
-    sr25519KeypairFromSeed: wrapReady(stubbed.ext_sr_from_seed),
-    sr25519Sign: wrapReady(stubbed.ext_sr_sign),
-    sr25519Verify: wrapReady(stubbed.ext_sr_verify),
-
-    blake2b: wrapReady(stubbed.ext_blake2b),
-    keccak256: wrapReady(stubbed.ext_keccak256),
-    pbkdf2: wrapReady(stubbed.ext_pbkdf2),
-    scrypt: wrapReady(stubbed.ext_scrypt),
-
-    // secp256k1IsRecoverable: wrapReady(stubbed.ext_secp256k1_is_recoverable);
-    // secp256k1Recover: wrapReady(stubbed.ext_secp256k1_recover);
-
-    sha512: wrapReady(stubbed.ext_sha512),
-    twox: wrapReady(stubbed.ext_twox),
-
-    isReady: stubbed.isReady,
-    waitReady: stubbed.waitReady
-  };
-};

packages/wasm-crypto/src/js/index.d.ts

@@ -1,31 +0,0 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-export function bip39Generate (words: 12 | 15 | 18 | 21 | 24): string;
-export function bip39ToEntropy (phrase: string): Uint8Array;
-export function bip39ToMiniSecret (phrase: string, password: string): Uint8Array;
-export function bip39Validate (phrase: string): boolean;
-
-export function ed25519KeypairFromSeed (seed: Uint8Array): Uint8Array;
-export function ed25519Sign (publicKey: Uint8Array, secretKey: Uint8Array, message: Uint8Array): Uint8Array;
-export function ed25519Verify (signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array): boolean;
-
-export function sr25519DeriveKeypairHard (pair: Uint8Array, chainCode: Uint8Array): Uint8Array;
-export function sr25519DeriveKeypairSoft (pair: Uint8Array, chainCode: Uint8Array): Uint8Array;
-export function sr25519DerivePublicSoft (publicKey: Uint8Array, chainCode: Uint8Array): Uint8Array;
-export function sr25519KeypairFromSeed (seed: Uint8Array): Uint8Array;
-export function sr25519Sign (publicKey: Uint8Array, secretKey: Uint8Array, message: Uint8Array): Uint8Array;
-export function sr25519Verify (signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array): boolean;
-
-export function blake2b (data: Uint8Array, key: Uint8Array, byteSize: number): Uint8Array;
-export function keccak256 (data: Uint8Array): Uint8Array;
-export function pbkdf2 (data: Uint8Array, salt: Uint8Array, rounds: number): Uint8Array;
-export function scrypt (password: Uint8Array, salt: Uint8Array, log2N: number, r: number, p: number): Uint8Array;
-// export function secp256k1IsRecoverable (message: Uint8Array, signature: Uint8Array): number;
-// export function secp256k1Recover (message: Uint8Array, signature: Uint8Array): Uint8Array;
-export function sha512 (data: Uint8Array): Uint8Array;
-export function twox (data: Uint8Array, rounds: number): Uint8Array;
-
-export function isReady (): boolean;
-export function waitReady (): Promise<boolean>;

packages/wasm-crypto/src/js/index.js

@@ -1,7 +0,0 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-const stubbed = require('./wasm');
-
-module.exports = require('./exports')(stubbed);

packages/wasm-crypto/src/js/wasm_asm_stub.js

@@ -1,5 +0,0 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-module.exports = {};

packages/wasm-crypto/src/js/wasm_promise.js

@@ -1,26 +0,0 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-const pkg = require('./package.json');
-const asm = require('./wasm_asm_stub');
-const bytes = require('./wasm_wasm');
-const imports = require('./wasm');
-
-module.exports = async function createExportPromise () {
-  try {
-    const { instance } = await WebAssembly.instantiate(bytes, { __wbindgen_placeholder__: imports });
-
-    return instance.exports;
-  } catch (error) {
-    // if we have a valid supplied asm.js, return that
-    if (asm && asm.ext_blake2b) {
-      return asm;
-    }
-
-    console.error(`ERROR: Unable to initialize ${pkg.name} ${pkg.version}`);
-    console.error(error);
-
-    return null;
-  }
-};

packages/wasm-crypto/src/lib.rs

@@ -1,12 +1,24 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
 
 // Use `wee_alloc` as the global allocator.
 #[global_allocator]
 static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
 
+#[path = "rs/bip39.rs"]
 pub mod bip39;
+
+#[path = "rs/ed25519.rs"]
 pub mod ed25519;
+
+#[path = "rs/hashing.rs"]
 pub mod hashing;
+
+#[path = "rs/secp256k1.rs"]
+pub mod secp256k1;
+
+#[path = "rs/sr25519.rs"]
 pub mod sr25519;
+
+#[path = "rs/vrf.rs"]
+pub mod vrf;

packages/wasm-crypto/src/packageInfo.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+
+export const packageInfo = { name: '@polkadot/wasm-crypto', path: 'auto', type: 'auto', version: '5.0.1' };

packages/wasm-crypto/src/rs/.editorconfig

@@ -0,0 +1,10 @@
+root = true
+[*]
+indent_style=tab
+indent_size=tab
+tab_width=4
+end_of_line=lf
+charset=utf-8
+trim_trailing_whitespace=true
+max_line_length=100
+insert_final_newline=true

packages/wasm-crypto/src/rs/bip39.rs

@@ -1,8 +1,7 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
 
-use bip39::{Mnemonic, MnemonicType, Language};
+use bip39::{Mnemonic, MnemonicType, Language, Seed};
 use hmac::Hmac;
 use pbkdf2::pbkdf2;
 use sha2::Sha512;
@@ -15,8 +14,11 @@ use wasm_bindgen::prelude::*;
 /// Returns the bip 39 phrase
 #[wasm_bindgen]
 pub fn ext_bip39_generate(words: u32) -> String {
-	Mnemonic::new(MnemonicType::for_word_count(words as usize).unwrap(), Language::English)
-		.into_phrase()
+	match MnemonicType::for_word_count(words as usize) {
+		Ok(p) => Mnemonic::new(p, Language::English)
+			.into_phrase(),
+		_ => panic!("Invalid count provided.")
+	}
 }
 
 /// Create entropy from a bip39 phrase
@@ -26,10 +28,12 @@ pub fn ext_bip39_generate(words: u32) -> String {
 /// Returns the entropy
 #[wasm_bindgen]
 pub fn ext_bip39_to_entropy(phrase: &str) -> Vec<u8> {
-	Mnemonic::from_phrase(phrase, Language::English)
-		.unwrap()
-		.entropy()
-		.to_vec()
+	match Mnemonic::from_phrase(phrase, Language::English) {
+		Ok(m) => m
+			.entropy()
+			.to_vec(),
+		_ => panic!("Invalid phrase provided.")
+	}
 }
 
 /// Create a mini-secret from a bip39 phrase
@@ -39,13 +43,35 @@ pub fn ext_bip39_to_entropy(phrase: &str) -> Vec<u8> {
 /// Returns the 32-byte mini-secret via entropy
 #[wasm_bindgen]
 pub fn ext_bip39_to_mini_secret(phrase: &str, password: &str) -> Vec<u8> {
-	let salt = format!("mnemonic{}", password);
-	let mnemonic = Mnemonic::from_phrase(phrase, Language::English).unwrap();
-	let mut result = [0u8; 64];
+	match Mnemonic::from_phrase(phrase, Language::English) {
+		Ok(m) => {
+			let mut res = [0u8; 64];
+			let mut seed = vec![];
 
-	pbkdf2::<Hmac<Sha512>>(mnemonic.entropy(), salt.as_bytes(), 2048, &mut result);
+			seed.extend_from_slice(b"mnemonic");
+			seed.extend_from_slice(password.as_bytes());
 
-	result[..32].to_vec()
+			pbkdf2::<Hmac<Sha512>>(m.entropy(), &seed, 2048, &mut res);
+
+			res[..32].to_vec()
+		},
+		_ => panic!("Invalid phrase provided.")
+	}
+}
+
+/// Creates a BTC/ETH compatible seed from a bip-39 phrase
+///
+/// @phrase: mnemonic phrase
+///
+/// Returns a 32-byte seed
+#[wasm_bindgen]
+pub fn ext_bip39_to_seed(phrase: &str, password: &str) -> Vec<u8> {
+	match Mnemonic::from_phrase(phrase, Language::English) {
+		Ok(m) => Seed::new(&m, password)
+			.as_bytes()[..32]
+			.to_vec(),
+		_ => panic!("Invalid phrase provided.")
+	}
 }
 
 /// Validates a bip39 phrase
@@ -56,8 +82,8 @@ pub fn ext_bip39_to_mini_secret(phrase: &str, password: &str) -> Vec<u8> {
 #[wasm_bindgen]
 pub fn ext_bip39_validate(phrase: &str) -> bool {
 	match Mnemonic::validate(phrase, Language::English) {
-		Err(_) => false,
-		_ => true
+		Ok(_) => true,
+		_ => false
 	}
 }
 
@@ -70,9 +96,9 @@ pub mod tests {
 	fn can_bip39_entropy() {
 		let phrase = "legal winner thank year wave sausage worth useful legal winner thank yellow";
 		let entropy = hex!("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f");
-		let result = ext_bip39_to_entropy(phrase);
+		let res = ext_bip39_to_entropy(phrase);
 
-		assert_eq!(result, entropy);
+		assert_eq!(res, entropy);
 	}
 
 	#[test]
@@ -80,9 +106,18 @@ pub mod tests {
 		let phrase = "legal winner thank year wave sausage worth useful legal winner thank yellow";
 		let password = "Substrate";
 		let mini = hex!("4313249608fe8ac10fd5886c92c4579007272cb77c21551ee5b8d60b78041685");
-		let result = ext_bip39_to_mini_secret(phrase, password);
+		let res = ext_bip39_to_mini_secret(phrase, password);
 
-		assert_eq!(result[..], mini[..]);
+		assert_eq!(res[..], mini[..]);
+	}
+
+	#[test]
+	fn can_bip39_seed() {
+		let phrase = "seed sock milk update focus rotate barely fade car face mechanic mercy";
+		let seed = hex!("3c121e20de068083b49c2315697fb59a2d9e8643c24e5ea7628132c58969a027");
+		let res = ext_bip39_to_seed(phrase, "");
+
+		assert_eq!(res[..], seed[..]);
 	}
 
 	#[test]

packages/wasm-crypto/src/rs/ed25519.rs

@@ -1,42 +1,20 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
 
 use std::convert::TryFrom;
 use ed25519_dalek::{Keypair, PublicKey, SecretKey, Signature, Signer as _, Verifier as _};
 use wasm_bindgen::prelude::*;
 
-/// Keypair helper function.
-fn create_from_pair(pair: &[u8]) -> Keypair {
-	match Keypair::from_bytes(pair) {
-		Ok(pair) => return pair,
-		Err(_) => panic!("Provided pair is invalid.")
-	}
-}
-
 /// Keypair helper function
-fn create_from_parts(pubkey: &[u8], seckey: &[u8]) -> Keypair {
+fn new_from_parts(pubkey: &[u8], seckey: &[u8]) -> Keypair {
 	let mut pair = vec![];
 
 	pair.extend_from_slice(seckey);
 	pair.extend_from_slice(pubkey);
 
-	create_from_pair(&pair)
-}
-
-/// Keypair helper function.
-fn create_from_seed(seed: &[u8]) -> Keypair {
-	let seckey = SecretKey::from_bytes(seed).unwrap();
-	let pubkey: PublicKey = (&seckey).into();
-
-	create_from_parts(pubkey.as_bytes(), seed)
-}
-
-/// PublicKey helper
-fn create_public(pubkey: &[u8]) -> PublicKey {
-	match PublicKey::from_bytes(pubkey) {
-		Ok(pubkey) => return pubkey,
-		Err(_) => panic!("Provided public key is invalid.")
+	match Keypair::from_bytes(&pair) {
+		Ok(p) => p,
+		_ => panic!("Provided pair is invalid.")
 	}
 }
 
@@ -48,9 +26,16 @@ fn create_public(pubkey: &[u8]) -> PublicKey {
 /// followed by the public key (32) bytes.
 #[wasm_bindgen]
 pub fn ext_ed_from_seed(seed: &[u8]) -> Vec<u8> {
-	create_from_seed(seed)
-		.to_bytes()
-		.to_vec()
+	match &SecretKey::from_bytes(seed) {
+		Ok(s) => {
+			let pubkey: PublicKey = s.into();
+
+			new_from_parts(pubkey.as_bytes(), seed)
+				.to_bytes()
+				.to_vec()
+		},
+		_ => panic!("Invalid seed provided.")
+	}
 }
 
 /// Sign a message
@@ -65,7 +50,7 @@ pub fn ext_ed_from_seed(seed: &[u8]) -> Vec<u8> {
 /// * returned vector is the signature consisting of 64 bytes.
 #[wasm_bindgen]
 pub fn ext_ed_sign(pubkey: &[u8], seckey: &[u8], message: &[u8]) -> Vec<u8> {
-	create_from_parts(pubkey, seckey)
+	new_from_parts(pubkey, seckey)
 		.sign(message)
 		.to_bytes()
 		.to_vec()
@@ -78,14 +63,12 @@ pub fn ext_ed_sign(pubkey: &[u8], seckey: &[u8], message: &[u8]) -> Vec<u8> {
 /// * pubkey: UIntArray with 32 element
 #[wasm_bindgen]
 pub fn ext_ed_verify(signature: &[u8], message: &[u8], pubkey: &[u8]) -> bool {
-	let signature = match Signature::try_from(signature) {
-		Ok(signature) => signature,
-		Err(_) => return false
-	};
-
-	create_public(pubkey)
-		.verify(message, &signature)
-		.is_ok()
+	match (Signature::try_from(signature), PublicKey::from_bytes(pubkey)) {
+		(Ok(s), Ok(k)) => k
+			.verify(message, &s)
+			.is_ok(),
+		_ => false
+	}
 }
 
 #[cfg(test)]
@@ -101,7 +84,7 @@ pub mod tests {
 	}
 
 	#[test]
-	fn can_create_keypair() {
+	fn can_new_keypair() {
 		let seed = generate_random_seed();
 		let keypair = ext_ed_from_seed(seed.as_slice());
 

packages/wasm-crypto/src/rs/hashing.rs

@@ -1,33 +1,16 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
 
 use blake2_rfc::blake2b::blake2b;
 use byteorder::{ByteOrder, LittleEndian};
-use hmac::Hmac;
+use hmac::{Hmac, Mac};
 use pbkdf2::pbkdf2;
 use scrypt::{ScryptParams, scrypt};
-use sha2::{Digest, Sha512};
-// use secp256k1;
+use sha2::{Digest, Sha256, Sha512};
 use tiny_keccak::{Hasher, Keccak};
 use twox_hash::XxHash;
 use wasm_bindgen::prelude::*;
 
-/// helper function for a single twox round with a seed
-fn create_twox(data: &[u8], seed: u64) -> [u8; 8] {
-	use ::std::hash::Hasher;
-	let mut hasher = XxHash::with_seed(seed);
-
-	hasher.write(data);
-
-	let hash64 = hasher.finish();
-	let mut result = [0u8; 8];
-
-	LittleEndian::write_u64(&mut result, hash64);
-
-	result
-}
-
 /// blake2b hash for the specified input
 ///
 /// * data: Arbitrary data to be hashed
@@ -43,6 +26,39 @@ pub fn ext_blake2b(data: &[u8], key: &[u8], size: u32) -> Vec<u8> {
 		.to_vec()
 }
 
+/// hmac with sha256
+#[wasm_bindgen]
+pub fn ext_hmac_sha256(key: &[u8], data: &[u8]) -> Vec<u8> {
+	match Hmac::<Sha256>::new_varkey(key) {
+		Ok(mut m) => {
+			m.input(data);
+
+			m
+				.result()
+				.code()
+				.to_vec()
+		},
+		_ => panic!("Invalid key provided.")
+	}
+}
+
+/// hmac with sha512
+#[wasm_bindgen]
+pub fn ext_hmac_sha512(key: &[u8], data: &[u8]) -> Vec<u8> {
+	match Hmac::<Sha512>::new_varkey(key) {
+		Ok(mut m) => {
+			m.input(data);
+
+			m
+				.result()
+				.code()
+				.to_vec()
+		},
+		_ => panic!("Invalid key provided.")
+	}
+
+}
+
 /// Create a keccak256 hash for the specified input
 ///
 // * data: Arbitrary data to be hashed
@@ -51,12 +67,28 @@ pub fn ext_blake2b(data: &[u8], key: &[u8], size: u32) -> Vec<u8> {
 #[wasm_bindgen]
 pub fn ext_keccak256(data: &[u8]) -> Vec<u8> {
 	let mut keccak = Keccak::v256();
-	let mut result = [0u8; 32];
+	let mut res = [0u8; 32];
 
 	keccak.update(data);
-	keccak.finalize(&mut result);
+	keccak.finalize(&mut res);
 
-	result.to_vec()
+	res.to_vec()
+}
+
+/// Create a keccak512 hash for the specified input
+///
+// * data: Arbitrary data to be hashed
+///
+/// Returns the hash as a vector
+#[wasm_bindgen]
+pub fn ext_keccak512(data: &[u8]) -> Vec<u8> {
+	let mut keccak = Keccak::v512();
+	let mut res = [0u8; 64];
+
+	keccak.update(data);
+	keccak.finalize(&mut res);
+
+	res.to_vec()
 }
 
 /// pbkdf2 kdf from an input, salt for the number of specified rounds
@@ -68,12 +100,12 @@ pub fn ext_keccak256(data: &[u8]) -> Vec<u8> {
 /// Returns a vector with the hashed result
 #[wasm_bindgen]
 pub fn ext_pbkdf2(data: &[u8], salt: &[u8], rounds: u32) -> Vec<u8> {
-	let mut result = [0u8; 64];
+	let mut res = [0u8; 64];
 
 	// we cast to usize here - due to the WASM, we'd rather have u32 inputs
-	pbkdf2::<Hmac<Sha512>>(data, salt, rounds as usize, &mut result);
+	pbkdf2::<Hmac::<Sha512>>(data, salt, rounds as usize, &mut res);
 
-	result.to_vec()
+	res.to_vec()
 }
 
 /// scrypt kdf from input, salt and config
@@ -87,72 +119,41 @@ pub fn ext_pbkdf2(data: &[u8], salt: &[u8], rounds: u32) -> Vec<u8> {
 /// Returns vector with the hashed result
 #[wasm_bindgen]
 pub fn ext_scrypt(password: &[u8], salt: &[u8], log2_n: u8, r: u32, p: u32) -> Vec<u8> {
-	let params = ScryptParams::new(log2_n, r, p).unwrap();
-	let mut result = [0u8; 64];
+	match ScryptParams::new(log2_n, r, p) {
+		Ok(p) => {
+			let mut res = [0u8; 64];
 
-	match scrypt(password, salt, &params, &mut result) {
-		Ok(_) => return result.to_vec(),
-		Err(_) => panic!("Invalid scrypt hash.")
+			match scrypt(password, salt, &p, &mut res) {
+				Ok(_) => res.to_vec(),
+				_ => panic!("Invalid scrypt hash.")
+			}
+		},
+		_ => panic!("Invalid scrypt params.")
 	}
+
 }
 
-// /// Checks for the recoverability of a signature from message
-// ///
-// /// * message: The message
-// /// * signature: The signature
-// ///
-// /// Returns 0 on success, or a specific error code
-// #[wasm_bindgen]
-// pub fn ext_secp256k1_is_recoverable(message: &[u8], signature: &[u8]) -> u32 {
-// 	let rs = match secp256k1::Signature::parse_slice(&signature[0..64]) {
-// 		Ok(rs) => rs,
-// 		_ => return 1
-// 	};
-// 	let v = match secp256k1::RecoveryId::parse(if signature[64] > 26 { signature[64] - 27 } else { signature[64] } as u8) {
-// 		Ok(v) => v,
-// 		_ => return 2
-// 	};
-// 	let mut msg = [0u8; 32];
+/// sha256 hash for the specified input
+///
+/// * data: Arbitrary data to be hashed
+///
+/// Returns a vector with the hash result
+#[wasm_bindgen]
+pub fn ext_sha256(data: &[u8]) -> Vec<u8> {
+	let mut hasher = Sha256::new();
 
-// 	msg.copy_from_slice(&message);
+	hasher.input(data);
 
-// 	match secp256k1::recover(&secp256k1::Message::parse(&msg), &rs, &v) {
-// 		Ok(_) => 0,
-// 		_ => 3
-// 	}
-// }
-
-// /// Recovers the secp256k1 signature from the input
-// ///
-// /// * message: The message
-// /// * signature: The signature
-// ///
-// /// Returns a vector with the recovered public key
-// #[wasm_bindgen]
-// pub fn ext_secp256k1_recover(message: &[u8], signature: &[u8]) -> Vec<u8> {
-// 	let rs = match secp256k1::Signature::parse_slice(&signature[0..64]) {
-// 		Ok(rs) => rs,
-// 		_ => panic!("Unable to recover r,s")
-// 	};
-// 	let v = match secp256k1::RecoveryId::parse(if signature[64] > 26 { signature[64] - 27 } else { signature[64] } as u8) {
-// 		Ok(v) => v,
-// 		_ => panic!("Unable to recover v")
-// 	};
-// 	let mut msg = [0u8; 32];
-
-// 	msg.copy_from_slice(&message);
-
-// 	match secp256k1::recover(&secp256k1::Message::parse(&msg), &rs, &v) {
-// 		Ok(pk) => return pk.serialize()[1..65].to_vec(),
-// 		_ => panic!("Unable to recover publickey")
-// 	}
-// }
+	hasher
+		.result()
+		.to_vec()
+}
 
 /// sha512 hash for the specified input
 ///
 /// * data: Arbitrary data to be hashed
 ///
-/// Returns a vecor with the hash result
+/// Returns a vector with the hash result
 #[wasm_bindgen]
 pub fn ext_sha512(data: &[u8]) -> Vec<u8> {
 	let mut hasher = Sha512::new();
@@ -169,17 +170,23 @@ pub fn ext_sha512(data: &[u8]) -> Vec<u8> {
 /// * data: Arbitrary data to be hashed
 /// * rounds: Number of 8-byte rounds to add to the output
 ///
-/// Returns a vecor with the hash result
+/// Returns a vector with the hash result
 #[wasm_bindgen]
 pub fn ext_twox(data: &[u8], rounds: u32) -> Vec<u8> {
-	let mut vec = vec![];
+	use ::std::hash::Hasher;
+	let mut res = vec![];
+	let mut buf = [0u8; 8];
 
 	for round in 0..rounds {
 		// we cast to u64 here - due to the WASM, we'd rather have u32 inputs
-		vec.extend_from_slice(&create_twox(data, round as u64));
+		let mut hasher = XxHash::with_seed(round as u64);
+
+		hasher.write(data);
+		LittleEndian::write_u64(&mut buf, hasher.finish());
+		res.extend_from_slice(&buf);
 	}
 
-	vec
+	res
 }
 
 #[cfg(test)]
@@ -187,24 +194,6 @@ pub mod tests {
 	use hex_literal::hex;
 	use super::*;
 
-	// // Constructs the message that Ethereum RPC's `personal_sign` and `eth_sign` would sign.
-	// fn ethereum_signable_message(data: &[u8]) -> Vec<u8> {
-	// 	let prefix = b"Pay DOTs to the Polkadot account:";
-	// 	let mut l = prefix.len() + data.len();
-	// 	let mut rev = Vec::new();
-	// 	let mut v = b"\x19Ethereum Signed Message:\n".to_vec();
-
-	// 	while l > 0 {
-	// 		rev.push(b'0' + (l % 10) as u8);
-	// 		l /= 10;
-	// 	}
-
-	// 	v.extend(rev.into_iter().rev());
-	// 	v.extend_from_slice(&prefix[..]);
-	// 	v.extend_from_slice(data);
-	// 	v
-	// }
-
 	#[test]
 	fn can_blake2b() {
 		let data = b"abc";
@@ -226,6 +215,35 @@ pub mod tests {
 		assert_eq!(hash[..], expected[..]);
 	}
 
+	#[test]
+	fn can_hmac_sha256() {
+		let key = b"secret";
+		let data = b"some message";
+		let expected = hex!("f28a70b41263840e5c059a0a733336e0957efba87902aa8cca11441d4b0c96d7");
+		let hash = ext_hmac_sha256(key, data);
+
+		assert_eq!(hash[..], expected[..]);
+	}
+
+	#[test]
+	fn can_hmac_sha512() {
+		let key = b"secret";
+		let data = b"some message";
+		let expected = hex!("295832e97ed77be75a9fa98029497e4a722c4b9a2f21b39d34f1befa931a39ec520fd24711d6f5c03501384ea66b83066a01a82c57a0460f8cd1f471fcce5841");
+		let hash = ext_hmac_sha512(key, data);
+
+		assert_eq!(hash[..], expected[..]);
+	}
+
+	#[test]
+	fn can_keccak512() {
+		let data = b"test";
+		let expected = hex!("1e2e9fc2002b002d75198b7503210c05a1baac4560916a3c6d93bcce3a50d7f00fd395bf1647b9abb8d1afcc9c76c289b0c9383ba386a956da4b38934417789e");
+		let hash = ext_keccak512(data);
+
+		assert_eq!(hash[..], expected[..]);
+	}
+
 	#[test]
 	fn can_pbkdf2() {
 		let salt = b"this is a salt";
@@ -246,16 +264,14 @@ pub mod tests {
 		assert_eq!(hash[..], expected[..]);
 	}
 
-	// #[test]
-	// fn can_secp256k1_real_eth_sig() {
-	// 	let sig = hex!("7505f2880114da51b3f5d535f8687953c0ab9af4ab81e592eaebebf53b728d2b6dfd9b5bcd70fee412b1f31360e7c2774009305cb84fc50c1d0ff8034dfa5fff1c");
-	// 	let pk = hex!("DF67EC7EAe23D2459694685257b6FC59d1BAA1FE");
-	// 	let data = [42, 0, 0, 0, 0, 0, 0, 0];
-	// 	let msg = ext_keccak256(&ethereum_signable_message(&data));
-	// 	let result = ext_keccak256(&ext_secp256k1_recover(&msg[..], &sig[..]));
+	#[test]
+	fn can_sha256() {
+		let data = b"hello world";
+		let expected = hex!("b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9");
+		let hash = ext_sha256(data);
 
-	// 	assert_eq!(result[12..], pk[..]);
-	// }
+		assert_eq!(hash[..], expected[..]);
+	}
 
 	#[test]
 	fn can_sha512() {

packages/wasm-crypto/src/rs/secp256k1.rs

@@ -0,0 +1,126 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+use libsecp256k1::{Message, PublicKey, RecoveryId, SecretKey, Signature, recover, sign};
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub fn ext_secp_pub_compress(pubkey: &[u8]) -> Vec<u8> {
+	match PublicKey::parse_slice(&pubkey, None) {
+		Ok(p) => p
+			.serialize_compressed()
+			.to_vec(),
+		_ => panic!("Invalid pubkey provided.")
+	}
+}
+
+#[wasm_bindgen]
+pub fn ext_secp_pub_expand(pubkey: &[u8]) -> Vec<u8> {
+	match PublicKey::parse_slice(&pubkey, None) {
+		Ok(p) => p
+			.serialize()
+			.to_vec(),
+		_ => panic!("Invalid pubkey provided.")
+	}
+}
+
+#[wasm_bindgen]
+pub fn ext_secp_from_seed(seed: &[u8]) -> Vec<u8> {
+	match SecretKey::parse_slice(seed) {
+		Ok(s) => {
+			let mut res = vec![];
+			let pubkey = PublicKey::from_secret_key(&s);
+
+			res.extend_from_slice(&s.serialize());
+			res.extend_from_slice(&pubkey.serialize_compressed());
+
+			res
+		},
+		_ => panic!("Invalid seed provided.")
+	}
+}
+
+#[wasm_bindgen]
+pub fn ext_secp_recover(hash: &[u8], sig: &[u8], rec: u8) -> Vec<u8> {
+	match (Message::parse_slice(hash), Signature::parse_standard_slice(sig), RecoveryId::parse(rec)) {
+		(Ok(m), Ok(s), Ok(r)) =>
+			match recover(&m, &s, &r) {
+				Ok(k) => k
+					.serialize_compressed()
+					.to_vec(),
+				_ => panic!("Invalid message provided.")
+			},
+		_ => panic!("Invalid recovery data provided.")
+	}
+}
+
+#[wasm_bindgen]
+pub fn ext_secp_sign(hash: &[u8], seckey: &[u8]) -> Vec<u8> {
+	match (Message::parse_slice(hash), SecretKey::parse_slice(seckey)) {
+		(Ok(m), Ok(s)) => {
+			let mut res = vec![];
+			let (sig, rec) = sign(&m, &s);
+
+			res.extend_from_slice(&sig.serialize());
+			res.push(rec.into());
+
+			res
+		},
+		_ => panic!("Invalid message or secret provided.")
+	}
+}
+
+#[cfg(test)]
+pub mod tests {
+	use hex_literal::hex;
+	use super::*;
+
+	#[test]
+	fn can_create_pair() {
+		let seckey = hex!("4380de832af797688026ce24f85204d508243f201650c1a134929e5458b7fbae");
+		let expected = hex!("4380de832af797688026ce24f85204d508243f201650c1a134929e5458b7fbae03fd8c74f795ced92064b86191cb2772b1e3a0947740aa0a5a6e379592471fd85b");
+		let res = ext_secp_from_seed(&seckey);
+
+		assert_eq!(res[..], expected[..]);
+	}
+
+	#[test]
+	fn can_pub_compress_full() {
+		let pubkey = hex!("04b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb1307763fe926c273235fd979a134076d00fd1683cbd35868cb485d4a3a640e52184af");
+		let expected = hex!("03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077");
+		let res = ext_secp_pub_compress(&pubkey);
+
+		assert_eq!(res[..], expected[..]);
+	}
+
+	#[test]
+	fn can_pub_expand_comp() {
+		let pubkey = hex!("03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077");
+		let expected = hex!("04b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb1307763fe926c273235fd979a134076d00fd1683cbd35868cb485d4a3a640e52184af");
+		let res = ext_secp_pub_expand(&pubkey);
+
+		assert_eq!(res[..], expected[..]);
+	}
+
+	#[test]
+	fn can_recover() {
+		let expected = hex!("028d13da15a02f3a70677339d51b14177ee9b49657662b35e56a9d9dee17db1d30");
+		let sig = hex!("7505f2880114da51b3f5d535f8687953c0ab9af4ab81e592eaebebf53b728d2b6dfd9b5bcd70fee412b1f31360e7c2774009305cb84fc50c1d0ff8034dfa5fff");
+    	let msg = hex!("a30b64ce1eedf409c8afb801d72c05234e64849ea538c15dd3c8cf4ffcf166c9");
+		let res = ext_secp_recover(&msg, &sig, 0);
+
+		assert_eq!(res[..], expected[..]);
+	}
+
+	#[test]
+	fn can_sign() {
+		// JS expectation - doesn't match?
+		// let expected = hex!("df92f73d9f060cefacf187b5414491cb992998ace017fa48839b5cda3e264ba8c4efa521361678d9b8582744d77aa4b8d886d7380b7808a683174afad9c4700300");
+		let expected = hex!("df92f73d9f060cefacf187b5414491cb992998ace017fa48839b5cda3e264ba83b105adec9e9872647a7d8bb28855b45e22805aea3d097953cbb1391f671d13e01");
+		let seckey = hex!("4380de832af797688026ce24f85204d508243f201650c1a134929e5458b7fbae");
+		let msg = hex!("68c731589a583d08b70861683b59ce3dd56284cb2f0da5b6cd83e6641dac3aab");
+		let res = ext_secp_sign(&msg, &seckey);
+
+		assert_eq!(res[..], expected[..]);
+	}
+}

packages/wasm-crypto/src/rs/sr25519.rs

@@ -1,12 +1,13 @@
-// Copyright 2019 Paritytech via https://github.com/paritytech/schnorrkel-js/
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
 
+// Copyright 2019 Paritytech via https://github.com/paritytech/schnorrkel-js/
+//
 // Originally developed (as a fork) in https://github.com/polkadot-js/schnorrkel-js/
 // which was adpated from the initial https://github.com/paritytech/schnorrkel-js/
 // forked at commit eff430ddc3090f56317c80654208b8298ef7ab3f
 
+use curve25519_dalek::scalar::Scalar;
 use schnorrkel::{
 	ExpansionMode, Keypair, MiniSecretKey, PublicKey, SecretKey, Signature,
 	derive::{Derivation, ChainCode, CHAIN_CODE_LENGTH},
@@ -14,10 +15,10 @@ use schnorrkel::{
 use wasm_bindgen::prelude::*;
 
 // We must make sure that this is the same as declared in the substrate source code.
-const SIGNING_CTX: &'static [u8] = b"substrate";
+const CTX: &'static [u8] = b"substrate";
 
 /// ChainCode construction helper
-fn create_cc(data: &[u8]) -> ChainCode {
+fn new_cc(data: &[u8]) -> ChainCode {
 	let mut cc = [0u8; CHAIN_CODE_LENGTH];
 
 	cc.copy_from_slice(&data);
@@ -33,13 +34,14 @@ fn create_cc(data: &[u8]) -> ChainCode {
 /// returned vector the derived keypair as a array of 96 bytes
 #[wasm_bindgen]
 pub fn ext_sr_derive_keypair_hard(pair: &[u8], cc: &[u8]) -> Vec<u8> {
-	Keypair::from_half_ed25519_bytes(pair)
-		.unwrap()
-		.secret
-		.hard_derive_mini_secret_key(Some(create_cc(cc)), &[]).0
-		.expand_to_keypair(ExpansionMode::Ed25519)
-		.to_half_ed25519_bytes()
-		.to_vec()
+	match Keypair::from_half_ed25519_bytes(pair) {
+		Ok(p) => p.secret
+			.hard_derive_mini_secret_key(Some(new_cc(cc)), &[]).0
+			.expand_to_keypair(ExpansionMode::Ed25519)
+			.to_half_ed25519_bytes()
+			.to_vec(),
+		_ => panic!("Invalid pair provided.")
+	}
 }
 
 /// Perform a derivation on a secret
@@ -50,11 +52,13 @@ pub fn ext_sr_derive_keypair_hard(pair: &[u8], cc: &[u8]) -> Vec<u8> {
 /// returned vector the derived keypair as a array of 96 bytes
 #[wasm_bindgen]
 pub fn ext_sr_derive_keypair_soft(pair: &[u8], cc: &[u8]) -> Vec<u8> {
-	Keypair::from_half_ed25519_bytes(pair)
-		.unwrap()
-		.derived_key_simple(create_cc(cc), &[]).0
-		.to_half_ed25519_bytes()
-		.to_vec()
+	match Keypair::from_half_ed25519_bytes(pair) {
+		Ok(p) => p
+			.derived_key_simple(new_cc(cc), &[]).0
+			.to_half_ed25519_bytes()
+			.to_vec(),
+		_ => panic!("Invalid pair provided.")
+	}
 }
 
 /// Perform a derivation on a publicKey
@@ -65,11 +69,13 @@ pub fn ext_sr_derive_keypair_soft(pair: &[u8], cc: &[u8]) -> Vec<u8> {
 /// returned vector is the derived publicKey as a array of 32 bytes
 #[wasm_bindgen]
 pub fn ext_sr_derive_public_soft(pubkey: &[u8], cc: &[u8]) -> Vec<u8> {
-	PublicKey::from_bytes(pubkey)
-		.unwrap()
-		.derived_key_simple(create_cc(cc), &[]).0
-		.to_bytes()
-		.to_vec()
+	match PublicKey::from_bytes(pubkey) {
+		Ok(k) => k
+			.derived_key_simple(new_cc(cc), &[]).0
+			.to_bytes()
+			.to_vec(),
+		_ => panic!("Invalid pubkey provided.")
+	}
 }
 
 /// Generate a key pair.
@@ -80,11 +86,13 @@ pub fn ext_sr_derive_public_soft(pubkey: &[u8], cc: &[u8]) -> Vec<u8> {
 /// followed by the public key (32) bytes.
 #[wasm_bindgen]
 pub fn ext_sr_from_seed(seed: &[u8]) -> Vec<u8> {
-	MiniSecretKey::from_bytes(seed)
-		.unwrap()
-		.expand_to_keypair(ExpansionMode::Ed25519)
-		.to_half_ed25519_bytes()
-		.to_vec()
+	match MiniSecretKey::from_bytes(seed) {
+		Ok(s) => s
+			.expand_to_keypair(ExpansionMode::Ed25519)
+			.to_half_ed25519_bytes()
+			.to_vec(),
+		_ => panic!("Invalid seed provided.")
+	}
 }
 
 /// Generate a key pair from a known pair. (This is not exposed via WASM)
@@ -94,10 +102,12 @@ pub fn ext_sr_from_seed(seed: &[u8]) -> Vec<u8> {
 /// returned vector is the concatenation of first the private key (64 bytes)
 /// followed by the public key (32) bytes.
 pub fn ext_sr_from_pair(pair: &[u8]) -> Vec<u8> {
-	Keypair::from_half_ed25519_bytes(pair)
-		.unwrap()
-		.to_half_ed25519_bytes()
-		.to_vec()
+	match Keypair::from_half_ed25519_bytes(pair) {
+		Ok(p) => p
+			.to_half_ed25519_bytes()
+			.to_vec(),
+		_ => panic!("Invalid pair provided.")
+	}
 }
 
 /// Sign a message
@@ -112,11 +122,13 @@ pub fn ext_sr_from_pair(pair: &[u8]) -> Vec<u8> {
 /// * returned vector is the signature consisting of 64 bytes.
 #[wasm_bindgen]
 pub fn ext_sr_sign(pubkey: &[u8], secret: &[u8], message: &[u8]) -> Vec<u8> {
-	SecretKey::from_ed25519_bytes(secret)
-		.unwrap()
-		.sign_simple(SIGNING_CTX, message, &PublicKey::from_bytes(pubkey).unwrap())
-		.to_bytes()
-		.to_vec()
+	match (SecretKey::from_ed25519_bytes(secret), PublicKey::from_bytes(pubkey)) {
+		(Ok(s), Ok(k)) => s
+			.sign_simple(CTX, message, &k)
+			.to_bytes()
+			.to_vec(),
+		_ => panic!("Invalid secret or pubkey provided.")
+	 }
 }
 
 /// Verify a message and its corresponding against a public key;
@@ -126,11 +138,37 @@ pub fn ext_sr_sign(pubkey: &[u8], secret: &[u8], message: &[u8]) -> Vec<u8> {
 /// * pubkey: UIntArray with 32 element
 #[wasm_bindgen]
 pub fn ext_sr_verify(signature: &[u8], message: &[u8], pubkey: &[u8]) -> bool {
-	match Signature::from_bytes(signature) {
-		Ok(signature) => PublicKey::from_bytes(pubkey).unwrap()
-			.verify_simple(SIGNING_CTX, message, &signature)
+	match (Signature::from_bytes(signature), PublicKey::from_bytes(pubkey)) {
+		(Ok(s), Ok(k)) => k
+			.verify_simple(CTX, message, &s)
 			.is_ok(),
-		Err(_) => false
+		_ => false
+	}
+}
+
+/// Key agreement between other's public key and self secret key.
+///
+/// * pubkey: UIntArray with 32 element
+/// * secret: UIntArray with 64 element
+///
+/// * returned vector is the generated secret of 32 bytes.
+#[wasm_bindgen]
+pub fn ext_sr_agree(pubkey: &[u8], secret: &[u8]) -> Vec<u8> {
+	match SecretKey::from_ed25519_bytes(secret) {
+		Ok(s) => {
+			// The first 32 bytes holds the canonical private key
+			let mut key = [0u8; 32];
+
+			key.copy_from_slice(&s.to_bytes()[0..32]);
+
+			match (Scalar::from_canonical_bytes(key), PublicKey::from_bytes(pubkey)) {
+				(Some(n), Ok(k)) => (&n * k.as_point())
+					.compress().0
+					.to_vec(),
+				_ => panic!("Invalid scalar or pubkey provided.")
+			}
+		},
+		_ => panic!("Invalid secret provided.")
 	}
 }
 
@@ -139,16 +177,16 @@ pub mod tests {
 	extern crate rand;
 	extern crate schnorrkel;
 
-	use hex_literal::hex;
 	use super::*;
+	use hex_literal::hex;
 	use schnorrkel::{SIGNATURE_LENGTH, KEYPAIR_LENGTH, SECRET_KEY_LENGTH};
 
 	fn generate_random_seed() -> Vec<u8> {
-		(0..32).map(|_| rand::random::<u8>() ).collect()
+		(0..32).map(|_| rand::random::<u8>()).collect()
 	}
 
 	#[test]
-	fn can_create_keypair() {
+	fn can_new_keypair() {
 		let seed = generate_random_seed();
 		let keypair = ext_sr_from_seed(seed.as_slice());
 
@@ -166,7 +204,7 @@ pub mod tests {
 	}
 
 	#[test]
-	fn create_pair_from_known_pair() {
+	fn new_pair_from_known_pair() {
 		let input = hex!("28b0ae221c6bb06856b287f60d7ea0d98552ea5a16db16956849aa371db3eb51fd190cce74df356432b410bd64682309d6dedb27c76845daf388557cbac3ca3446ebddef8cd9bb167dc30878d7113b7e168e6f0646beffd77d69d39bad76b47a");
 		let keypair = ext_sr_from_pair(&input);
 		let expected = hex!("46ebddef8cd9bb167dc30878d7113b7e168e6f0646beffd77d69d39bad76b47a");
@@ -210,6 +248,26 @@ pub mod tests {
 		assert!(is_valid);
 	}
 
+	#[test]
+	fn can_verify_known_wrapped_message() {
+		let message = b"<Bytes>message to sign</Bytes>";
+		let public = hex!("f84d048da2ddae2d9d8fd6763f469566e8817a26114f39408de15547f6d47805");
+		let signature = hex!("48ce2c90e08651adfc8ecef84e916f6d1bb51ebebd16150ee12df247841a5437951ea0f9d632ca165e6ab391532e75e701be6a1caa88c8a6bcca3511f55b4183");
+		let is_valid = ext_sr_verify(&signature, message, &public);
+
+		assert!(is_valid);
+	}
+
+	#[test]
+	fn can_verify_known_wrapped_message_fail() {
+		let message = b"message to sign";
+		let public = hex!("f84d048da2ddae2d9d8fd6763f469566e8817a26114f39408de15547f6d47805");
+		let signature = hex!("48ce2c90e08651adfc8ecef84e916f6d1bb51ebebd16150ee12df247841a5437951ea0f9d632ca165e6ab391532e75e701be6a1caa88c8a6bcca3511f55b4183");
+		let is_valid = ext_sr_verify(&signature, message, &public);
+
+		assert!(!is_valid);
+	}
+
 	#[test]
 	fn soft_derives_pair() {
 		let cc = hex!("0c666f6f00000000000000000000000000000000000000000000000000000000"); // foo
@@ -243,4 +301,32 @@ pub mod tests {
 
 		assert_eq!(public, expected);
 	}
+
+	#[test]
+	fn key_agreement() {
+		let self_seed = hex!("98b3d305d5a5eace562387e47e59badd4d77e3f72cabfb10a60f8a197059f0a8");
+		let other_seed = hex!("9732eea001851ff862d949a1699c9971f3a26edbede2ad7922cbbe9a0701f366");
+		let expected = hex!("b03a0b198c34c16f35cae933d88b16341b4cef3e84e851f20e664c6a30527f4e");
+		let self_pair = ext_sr_from_seed(&self_seed);
+		let self_sk = &self_pair[0..SECRET_KEY_LENGTH];
+		let self_pk = &self_pair[SECRET_KEY_LENGTH..KEYPAIR_LENGTH];
+		let other_pair = ext_sr_from_seed(&other_seed);
+		let other_sk = &other_pair[0..SECRET_KEY_LENGTH];
+		let other_pk = &other_pair[SECRET_KEY_LENGTH..KEYPAIR_LENGTH];
+
+		assert_eq!(ext_sr_agree(self_pk, other_sk), expected);
+		assert_eq!(ext_sr_agree(other_pk, self_sk), expected);
+
+		let seed = generate_random_seed();
+		let self_pair = ext_sr_from_seed(seed.as_slice());
+		let self_sk = &self_pair[0..SECRET_KEY_LENGTH];
+		let self_pk = &self_pair[SECRET_KEY_LENGTH..KEYPAIR_LENGTH];
+
+		let seed = generate_random_seed();
+		let other_pair = ext_sr_from_seed(seed.as_slice());
+		let other_sk = &other_pair[0..SECRET_KEY_LENGTH];
+		let other_pk = &other_pair[SECRET_KEY_LENGTH..KEYPAIR_LENGTH];
+
+		assert_eq!(ext_sr_agree(self_pk, other_sk), ext_sr_agree(other_pk, self_sk));
+	}
 }

packages/wasm-crypto/src/rs/vrf.rs

@@ -0,0 +1,144 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Copyright 2019 Paritytech via https://github.com/paritytech/schnorrkel-js/
+//
+// Originally developed (as a fork) in https://github.com/polkadot-js/schnorrkel-js/
+// which was adpated from the initial https://github.com/paritytech/schnorrkel-js/
+// forked at commit eff430ddc3090f56317c80654208b8298ef7ab3f
+
+use merlin::Transcript;
+use schnorrkel::{signing_context, vrf::{VRFOutput, VRFProof}, PublicKey, SecretKey};
+use wasm_bindgen::prelude::*;
+
+/// Size of VRF output, bytes
+pub const OUTPUT_SIZE: usize = 32;
+
+/// Size of VRF proof, bytes
+pub const PROOF_SIZE: usize = 64;
+
+/// Size of VRF raw output, bytes
+pub const RAW_OUTPUT_SIZE: usize = 16;
+
+/// Size of VRF limit, bytes
+pub const THRESHOLD_SIZE: usize = 16;
+
+/// Size of the final full output
+pub const RESULT_SIZE: usize = OUTPUT_SIZE + PROOF_SIZE;
+
+pub fn new_transcript(extra: &[u8]) -> Transcript {
+	let mut transcript = Transcript::new(b"VRF");
+
+	// if is important that we don't append when empty, since the
+	// append in merging encodes length information
+	if extra.len() > 0 {
+		transcript.append_message(b"", extra);
+	}
+
+	transcript
+}
+
+// We don't use the non-extra sign and verify internally  since in sr25519 they only wrap -
+//
+// https://github.com/w3f/schnorrkel/blob/8fa2ad3e9fbf0b652c724df6a87a4b3c5500f759/src/vrf.rs#L660
+
+/// Run a Random Verifiable Function (VRF) on one single input
+/// (message) transcript, and an extra message transcript,
+/// producing the output signature and corresponding short proof.
+///
+/// * secret: UIntArray with 64 element
+/// * context: Arbitrary length UIntArray
+/// * message: Arbitrary length UIntArray
+/// * extra: Arbitrary length UIntArray
+///
+/// * returned vector is the 32-byte output (signature) and 64-byte proof.
+#[wasm_bindgen]
+pub fn ext_vrf_sign(secret: &[u8], ctx: &[u8], msg: &[u8], extra: &[u8]) -> Vec<u8> {
+	match SecretKey::from_ed25519_bytes(secret) {
+		Ok(s) => {
+			let mut res: [u8; RESULT_SIZE] = [0u8; RESULT_SIZE];
+			let (io, proof, _) = s
+				.to_keypair()
+				.vrf_sign_extra(signing_context(ctx).bytes(msg), new_transcript(extra));
+
+			res[..OUTPUT_SIZE].copy_from_slice(io.as_output_bytes());
+			res[OUTPUT_SIZE..].copy_from_slice(&proof.to_bytes());
+
+			res.to_vec()
+		},
+		_ => panic!("Invalid secret provided.")
+	}
+}
+
+/// Verify VRF proof for one single input transcript, and an extra message transcript,
+/// and corresponding output.
+///
+/// * pubkey: UIntArray with 32 element
+/// * context: Arbitrary length UIntArray
+/// * message: Arbitrary length UIntArray
+/// * extra: Arbitrary length UIntArray
+/// * out_and_proof: 96-byte output & proof array from the ext_sign function.
+#[wasm_bindgen]
+pub fn ext_vrf_verify(pubkey: &[u8], ctx: &[u8], msg: &[u8], extra: &[u8], out: &[u8]) -> bool {
+	match (PublicKey::from_bytes(pubkey), VRFOutput::from_bytes(&out[..OUTPUT_SIZE]), VRFProof::from_bytes(&out[OUTPUT_SIZE..RESULT_SIZE])) {
+		(Ok(k), Ok(o), Ok(p)) => k
+			.vrf_verify_extra(signing_context(ctx).bytes(msg), &o, &p, new_transcript(extra))
+			.is_ok(),
+		_ => false,
+	}
+}
+
+#[cfg(test)]
+pub mod tests {
+	extern crate rand;
+	extern crate schnorrkel;
+
+	use super::*;
+	use crate::sr25519::ext_sr_from_seed;
+	use schnorrkel::{KEYPAIR_LENGTH, SECRET_KEY_LENGTH};
+
+	fn generate_random_seed() -> Vec<u8> {
+		(0..32).map(|_| rand::random::<u8>()).collect()
+	}
+
+	#[test]
+	fn sign_extra_and_verify() {
+		let seed = generate_random_seed();
+		let keypair = ext_sr_from_seed(seed.as_slice());
+		let private = &keypair[0..SECRET_KEY_LENGTH];
+		let public = &keypair[SECRET_KEY_LENGTH..KEYPAIR_LENGTH];
+		let context = b"my VRF context";
+		let message = b"this is a message";
+		let extra = b"this is an extra";
+
+		// Perform multiple sign_extra calls w/ same context, message, extra args
+		let out1 = ext_vrf_sign(private, context, message, extra);
+		let out2 = ext_vrf_sign(private, context, message, extra);
+
+		// Basic size checks
+		assert!(out1.len() == RESULT_SIZE);
+		assert!(out2.len() == RESULT_SIZE);
+
+		// Given the same context, message & extra, output should be deterministic
+		assert_eq!(&out1[..OUTPUT_SIZE], &out2[..OUTPUT_SIZE]);
+
+		// But proof is non-deterministic
+		assert_ne!(&out1[OUTPUT_SIZE..], &out2[OUTPUT_SIZE..]);
+
+		// VRF outputs can verified w/ original context, message & extra args
+		assert!(ext_vrf_verify(
+			public,
+			context,
+			message,
+			extra,
+			&out1
+		));
+		assert!(ext_vrf_verify(
+			public,
+			context,
+			message,
+			extra,
+			&out2
+		));
+	}
+}

packages/wasm-crypto/src/types.ts

@@ -0,0 +1,87 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable camelcase */
+
+// wasm-pack build output (formatted) from pkg/wasm_bg.d.ts
+export interface WasmCryptoInstance {
+  memory: WebAssembly.Memory;
+
+  // wbindgen functions (required and used internally)
+
+  __wbindgen_free(a: number, b: number): void;
+
+  __wbindgen_malloc(a: number): number;
+
+  __wbindgen_realloc(a: number, b: number, c: number): number;
+
+  __wbindgen_exn_store(a: number): void;
+
+  // exposed functions
+
+  ext_bip39_generate(resLen: 8, words: number): void;
+
+  ext_bip39_to_entropy(resLen: 8, ptrPhrase: number, lenPhrase: number): void;
+
+  ext_bip39_to_mini_secret(resLen: 8, ptrPhrase: number, lenPhrase: number, ptrPass: number, lenPass: number): void;
+
+  ext_bip39_to_seed(resLen: 8, ptrPhrase: number, lenPhrase: number, ptrPass: number, lenPass: number): void;
+
+  ext_bip39_validate(ptrPhrase: number, lenPhrase: number): number;
+
+  ext_ed_from_seed(resLen: 8, ptrSeed: number, lenSeed: number): void;
+
+  ext_ed_sign(resLen: 8, ptrPub: number, lenPub: number, ptrSec: number, lenSec: number, ptrMsg: number, lenMsg: number): void;
+
+  ext_ed_verify(ptrSig: number, lenSig: number, ptrMsg: number, lenMsg: number, ptrPub: number, lenPub: number): number;
+
+  ext_blake2b(resLen: 8, ptrData: number, lenData: number, ptrKey: number, lenKey: number, size: number): void;
+
+  ext_hmac_sha256(resLen: 8, ptrKey: number, lenKey: number, ptrData: number, lenData: number): void;
+
+  ext_hmac_sha512(resLen: 8, ptrKey: number, lenKey: number, ptrData: number, lenData: number): void;
+
+  ext_keccak256(resLen: 8, ptrData: number, lenData: number): void;
+
+  ext_keccak512(resLen: 8, ptrData: number, lenData: number): void;
+
+  ext_pbkdf2(resLen: 8, ptrData: number, lenData: number, ptrSalt: number, lenSalt: number, rounds: number): void;
+
+  ext_scrypt(resLen: 8, ptrPass: number, lenPass: number, ptrSalt: number, lenSalt: number, log2n: number, r: number, p: number): void;
+
+  ext_sha256(resLen: 8, ptrData: number, lenData: number): void;
+
+  ext_sha512(resLen: 8, ptrData: number, lenData: number): void;
+
+  ext_twox(resLen: 8, ptrData: number, lenData: number, rounds: number): void;
+
+  ext_secp_from_seed(reslen: 8, ptrSec: number, lenSec: number): void;
+
+  ext_secp_pub_compress(resLen: 8, ptrPub: number, lenPub: number): void;
+
+  ext_secp_pub_expand(resLen: 8, ptrPub: number, lenPub: number): void;
+
+  ext_secp_recover(resLen: 8, ptrMsgHash: number, lenMsgHash: number, ptrSig: number, lenSig: number, recovery: number): void;
+
+  ext_secp_sign(resLen: 8, ptrMsgHash: number, lenMsgHash: number, ptrSec: number, lenSec: number): void;
+
+  ext_sr_derive_keypair_hard(resLen: 8, ptrPair: number, lenPair: number, ptrCc: number, lenCc: number): void;
+
+  ext_sr_derive_keypair_soft(resLen: 8, ptrPub: number, lenPub: number, ptrCc: number, lenCc: number): void;
+
+  ext_sr_derive_public_soft(resLen: 8, ptrPub: number, lenPub: number, ptrCc: number, lenCc: number): void;
+
+  ext_sr_from_seed(resLen: 8, ptrSeed: number, lenSeed: number): void;
+
+  ext_sr_sign(resLen: 8, ptrPub: number, lenPub: number, ptrSec: number, lenSec: number, ptrMsg: number, lenMsg: number): void;
+
+  ext_sr_verify(ptrSig: number, lenSig: number, ptrMsg: number, lenMsg: number, ptrPub: number, lenPub: number): number;
+
+  ext_sr_agree(resLen: 8, ptrPub: number, lenPub: number, ptrSec: number, lenSec: number): void;
+
+  ext_vrf_sign(resLen: 8, ptrSec: number, lenSec: number, ptrCtx: number, lenCtx: number, ptrMsg: number, lenMsg: number, ptrExtra: number, lenExtra: number): void;
+
+  ext_vrf_verify(ptrPub: number, lenPub: number, ptrCtx: number, lenCtx: number, ptrMsg: number, lenMsg: number, ptrExtra: number, lenExtra: number, ptrProof: number, lenProof: number): number;
+}
+
+export type AsmCreator = (wbg: Record<string, WebAssembly.ImportValue>) => WasmCryptoInstance;

packages/wasm-crypto/test/alias-imports.cjs

@@ -0,0 +1,23 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const rootIncl = ['@polkadot/wasm-crypto', '@polkadot/wasm-crypto-asmjs', '@polkadot/wasm-crypto-wasm'];
+const detcIncl = [
+  ...rootIncl.map((p) => `${p}/initOnlyAsm.cjs`),
+  ...rootIncl.map((p) => `${p}/initOnlyWasm.cjs`),
+  ...rootIncl.map((p) => `${p}/packageInfo.cjs`)
+];
+
+require('override-require')(
+  (request) =>
+    rootIncl.some((p) => request.endsWith(p)) ||
+    detcIncl.some((p) => request.endsWith(p)),
+  (request) =>
+    rootIncl.some((p) => request.endsWith(p))
+      ? require(`${rootIncl.find((p) => request.endsWith(p))}/build/index.cjs`)
+      : require(`${detcIncl.find((p) => request.endsWith(p))
+        .replace('initOnlyAsm.cjs', 'build/initOnlyAsm.cjs')
+        .replace('initOnlyWasm.cjs', 'build/initOnlyWasm.cjs')
+        .replace('packageInfo.cjs', 'build/packageInfo.cjs')
+      }`)
+);

packages/wasm-crypto/test/all/bip39.cjs

@@ -0,0 +1,63 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const { assert, u8aToHex } = require('@polkadot/util');
+
+function bip39Generate (wasm) {
+  const res = wasm.bip39Generate(21);
+
+  console.log('\tPHR', res);
+
+  assert(res.split(' ').length === 21, 'ERROR: Invalid bip39 Phase length');
+}
+
+function bip39GenerateSubsequent (wasm) {
+  const val1 = wasm.bip39Generate(24);
+  const val2 = wasm.bip39Generate(24);
+
+  console.log('\tVL1', val1);
+  console.log('\tVL2', val2);
+
+  assert(val1 !== val2, 'ERROR: Subsequent mnemonics are the same');
+}
+
+function bip39Validate (wasm) {
+  const res = wasm.bip39Validate(wasm.bip39Generate(12));
+
+  console.log('\tVAL', res);
+
+  assert(res, 'ERROR: Invalid bip39 validation');
+}
+
+function bip39ToEntropy (wasm) {
+  const res = u8aToHex(wasm.bip39ToEntropy('legal winner thank year wave sausage worth useful legal winner thank yellow'));
+
+  console.log('\tENT', res);
+
+  assert(res === '0x7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f', 'ERROR: Invalid bip39 entropy');
+}
+
+function bip39ToMiniSecret (wasm) {
+  const res = u8aToHex(wasm.bip39ToMiniSecret('legal winner thank year wave sausage worth useful legal winner thank yellow', 'Substrate'));
+
+  console.log('\tMIN', res);
+
+  assert(res === '0x4313249608fe8ac10fd5886c92c4579007272cb77c21551ee5b8d60b78041685', 'ERROR: Invalid bip39 mini secret');
+}
+
+function bip39ToSeed (wasm) {
+  const res = u8aToHex(wasm.bip39ToSeed('seed sock milk update focus rotate barely fade car face mechanic mercy', ''));
+
+  console.log('\tSEE', res);
+
+  assert(res === '0x3c121e20de068083b49c2315697fb59a2d9e8643c24e5ea7628132c58969a027', 'ERROR: Invalid bip39 mini secret');
+}
+
+module.exports = {
+  bip39Generate,
+  bip39GenerateSubsequent,
+  bip39ToEntropy,
+  bip39ToMiniSecret,
+  bip39ToSeed,
+  bip39Validate
+};

packages/wasm-crypto/test/all/bip39.js

@@ -1,47 +0,0 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-// @ts-check
-
-/* eslint-disable camelcase */
-
-const { assert, u8aToHex } = require('@polkadot/util');
-
-function bip39_generate (wasm) {
-  const RESULT = wasm.bip39Generate(21);
-
-  console.log('\tPHR', RESULT);
-
-  assert(RESULT.split(' ').length === 21, 'ERROR: Invalid bip39 Phase length');
-}
-
-function bip39_validate (wasm) {
-  const RESULT = wasm.bip39Validate(wasm.bip39Generate(12));
-
-  console.log('\tVAL', RESULT);
-
-  assert(RESULT, 'ERROR: Invalid bip39 validation');
-}
-
-function bip39_toEntropy (wasm) {
-  const RESULT = u8aToHex(wasm.bip39ToEntropy('legal winner thank year wave sausage worth useful legal winner thank yellow'));
-
-  console.log('\tENT', RESULT);
-
-  assert(RESULT === '0x7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f', 'ERROR: Invalid bip39 entropy');
-}
-
-function bip39_toMiniSecret (wasm) {
-  const RESULT = u8aToHex(wasm.bip39ToMiniSecret('legal winner thank year wave sausage worth useful legal winner thank yellow', 'Substrate'));
-
-  console.log('\tMIN', RESULT);
-
-  assert(RESULT === '0x4313249608fe8ac10fd5886c92c4579007272cb77c21551ee5b8d60b78041685', 'ERROR: Invalid bip39 mini secret');
-}
-
-module.exports = {
-  bip39_generate,
-  bip39_toEntropy,
-  bip39_toMiniSecret,
-  bip39_validate
-};

packages/wasm-crypto/test/all/ed25519.cjs

@@ -1,8 +1,5 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-/* eslint-disable camelcase */
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
 
 const crypto = require('crypto');
 const { assert, hexToU8a, stringToU8a, u8aToHex } = require('@polkadot/util');
@@ -15,7 +12,7 @@ function randomPair (wasm) {
   return extractKeys(wasm.ed25519KeypairFromSeed(crypto.randomBytes(32)));
 }
 
-function ed25519_pairFromSeed (wasm) {
+function ed25519PairFromSeed (wasm) {
   const [pair, pk, sk] = extractKeys(wasm.ed25519KeypairFromSeed(stringToU8a('12345678901234567890123456789012')));
 
   console.log('\tSEC', u8aToHex(sk));
@@ -24,7 +21,7 @@ function ed25519_pairFromSeed (wasm) {
   assert(u8aToHex(pair) === '0x31323334353637383930313233343536373839303132333435363738393031322f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee', 'ERROR: pairFromSeed() does not match');
 }
 
-function ed25519_signAndVerify (wasm) {
+function ed25519SignAndVerify (wasm) {
   const [, pk, sk] = randomPair(wasm);
   const signature = wasm.ed25519Sign(pk, sk, stringToU8a('this is a message'));
   const isValid = wasm.ed25519Verify(signature, stringToU8a('this is a message'), pk);
@@ -35,7 +32,7 @@ function ed25519_signAndVerify (wasm) {
   assert(isValid, 'ERROR: Unable to verify signature');
 }
 
-function ed25519_verifyExisting (wasm) {
+function ed25519VerifyExisting (wasm) {
   const isValid = wasm.ed25519Verify(hexToU8a('0x90588f3f512496f2dd40571d162e8182860081c74e2085316e7c4396918f07da412ee029978e4dd714057fe973bd9e7d645148bf7b66680d67c93227cde95202'), stringToU8a('this is a message'), hexToU8a('0x2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee'));
 
   console.log('\tRES', isValid);
@@ -43,7 +40,7 @@ function ed25519_verifyExisting (wasm) {
   assert(isValid, 'ERROR: Unable to verify signature');
 }
 
-function ed25519_benchmark (wasm) {
+function ed25519Benchmark (wasm) {
   const MESSAGE = stringToU8a('this is a message');
 
   for (let i = 0; i < 256; i++) {
@@ -54,8 +51,8 @@ function ed25519_benchmark (wasm) {
 }
 
 module.exports = {
-  ed25519_benchmark,
-  ed25519_pairFromSeed,
-  ed25519_signAndVerify,
-  ed25519_verifyExisting
+  ed25519Benchmark,
+  ed25519PairFromSeed,
+  ed25519SignAndVerify,
+  ed25519VerifyExisting
 };

packages/wasm-crypto/test/all/hashing.cjs

@@ -1,8 +1,5 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-/* eslint-disable camelcase */
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
 
 const { assert, stringToU8a, u8aToHex } = require('@polkadot/util');
 
@@ -14,6 +11,22 @@ function blake2bHash (wasm) {
   assert(hash === '0xba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923', 'ERROR: blake2bHash does not match');
 }
 
+function hmacSha256 (wasm) {
+  const hash = u8aToHex(wasm.hmacSha256(stringToU8a('secret'), stringToU8a('some message')));
+
+  console.log('\tRES', hash);
+
+  assert(hash === '0xf28a70b41263840e5c059a0a733336e0957efba87902aa8cca11441d4b0c96d7', 'ERROR: hmacSha256 does not match');
+}
+
+function hmacSha512 (wasm) {
+  const hash = u8aToHex(wasm.hmacSha512(stringToU8a('secret'), stringToU8a('some message')));
+
+  console.log('\tRES', hash);
+
+  assert(hash === '0x295832e97ed77be75a9fa98029497e4a722c4b9a2f21b39d34f1befa931a39ec520fd24711d6f5c03501384ea66b83066a01a82c57a0460f8cd1f471fcce5841', 'ERROR: hmacSha512 does not match');
+}
+
 function keccak256 (wasm) {
   const hash = u8aToHex(wasm.keccak256(stringToU8a('test value')));
 
@@ -22,6 +35,14 @@ function keccak256 (wasm) {
   assert(hash === '0x2d07364b5c231c56ce63d49430e085ea3033c750688ba532b24029124c26ca5e', 'ERROR: keccak256 does not match');
 }
 
+function keccak512 (wasm) {
+  const hash = u8aToHex(wasm.keccak512(stringToU8a('test')));
+
+  console.log('\tRES', hash);
+
+  assert(hash === '0x1e2e9fc2002b002d75198b7503210c05a1baac4560916a3c6d93bcce3a50d7f00fd395bf1647b9abb8d1afcc9c76c289b0c9383ba386a956da4b38934417789e', 'ERROR: keccak512 does not match');
+}
+
 function pbkdf2Hash (wasm) {
   const hash = u8aToHex(wasm.pbkdf2(stringToU8a('hello world'), stringToU8a('this is a salt'), 2048));
 
@@ -30,17 +51,6 @@ function pbkdf2Hash (wasm) {
   assert(hash === '0x5fcbe04f05300a3ecc5c35d18ea0b78f3f6853d2ae5f3fca374f69a7d1f78b5def5c60dae1a568026c7492511e0c53521e8bb6e03a650e1263265fee92722270', 'ERROR: pbkdf2Hash does not match');
 }
 
-// function secp256k1Recover (wasm) {
-//   const pk = u8aToHex(wasm.keccak256(wasm.secp256k1Recover(
-//     hexToU8a('0x2bbfa926ee947dfac384d981f8913b4e0992e52d7b6711e0ec3d9f8b0f752648'),
-//     hexToU8a('0x7505f2880114da51b3f5d535f8687953c0ab9af4ab81e592eaebebf53b728d2b6dfd9b5bcd70fee412b1f31360e7c2774009305cb84fc50c1d0ff8034dfa5fff1c')
-//   )));
-
-//   console.log('\tPUB', pk);
-
-//   assert(pk === '0x91d366769d44a7c7690428bfdf67ec7eae23d2459694685257b6fc59d1baa1fe', 'ERROR: secp256k1Recover does not match');
-// }
-
 function scryptHash (wasm) {
   const hash = u8aToHex(wasm.scrypt(stringToU8a('password'), stringToU8a('salt'), 14, 8, 1));
 
@@ -49,6 +59,14 @@ function scryptHash (wasm) {
   assert(hash === '0x745731af4484f323968969eda289aeee005b5903ac561e64a5aca121797bf7734ef9fd58422e2e22183bcacba9ec87ba0c83b7a2e788f03ce0da06463433cda6', 'ERROR: scryptHash does not match');
 }
 
+function sha256Hash (wasm) {
+  const hash = u8aToHex(wasm.sha256(stringToU8a('hello world')));
+
+  console.log('\tRES', hash);
+
+  assert(hash === '0xb94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9', 'ERROR: sha256Hash does not match');
+}
+
 function sha512Hash (wasm) {
   const hash = u8aToHex(wasm.sha512(stringToU8a('hello world')));
 
@@ -69,10 +87,13 @@ function twoxHash (wasm) {
 
 module.exports = {
   blake2bHash,
+  hmacSha256,
+  hmacSha512,
   keccak256,
+  keccak512,
   pbkdf2Hash,
   scryptHash,
-  // secp256k1Recover,
+  sha256Hash,
   sha512Hash,
   twoxHash
 };

packages/wasm-crypto/test/all/index.cjs

@@ -0,0 +1,77 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const wasm = require('../../build/index.cjs');
+const bip39 = require('./bip39.cjs');
+const ed25519 = require('./ed25519.cjs');
+const hashing = require('./hashing.cjs');
+const secp256k1 = require('./secp256k1.cjs');
+const sr25519 = require('./sr25519.cjs');
+const vrf = require('./vrf.cjs');
+
+const tests = {
+  // We place secp256k1 first, this allows the interaction with it in the
+  // hashing (specifically scrypt) test not be an issue (ASM.js only)
+  // https://github.com/polkadot-js/wasm/issues/307
+  ...secp256k1,
+  ...ed25519,
+  ...sr25519,
+  ...vrf,
+  ...bip39,
+  ...hashing
+};
+
+function beforeAll () {
+  return wasm.waitReady();
+}
+
+function runAll (name) {
+  const failed = [];
+  let count = 0;
+
+  Object.keys(tests).forEach((name) => {
+    count++;
+
+    try {
+      console.time(name);
+      console.log();
+      console.log(name);
+
+      tests[name](wasm);
+
+      console.timeEnd(name);
+    } catch (error) {
+      console.error();
+      console.error(error);
+
+      failed.push(name);
+    }
+  });
+
+  if (failed.length) {
+    throw new Error(`\n*** ${name}: FAILED: ${failed.length} of ${count}: ${failed.join(', ')}`);
+  }
+}
+
+function runUnassisted (name) {
+  console.log(`\n*** ${name}: Running tests`);
+
+  beforeAll()
+    .then(() => runAll(name))
+    .then(() => {
+      console.log(`\n*** ${name}: All passed`);
+      process.exit(0);
+    })
+    .catch((error) => {
+      console.error(error.message, '\n');
+      process.exit(-1);
+    });
+}
+
+module.exports = {
+  beforeAll,
+  runAll,
+  runUnassisted,
+  tests,
+  wasm
+};

packages/wasm-crypto/test/all/index.js

@@ -1,66 +0,0 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-const wasm = require('../../build/index');
-const bip39 = require('./bip39');
-const ed25519 = require('./ed25519');
-const hashing = require('./hashing');
-const sr25519 = require('./sr25519');
-
-const tests = {
-  ...bip39,
-  ...ed25519,
-  ...hashing,
-  ...sr25519
-};
-
-function beforeAll () {
-  return wasm.waitReady();
-}
-
-function runAll () {
-  const failed = [];
-  let count = 0;
-
-  Object.keys(tests).forEach((name) => {
-    count++;
-
-    try {
-      console.time(name);
-      console.log();
-      console.log(name);
-
-      tests[name](wasm);
-
-      console.timeEnd(name);
-    } catch (error) {
-      console.error(error);
-      failed.push(name);
-    }
-  });
-
-  if (failed.length) {
-    throw new Error(`Failed: ${failed.length} of ${count}: ${failed.concat(', ')}`);
-  }
-}
-
-function runUnassisted () {
-  (async () => {
-    await beforeAll();
-
-    runAll();
-  })().catch((error) => {
-    console.error(error);
-
-    process.exit(-1);
-  });
-}
-
-module.exports = {
-  beforeAll,
-  runAll,
-  runUnassisted,
-  tests,
-  wasm
-};

packages/wasm-crypto/test/all/secp256k1.cjs

@@ -0,0 +1,82 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const { assert, hexToU8a, u8aToHex } = require('@polkadot/util');
+
+function secp256k1Compress (wasm) {
+  const pubkey = '0x04b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb1307763fe926c273235fd979a134076d00fd1683cbd35868cb485d4a3a640e52184af';
+  const result = u8aToHex(wasm.secp256k1Compress(hexToU8a(pubkey)));
+
+  console.log('\tRES', result);
+
+  assert(result === '0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077', 'ERROR: secp256k1Compress does not match');
+}
+
+function secp256k1Expand (wasm) {
+  const pubkey = '0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077';
+  const result = u8aToHex(wasm.secp256k1Expand(hexToU8a(pubkey)));
+
+  console.log('\tRES', result);
+
+  assert(result === '0x04b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb1307763fe926c273235fd979a134076d00fd1683cbd35868cb485d4a3a640e52184af', 'ERROR: secp256k1Expand does not match');
+}
+
+function secp256k1FromSeed1 (wasm) {
+  const seckey = '0x4380de832af797688026ce24f85204d508243f201650c1a134929e5458b7fbae';
+  const result = u8aToHex(wasm.secp256k1FromSeed(hexToU8a(seckey)));
+
+  console.log('\tRES', result);
+
+  assert(result === '0x4380de832af797688026ce24f85204d508243f201650c1a134929e5458b7fbae03fd8c74f795ced92064b86191cb2772b1e3a0947740aa0a5a6e379592471fd85b', 'ERROR: secp256k1FromSeed does not match');
+}
+
+function secp256k1FromSeed2 (wasm) {
+  // https://github.com/polkadot-js/wasm/issues/307
+  const seckey = new Uint8Array([
+    203, 109, 249, 222, 30, 252, 167, 163, 153, 138, 142,
+    173, 78, 2, 21, 157, 95, 169, 156, 62, 13, 79,
+    214, 67, 38, 103, 57, 11, 180, 114, 104, 84
+  ]);
+  const expected = u8aToHex(new Uint8Array([
+    203, 109, 249, 222, 30, 252, 167, 163, 153, 138, 142,
+    173, 78, 2, 21, 157, 95, 169, 156, 62, 13, 79,
+    214, 67, 38, 103, 57, 11, 180, 114, 104, 84, 2,
+    10, 16, 145, 52, 31, 229, 102, 75, 250, 23, 130,
+    213, 224, 71, 121, 104, 144, 104, 201, 22, 176, 76,
+    179, 101, 236, 49, 83, 117, 86, 132, 217, 161
+  ]));
+  const result = u8aToHex(wasm.secp256k1FromSeed(seckey));
+
+  console.log('\tRES', result);
+
+  assert(result === expected, 'ERROR: secp256k1FromSeed does not match');
+}
+
+function secp256k1Recover (wasm) {
+  const sig = '0x7505f2880114da51b3f5d535f8687953c0ab9af4ab81e592eaebebf53b728d2b6dfd9b5bcd70fee412b1f31360e7c2774009305cb84fc50c1d0ff8034dfa5fff';
+  const msg = '0xa30b64ce1eedf409c8afb801d72c05234e64849ea538c15dd3c8cf4ffcf166c9';
+  const result = u8aToHex(wasm.secp256k1Recover(hexToU8a(msg), hexToU8a(sig), 0));
+
+  console.log('\tRES', result);
+
+  assert(result === '0x028d13da15a02f3a70677339d51b14177ee9b49657662b35e56a9d9dee17db1d30', 'ERROR: secp256k1Recover does not match');
+}
+
+function secp256k1Sign (wasm) {
+  const sec = '0x4380de832af797688026ce24f85204d508243f201650c1a134929e5458b7fbae';
+  const msg = '0x68c731589a583d08b70861683b59ce3dd56284cb2f0da5b6cd83e6641dac3aab';
+  const result = u8aToHex(wasm.secp256k1Sign(hexToU8a(msg), hexToU8a(sec)));
+
+  console.log('\tRES', result);
+
+  assert(result === '0xdf92f73d9f060cefacf187b5414491cb992998ace017fa48839b5cda3e264ba83b105adec9e9872647a7d8bb28855b45e22805aea3d097953cbb1391f671d13e01', 'ERROR: secp256k1Sign does not match');
+}
+
+module.exports = {
+  secp256k1Compress,
+  secp256k1Expand,
+  secp256k1FromSeed1,
+  secp256k1FromSeed2,
+  secp256k1Recover,
+  secp256k1Sign
+};

packages/wasm-crypto/test/all/sr25519.cjs

@@ -1,8 +1,5 @@
-// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-/* eslint-disable camelcase */
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
 
 const crypto = require('crypto');
 const { assert, hexToU8a, stringToU8a, u8aToHex } = require('@polkadot/util');
@@ -15,7 +12,7 @@ function randomPair (wasm) {
   return extractKeys(wasm.sr25519KeypairFromSeed(crypto.randomBytes(32)));
 }
 
-function sr25519_pairFromSeed (wasm) {
+function sr25519PairFromSeed (wasm) {
   const pair = wasm.sr25519KeypairFromSeed(stringToU8a('12345678901234567890123456789012'));
 
   console.log('\tSEC', u8aToHex(pair.slice(0, 64)));
@@ -24,7 +21,7 @@ function sr25519_pairFromSeed (wasm) {
   assert(u8aToHex(pair) === '0xf0106660c3dda23f16daa9ac5b811b963077f5bc0af89f85804f0de8e424f050f98d66f39442506ff947fd911f18c7a7a5da639a63e8d3b4e233f74143d951c1741c08a06f41c596608f6774259bd9043304adfa5d3eea62760bd9be97634d63', 'ERROR: pairFromSeed() does not match');
 }
 
-function sr25519_devFromSeed (wasm) {
+function sr25519DevFromSeed (wasm) {
   const pair = wasm.sr25519KeypairFromSeed(hexToU8a('0xfac7959dbfe72f052e5a0c3c8d6530f202b02fd8f9f5ca3580ec8deb7797479e'));
 
   console.log('\tSEC', u8aToHex(pair.slice(0, 64)));
@@ -33,7 +30,7 @@ function sr25519_devFromSeed (wasm) {
   assert(u8aToHex(pair) === '0x28b0ae221c6bb06856b287f60d7ea0d98552ea5a16db16956849aa371db3eb51fd190cce74df356432b410bd64682309d6dedb27c76845daf388557cbac3ca3446ebddef8cd9bb167dc30878d7113b7e168e6f0646beffd77d69d39bad76b47a', 'ERROR: devFromSeed() does not match');
 }
 
-function sr25519_verifyExisting (wasm) {
+function sr25519VerifyExisting (wasm) {
   const PK = hexToU8a('0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d');
   const MESSAGE = stringToU8a('I hereby verify that I control 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY');
   const SIGNATURE = hexToU8a('0xb83881d3bd7302981ee1c504fe5b7b394682927131fc0846fd616bb40fa14d02640fd2aca785b4cb57904765c2e4e75f59a7dd30154c209964369912091f6981');
@@ -45,7 +42,18 @@ function sr25519_verifyExisting (wasm) {
   assert(isValid, 'ERROR: Unable to verify signature');
 }
 
-function sr25519_signAndVerify (wasm) {
+function sr25519SignDeterministic (wasm) {
+  const [, pk, sk] = randomPair(wasm);
+  const sig1 = u8aToHex(wasm.sr25519Sign(pk, sk, stringToU8a('this is a message')));
+  const sig2 = u8aToHex(wasm.sr25519Sign(pk, sk, stringToU8a('this is a message')));
+
+  console.log('\tSG1', sig1);
+  console.log('\tSG2', sig2);
+
+  assert(sig1 !== sig2, 'ERROR: Signatures are deterministic');
+}
+
+function sr25519SignAndVerify (wasm) {
   const [, pk, sk] = randomPair(wasm);
   const signature = wasm.sr25519Sign(pk, sk, stringToU8a('this is a message'));
   const isValid = wasm.sr25519Verify(signature, stringToU8a('this is a message'), pk);
@@ -56,7 +64,7 @@ function sr25519_signAndVerify (wasm) {
   assert(isValid, 'ERROR: Unable to verify signature');
 }
 
-function sr25519_deriveHard (wasm) {
+function sr25519DeriveHard (wasm) {
   const [pair] = randomPair(wasm);
   const derived = wasm.sr25519DeriveKeypairHard(pair, hexToU8a('0x0c666f6f00000000000000000000000000000000000000000000000000000000'));
 
@@ -64,7 +72,7 @@ function sr25519_deriveHard (wasm) {
   console.log('\tPUB', u8aToHex(derived.slice(64)));
 }
 
-function sr25519_deriveHardKnown (wasm) {
+function sr25519DeriveHardKnown (wasm) {
   const derived = wasm.sr25519DeriveKeypairHard(hexToU8a('0x28b0ae221c6bb06856b287f60d7ea0d98552ea5a16db16956849aa371db3eb51fd190cce74df356432b410bd64682309d6dedb27c76845daf388557cbac3ca3446ebddef8cd9bb167dc30878d7113b7e168e6f0646beffd77d69d39bad76b47a'), hexToU8a('0x14416c6963650000000000000000000000000000000000000000000000000000'));
   const publicKey = u8aToHex(derived.slice(64));
 
@@ -74,7 +82,7 @@ function sr25519_deriveHardKnown (wasm) {
   assert(publicKey === '0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d', 'Unmatched resulting public keys');
 }
 
-function sr25519_deriveSoft (wasm) {
+function sr25519DeriveSoft (wasm) {
   const [pair] = randomPair(wasm);
   const derived = wasm.sr25519DeriveKeypairSoft(pair, hexToU8a('0x0c666f6f00000000000000000000000000000000000000000000000000000000'));
 
@@ -82,7 +90,7 @@ function sr25519_deriveSoft (wasm) {
   console.log('\tPUB', u8aToHex(derived.slice(64)));
 }
 
-function sr25519_deriveSoftKnown (wasm) {
+function sr25519DeriveSoftKnown (wasm) {
   const derived = wasm.sr25519DeriveKeypairSoft(hexToU8a('0x28b0ae221c6bb06856b287f60d7ea0d98552ea5a16db16956849aa371db3eb51fd190cce74df356432b410bd64682309d6dedb27c76845daf388557cbac3ca3446ebddef8cd9bb167dc30878d7113b7e168e6f0646beffd77d69d39bad76b47a'), hexToU8a('0x0c666f6f00000000000000000000000000000000000000000000000000000000'));
   const publicKey = u8aToHex(derived.slice(64));
 
@@ -92,7 +100,7 @@ function sr25519_deriveSoftKnown (wasm) {
   assert(publicKey === '0x40b9675df90efa6069ff623b0fdfcf706cd47ca7452a5056c7ad58194d23440a', 'Unmatched resulting public keys');
 }
 
-function sr25519_deriveSoftPubkey (wasm) {
+function sr25519DeriveSoftPubkey (wasm) {
   const derived = u8aToHex(wasm.sr25519DerivePublicSoft(hexToU8a('0x46ebddef8cd9bb167dc30878d7113b7e168e6f0646beffd77d69d39bad76b47a'), hexToU8a('0x0c666f6f00000000000000000000000000000000000000000000000000000000')));
 
   console.log('\tPUB', derived);
@@ -100,7 +108,24 @@ function sr25519_deriveSoftPubkey (wasm) {
   assert(derived === '0x40b9675df90efa6069ff623b0fdfcf706cd47ca7452a5056c7ad58194d23440a', 'Unmatched resulting public keys');
 }
 
-function sr25519_benchmark (wasm) {
+function sr25519KeyAgreement (wasm) {
+  const pair1 = wasm.sr25519KeypairFromSeed(hexToU8a('0x3b44c558f9a8f3dc9690d53088558c1ba2529b677e316c6054d1852595b004af'));
+  const pair2 = wasm.sr25519KeypairFromSeed(hexToU8a('0x923b80f79c6981fe756272128ec236eb510ae016dd20bdccbd77a9416b7ab94e'));
+  const [, pk1, sk1] = extractKeys(pair1);
+  const [, pk2, sk2] = extractKeys(pair2);
+
+  assert(u8aToHex(wasm.sr25519Agree(pk1, sk2)) === '0xfa7b90001b790fe42ff78b8cd86f6cf7a7c0a70b72f6b4c771b5d67536450222', 'Unmatched agreement keys');
+  assert(u8aToHex(wasm.sr25519Agree(pk2, sk1)) === '0xfa7b90001b790fe42ff78b8cd86f6cf7a7c0a70b72f6b4c771b5d67536450222', 'Unmatched agreement keys');
+
+  for (let i = 0; i < 256; i++) {
+    const [, pk1, sk1] = randomPair(wasm);
+    const [, pk2, sk2] = randomPair(wasm);
+
+    assert(u8aToHex(wasm.sr25519Agree(pk1, sk2)) === u8aToHex(wasm.sr25519Agree(pk2, sk1)), 'Unmatched agreement keys');
+  }
+}
+
+function sr25519Benchmark (wasm) {
   const MESSAGE = stringToU8a('this is a message');
 
   for (let i = 0; i < 256; i++) {
@@ -111,14 +136,16 @@ function sr25519_benchmark (wasm) {
 }
 
 module.exports = {
-  sr25519_benchmark,
-  sr25519_deriveHard,
-  sr25519_deriveHardKnown,
-  sr25519_deriveSoft,
-  sr25519_deriveSoftKnown,
-  sr25519_deriveSoftPubkey,
-  sr25519_devFromSeed,
-  sr25519_pairFromSeed,
-  sr25519_signAndVerify,
-  sr25519_verifyExisting
+  sr25519Benchmark,
+  sr25519DeriveHard,
+  sr25519DeriveHardKnown,
+  sr25519DeriveSoft,
+  sr25519DeriveSoftKnown,
+  sr25519DeriveSoftPubkey,
+  sr25519DevFromSeed,
+  sr25519KeyAgreement,
+  sr25519PairFromSeed,
+  sr25519SignAndVerify,
+  sr25519SignDeterministic,
+  sr25519VerifyExisting
 };

packages/wasm-crypto/test/all/vrf.cjs

@@ -0,0 +1,54 @@
+// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const crypto = require('crypto');
+const { assert, stringToU8a, u8aToHex } = require('@polkadot/util');
+
+function extractKeys (pair) {
+  return [pair, pair.slice(64), pair.slice(0, 64)];
+}
+
+function randomPair (wasm) {
+  return extractKeys(wasm.sr25519KeypairFromSeed(crypto.randomBytes(32)));
+}
+
+function vrfSignAndVerifyCompat (wasm) {
+  const [, pk, sk] = randomPair(wasm);
+  const outAndProof = wasm.vrfSign(sk, stringToU8a('my VRF context'), stringToU8a('this is a message'), new Uint8Array());
+  const isValid = wasm.vrfVerify(pk, stringToU8a('my VRF context'), stringToU8a('this is a message'), new Uint8Array(), outAndProof);
+
+  console.log('\tVRF', u8aToHex(outAndProof));
+  console.log('\tRES', isValid);
+
+  assert(isValid, 'ERROR: Unable to verify VRF output & proof');
+}
+
+function vrfSignAndVerify (wasm) {
+  const [, pk, sk] = randomPair(wasm);
+  const outAndProof = wasm.vrfSign(sk, stringToU8a('my VRF context'), stringToU8a('this is a message'), stringToU8a('extra param'));
+  const isValid = wasm.vrfVerify(pk, stringToU8a('my VRF context'), stringToU8a('this is a message'), stringToU8a('extra param'), outAndProof);
+
+  console.log('\tVRF', u8aToHex(outAndProof));
+  console.log('\tRES', isValid);
+
+  assert(isValid, 'ERROR: Unable to verify VRF extra output & proof');
+}
+
+function vrfSignAndVerifyDeterministic (wasm) {
+  const [,, sk] = randomPair(wasm);
+  const outAndProof1 = wasm.vrfSign(sk, stringToU8a('my VRF context'), stringToU8a('this is a message'), stringToU8a('extra param'));
+  const outAndProof2 = wasm.vrfSign(sk, stringToU8a('my VRF context'), stringToU8a('this is a message'), stringToU8a('extra param'));
+  const sig1 = u8aToHex(outAndProof1.slice(0, 32));
+  const sig2 = u8aToHex(outAndProof2.slice(0, 32));
+
+  console.log('\tSG1', sig1);
+  console.log('\tSG2', sig2);
+
+  assert(sig1 === sig2, 'ERROR: VRF extra outputs are non-deterministic');
+}
+
+module.exports = {
+  vrfSignAndVerify,
+  vrfSignAndVerifyCompat,
+  vrfSignAndVerifyDeterministic
+};