[CI Skip] release/stable 2.0.1

skip-checks: true

.babelrc.js

@@ -1 +0,0 @@
-module.exports = require('./babel.config.js');

.eslintignore

@@ -1,4 +0,0 @@
-**/binaryen/*
-**/build/*
-**/coverage/*
-**/node_modules/*

.eslintrc.js

@@ -1,7 +1,20 @@
+// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
 const base = require('@polkadot/dev/config/eslint');
 
 module.exports = {
   ...base,
+  ignorePatterns: [
+    '.eslintrc.js',
+    '.github/**',
+    '.vscode/**',
+    '.yarn/**',
+    '**/binaryen/*',
+    '**/build/*',
+    '**/coverage/*',
+    '**/node_modules/*'
+  ],
   parserOptions: {
     ...base.parserOptions,
     project: [

.github/workflows/pr-any.yml

@@ -2,85 +2,16 @@ name: PR
 on: [pull_request]
 
 jobs:
-  lint:
-    name: Linting
-    runs-on: ubuntu-latest
+  pr:
     strategy:
       matrix:
-        node-version: [12.x]
-    steps:
-    - uses: actions/checkout@v1
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - name: Config yarn cache
-      id: yarn-cache-dir-path
-      run: echo "::set-output name=dir::$(yarn cache dir)"
-    - uses: actions/cache@v1
-      id: yarn-cache
-      with:
-        path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-        key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-        restore-keys: |
-          ${{ runner.os }}-yarn-
-    - name: lint
-      run: |
-        yarn install --immutable | grep -v 'YN0013'
-        yarn lint
-
-  test:
-    name: Testing
+        step: ['lint', 'test', 'build']
+    name: ${{ matrix.step }}
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [12.x]
     steps:
-    - uses: actions/checkout@v1
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - name: Config yarn cache
-      id: yarn-cache-dir-path
-      run: echo "::set-output name=dir::$(yarn cache dir)"
-    - uses: actions/cache@v1
-      id: yarn-cache
-      with:
-        path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-        key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-        restore-keys: |
-          ${{ runner.os }}-yarn-
-    - name: test
+    - uses: actions/checkout@v2
+    - name: ${{ matrix.step }}
       run: |
-        rustup toolchain install nightly
         yarn install --immutable | grep -v 'YN0013'
-        yarn test
-
-  build_code:
-    name: Build Code
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [12.x]
-    steps:
-    - uses: actions/checkout@v1
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - name: Config yarn cache
-      id: yarn-cache-dir-path
-      run: echo "::set-output name=dir::$(yarn cache dir)"
-    - uses: actions/cache@v1
-      id: yarn-cache
-      with:
-        path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-        key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-        restore-keys: |
-          ${{ runner.os }}-yarn-
-    - name: build
-      run: |
-        rustup toolchain install nightly
-        yarn install --immutable | grep -v 'YN0013'
-        yarn build
+        ./scripts/install-build-deps.sh
+        yarn ${{ matrix.step }}

.github/workflows/push-master.yml

@@ -5,49 +5,30 @@ on:
       - master
 
 jobs:
-  build_code:
-    name: Build Code
-    if: "! contains(github.event.head_commit.message, '[CI Skip]')"
-    runs-on: ubuntu-latest
+  master:
     strategy:
       matrix:
-        node-version: [12.x]
+        step: ['build:release']
+    name: ${{ matrix.step }}
+    if: "! startsWith(github.event.head_commit.message, '[CI Skip]') && github.repository == 'polkadot-js/wasm'"
+    runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v2
       with:
         token: ${{ secrets.GH_PAT }}
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - name: Config yarn cache
-      id: yarn-cache-dir-path
-      run: echo "::set-output name=dir::$(yarn cache dir)"
-    - uses: actions/cache@v1
-      id: yarn-cache
-      with:
-        path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-        key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-        restore-keys: |
-          ${{ runner.os }}-yarn-
     - name: build
       env:
         CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
         GH_PAT: ${{ secrets.GH_PAT }}
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        GH_RELEASE_GITHUB_API_TOKEN: ${{ secrets.GH_PAT }}
         NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
       run: |
-        rustup toolchain install nightly
         yarn install --immutable | grep -v 'YN0013'
-        yarn polkadot-ci-ghact-build
+        ./scripts/install-build-deps.sh
+        yarn ${{ matrix.step }}
 
   dummy:
-    name: Dummy
-    if: "contains(github.event.head_commit.message, '[CI Skip]')"
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [12.x]
     steps:
     - name: dummy
       run: |

.gitignore

@@ -1,4 +1,5 @@
-binaryen*
+binaryen/
+bindgen/
 build/
 build-docs/
 coverage/
@@ -7,16 +8,18 @@ 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*

.nvmrc

@@ -1 +1 @@
-10
+12

.yarnrc.yml

@@ -1,10 +1,15 @@
 enableImmutableInstalls: false
+
 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"
+  - path: .yarn/plugins/@yarnpkg/plugin-workspace-tools.cjs
+    spec: "@yarnpkg/plugin-workspace-tools"
 
-yarnPath: .yarn/releases/yarn-berry.js
+yarnPath: .yarn/releases/yarn-2.3.3.cjs

CHANGELOG.md

@@ -1,83 +1,166 @@
-# 1.2.1 Feb 29, 2020
+# CHANGELOG
+
+## 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
+
+## 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
+
+## 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
+
+## 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
+
+## 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
+
+## 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
+
+## 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
+
+## 0.11.1 May 31, 2019
+
+Changes:
 
 - Security dependency bumps
 
-# 0.10.1 May 09, 2019
+
+## 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
+
+## 0.9.1 Apr 29, 2019
+
+Changes:
 
 - Dependency bumps
 
-# 0.8.1 Mar 31, 2019
+
+## 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
+
+## 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
+
+## 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
+
+## 0.5.1 Mar 23, 2019
+
+Changes:
 
 - Add password argument to bip39ToSeed
 
-# 0.4.1 Mar 23, 2019
+
+## 0.4.1 Mar 23, 2019
+
+Changes:
 
 - Add bip39ToSeed
 
-# 0.3.1 Mar 23, 2019
+
+## 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
+
+## 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
+
+## 0.1.1 Mar 18, 2019
+
+Changes:
 
 - Initial release

babel.config.js

@@ -1 +1,4 @@
+// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
 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.js

@@ -1,12 +1,14 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
+// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
 const config = require('@polkadot/dev/config/jest');
 
 module.exports = Object.assign({}, config, {
   moduleNameMapper: {
-    '@polkadot/wasm-(schnorrkel)(.*)$': '<rootDir>/packages/wasm-$1/src/$2'
+    '@polkadot/wasm-(crypto)(.*)$': '<rootDir>/packages/wasm-$1/src/$2'
   },
   modulePathIgnorePatterns: [
-    '<rootDir>/packages/wasm-schnorrkel/build'
+    '<rootDir>/packages/wasm-crypto/build'
   ],
-  resolver: './jest.resolver.js'
+  resolver: '@polkadot/dev/config/jest-resolver'
 });

jest.resolver.js

@@ -1,12 +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 @typescript-eslint/no-var-requires */
-
-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.2.1"
-}

package.json

@@ -7,21 +7,24 @@
     "packages/*"
   ],
   "resolutions": {
-    "@polkadot/dev": "^0.50.14",
-    "babel-core": "^7.0.0-bridge.0",
-    "typescript": "^3.8.3"
+    "typescript": "^4.0.5"
   },
   "scripts": {
-    "build": "./scripts/build.sh",
+    "build": "yarn build:wasm",
+    "build:release": "polkadot-ci-ghact-build",
+    "build:wasm": "./scripts/build.sh",
     "lint": "polkadot-dev-run-lint",
     "clean": "./scripts/clean.sh",
     "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.js && node ./test/asm.js",
+    "test:wasm:rust": "cd packages/wasm-crypto && RUST_BACKTRACE=full cargo test --release -- --nocapture"
   },
   "devDependencies": {
-    "@babel/core": "^7.8.4",
-    "@polkadot/dev": "^0.50.14",
-    "@polkadot/util": "^2.5.1",
-    "override-require": "^1.1.1"
-  }
+    "@babel/core": "^7.12.3",
+    "@polkadot/dev": "^0.59.19"
+  },
+  "version": "2.0.1"
 }

packages/wasm-crypto/Cargo.toml

@@ -3,7 +3,7 @@
 
 [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"
@@ -12,28 +12,34 @@ repository = "https://github.com/polkadot-js/wasm/"
 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.3", features = ["nightly"] }
+ed25519-dalek = { version = "1.0.0-pre.4", features = [] }
 hmac = "0.7.0"
 # libsecp256k1 = "0.2.2"
 pbkdf2 = { version = "0.3.0", default-features = false }
-schnorrkel = { version = "0.8.5", features = ["nightly", "preaudit_deprecated", "u64_backend"] }
-sha2 = "0.8.0"
-tiny-bip39 = { version = "0.6.2", default-features = false }
+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"
+wasm-bindgen = "=0.2.65"
 wee_alloc = "0.4.3"
 
 [dev-dependencies]
 hex-literal = "0.2.0"
-rand = { version = "0.6.5", features = ["wasm-bindgen"] }
+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"
+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,28 +1,20 @@
 {
   "name": "@polkadot/wasm-crypto",
-  "version": "1.2.1",
+  "version": "2.0.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"
+    "./wasm/asm-empty.js": "./wasm/asm.js"
   },
   "main": "index.js",
   "types": "index.d.ts",
   "devDependencies": {
-    "@polkadot/dev": "^0.50.8"
+    "@polkadot/dev": "^0.59.19",
+    "@polkadot/util": "^4.0.0-7",
+    "@polkadot/x-randomvalues": "^4.0.0-7",
+    "override-require": "^1.1.1"
   },
   "peerDependencies": {
-    "@polkadot/util": "*"
+    "@polkadot/util": "*",
+    "@polkadot/x-randomvalues": "*"
   }
 }

packages/wasm-crypto/src/bridge.js

@@ -0,0 +1,103 @@
+// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const { assert, stringToU8a, u8aToString } = require('@polkadot/util');
+
+let wasm;
+let cachegetInt32 = null;
+let cachegetUint8 = null;
+
+async function initWasm (wasmBytes, asmFn, wbg) {
+  try {
+    assert(typeof WebAssembly !== 'undefined' && wasmBytes && wasmBytes.length, 'WebAssembly is not available in your environment');
+
+    const source = await WebAssembly.instantiate(wasmBytes, { wbg });
+
+    wasm = source.instance.exports;
+  } catch (error) {
+    // if we have a valid supplied asm.js, return that
+    if (asmFn) {
+      wasm = asmFn(wbg);
+    } else {
+      console.error('ERROR: Unable to initialize @polkadot/wasm-crypto');
+      console.error(error);
+
+      wasm = null;
+    }
+  }
+}
+
+function withWasm (fn) {
+  return (...params) => {
+    assert(wasm, '@polkadot/wasm-crypto has not been initialized. Ensure that you wait for the initialization Promise with waitReady() (or cryptoWaitReady() from @polkadot/util-crypto) before attempting to use WASM-only interfaces.');
+
+    return fn(wasm, ...params);
+  };
+}
+
+function getWasm () {
+  return wasm;
+}
+
+function getInt32 () {
+  if (cachegetInt32 === null || cachegetInt32.buffer !== wasm.memory.buffer) {
+    cachegetInt32 = new Int32Array(wasm.memory.buffer);
+  }
+
+  return cachegetInt32;
+}
+
+function getUint8 () {
+  if (cachegetUint8 === null || cachegetUint8.buffer !== wasm.memory.buffer) {
+    cachegetUint8 = new Uint8Array(wasm.memory.buffer);
+  }
+
+  return cachegetUint8;
+}
+
+function getU8a (ptr, len) {
+  return getUint8().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function getString (ptr, len) {
+  return u8aToString(getU8a(ptr, len));
+}
+
+function allocU8a (arg) {
+  const ptr = wasm.__wbindgen_malloc(arg.length * 1);
+
+  getUint8().set(arg, ptr / 1);
+
+  return [ptr, arg.length];
+}
+
+function allocString (arg) {
+  return allocU8a(stringToU8a(arg));
+}
+
+function resultU8a () {
+  const r0 = getInt32()[8 / 4 + 0];
+  const r1 = getInt32()[8 / 4 + 1];
+  const ret = getU8a(r0, r1).slice();
+
+  wasm.__wbindgen_free(r0, r1 * 1);
+
+  return ret;
+}
+
+function resultString () {
+  return u8aToString(resultU8a());
+}
+
+module.exports = {
+  allocString,
+  allocU8a,
+  getInt32,
+  getString,
+  getU8a,
+  getWasm,
+  initWasm,
+  resultString,
+  resultU8a,
+  withWasm
+};

packages/wasm-crypto/src/imports.js

@@ -0,0 +1,81 @@
+// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const getRandomValues = require('@polkadot/x-randomvalues').default;
+
+const { getString, getU8a } = require('./bridge');
+
+const DEFAULT_SELF = { crypto: { getRandomValues } };
+
+const heap = new Array(32).fill(undefined).concat(undefined, null, true, false);
+let heapNext = heap.length;
+
+function getObject (idx) {
+  return heap[idx];
+}
+
+function dropObject (idx) {
+  if (idx < 36) {
+    return;
+  }
+
+  heap[idx] = heapNext;
+  heapNext = idx;
+}
+
+function takeObject (idx) {
+  const ret = getObject(idx);
+
+  dropObject(idx);
+
+  return ret;
+}
+
+function addObject (obj) {
+  if (heapNext === heap.length) {
+    heap.push(heap.length + 1);
+  }
+
+  const idx = heapNext;
+
+  heapNext = heap[idx];
+  heap[idx] = obj;
+
+  return idx;
+}
+
+module.exports.__wbindgen_is_undefined = function (arg0) {
+  return getObject(arg0) === undefined;
+};
+
+module.exports.__wbg_self_1b7a39e3a92c949c = function () {
+  return addObject(DEFAULT_SELF);
+};
+
+module.exports.__wbg_require_604837428532a733 = function (arg0, arg1) {
+  throw new Error(`Unable to import ${getString(arg0, arg1)}`);
+};
+
+module.exports.__wbg_crypto_968f1772287e2df0 = function (arg0) {
+  return addObject(getObject(arg0).crypto);
+};
+
+module.exports.__wbg_getRandomValues_a3d34b4fee3c2869 = function (arg0) {
+  return addObject(getObject(arg0).getRandomValues);
+};
+
+module.exports.__wbg_getRandomValues_f5e14ab7ac8e995d = function (arg0, arg1, arg2) {
+  getObject(arg0).getRandomValues(getU8a(arg1, arg2));
+};
+
+module.exports.__wbg_randomFillSync_d5bd2d655fdf256a = function (arg0, arg1, arg2) {
+  getObject(arg0).randomFillSync(getU8a(arg1, arg2));
+};
+
+module.exports.__wbindgen_object_drop_ref = function (arg0) {
+  takeObject(arg0);
+};
+
+module.exports.abort = function () {
+  throw new Error('abort');
+};

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

@@ -1,6 +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.
+// SPDX-License-Identifier: Apache-2.0
 
 export function bip39Generate (words: 12 | 15 | 18 | 21 | 24): string;
 export function bip39ToEntropy (phrase: string): Uint8Array;
@@ -22,6 +21,7 @@ export function sr25519Verify (signature: Uint8Array, message: Uint8Array, publi
 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;

packages/wasm-crypto/src/index.js

@@ -0,0 +1,188 @@
+// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const asmFallback = require('./wasm/asm-empty');
+const wasmBytes = require('./wasm/bytes');
+const { allocString, allocU8a, getWasm, initWasm, resultString, resultU8a, withWasm } = require('./bridge');
+const imports = require('./imports');
+
+const wasmPromise = initWasm(wasmBytes, asmFallback, imports).catch(() => null);
+
+module.exports.bip39Generate = withWasm((wasm, words) => {
+  wasm.ext_bip39_generate(8, words);
+
+  return resultString();
+});
+
+module.exports.bip39ToEntropy = withWasm((wasm, phrase) => {
+  const [ptr0, len0] = allocString(phrase);
+
+  wasm.ext_bip39_to_entropy(8, ptr0, len0);
+
+  return resultU8a();
+});
+
+module.exports.bip39ToMiniSecret = withWasm((wasm, phrase, password) => {
+  const [ptr0, len0] = allocString(phrase);
+  const [ptr1, len1] = allocString(password);
+
+  wasm.ext_bip39_to_mini_secret(8, ptr0, len0, ptr1, len1);
+
+  return resultU8a();
+});
+
+module.exports.bip39ToSeed = withWasm((wasm, phrase, password) => {
+  const [ptr0, len0] = allocString(phrase);
+  const [ptr1, len1] = allocString(password);
+
+  wasm.ext_bip39_to_seed(8, ptr0, len0, ptr1, len1);
+
+  return resultU8a();
+});
+
+module.exports.bip39Validate = withWasm((wasm, phrase) => {
+  const [ptr0, len0] = allocString(phrase);
+  const ret = wasm.ext_bip39_validate(ptr0, len0);
+
+  return ret !== 0;
+});
+
+module.exports.ed25519KeypairFromSeed = withWasm((wasm, seed) => {
+  const [ptr0, len0] = allocU8a(seed);
+
+  wasm.ext_ed_from_seed(8, ptr0, len0);
+
+  return resultU8a();
+});
+
+module.exports.ed25519Sign = withWasm((wasm, pubkey, seckey, message) => {
+  const [ptr0, len0] = allocU8a(pubkey);
+  const [ptr1, len1] = allocU8a(seckey);
+  const [ptr2, len2] = allocU8a(message);
+
+  wasm.ext_ed_sign(8, ptr0, len0, ptr1, len1, ptr2, len2);
+
+  return resultU8a();
+});
+
+module.exports.ed25519Verify = withWasm((wasm, signature, message, pubkey) => {
+  const [ptr0, len0] = allocU8a(signature);
+  const [ptr1, len1] = allocU8a(message);
+  const [ptr2, len2] = allocU8a(pubkey);
+  const ret = wasm.ext_ed_verify(ptr0, len0, ptr1, len1, ptr2, len2);
+
+  return ret !== 0;
+});
+
+module.exports.blake2b = withWasm((wasm, data, key, size) => {
+  const [ptr0, len0] = allocU8a(data);
+  const [ptr1, len1] = allocU8a(key);
+
+  wasm.ext_blake2b(8, ptr0, len0, ptr1, len1, size);
+
+  return resultU8a();
+});
+
+module.exports.keccak256 = withWasm((wasm, data) => {
+  const [ptr0, len0] = allocU8a(data);
+
+  wasm.ext_keccak256(8, ptr0, len0);
+
+  return resultU8a();
+});
+
+module.exports.pbkdf2 = withWasm((wasm, data, salt, rounds) => {
+  const [ptr0, len0] = allocU8a(data);
+  const [ptr1, len1] = allocU8a(salt);
+
+  wasm.ext_pbkdf2(8, ptr0, len0, ptr1, len1, rounds);
+
+  return resultU8a();
+});
+
+module.exports.scrypt = withWasm((wasm, password, salt, log2n, r, p) => {
+  const [ptr0, len0] = allocU8a(password);
+  const [ptr1, len1] = allocU8a(salt);
+
+  wasm.ext_scrypt(8, ptr0, len0, ptr1, len1, log2n, r, p);
+
+  return resultU8a();
+});
+
+module.exports.sha512 = withWasm((wasm, data) => {
+  const [ptr0, len0] = allocU8a(data);
+
+  wasm.ext_sha512(8, ptr0, len0);
+
+  return resultU8a();
+});
+
+module.exports.twox = withWasm((wasm, data, rounds) => {
+  const [ptr0, len0] = allocU8a(data);
+
+  wasm.ext_twox(8, ptr0, len0, rounds);
+
+  return resultU8a();
+});
+
+module.exports.sr25519DeriveKeypairHard = withWasm((wasm, pair, cc) => {
+  const [ptr0, len0] = allocU8a(pair);
+  const [ptr1, len1] = allocU8a(cc);
+
+  wasm.ext_sr_derive_keypair_hard(8, ptr0, len0, ptr1, len1);
+
+  return resultU8a();
+});
+
+module.exports.sr25519DeriveKeypairSoft = withWasm((wasm, pair, cc) => {
+  const [ptr0, len0] = allocU8a(pair);
+  const [ptr1, len1] = allocU8a(cc);
+
+  wasm.ext_sr_derive_keypair_soft(8, ptr0, len0, ptr1, len1);
+
+  return resultU8a();
+});
+
+module.exports.sr25519DerivePublicSoft = withWasm((wasm, pubkey, cc) => {
+  const [ptr0, len0] = allocU8a(pubkey);
+  const [ptr1, len1] = allocU8a(cc);
+
+  wasm.ext_sr_derive_public_soft(8, ptr0, len0, ptr1, len1);
+
+  return resultU8a();
+});
+
+module.exports.sr25519KeypairFromSeed = withWasm((wasm, seed) => {
+  const [ptr0, len0] = allocU8a(seed);
+
+  wasm.ext_sr_from_seed(8, ptr0, len0);
+
+  return resultU8a();
+});
+
+module.exports.sr25519Sign = withWasm((wasm, pubkey, secret, message) => {
+  const [ptr0, len0] = allocU8a(pubkey);
+  const [ptr1, len1] = allocU8a(secret);
+  const [ptr2, len2] = allocU8a(message);
+
+  wasm.ext_sr_sign(8, ptr0, len0, ptr1, len1, ptr2, len2);
+
+  return resultU8a();
+});
+
+module.exports.sr25519Verify = withWasm((wasm, signature, message, pubkey) => {
+  const [ptr0, len0] = allocU8a(signature);
+  const [ptr1, len1] = allocU8a(message);
+  const [ptr2, len2] = allocU8a(pubkey);
+  const ret = wasm.ext_sr_verify(ptr0, len0, ptr1, len1, ptr2, len2);
+
+  return ret !== 0;
+});
+
+module.exports.isReady = function () {
+  return !!getWasm();
+};
+
+module.exports.waitReady = function () {
+  return wasmPromise.then(() => !!getWasm());
+};

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

@@ -1,22 +0,0 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-// 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,49 +0,0 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-// 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 { 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),
-
-    // 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.js

@@ -1,8 +0,0 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-// 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,27 +0,0 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-// 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, { './wasm': 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,18 @@
 // 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.
+// 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/sr25519.rs"]
 pub mod sr25519;

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

@@ -1,6 +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.
+// SPDX-License-Identifier: Apache-2.0
 
 use bip39::{Mnemonic, MnemonicType, Language, Seed};
 use hmac::Hmac;
@@ -48,7 +47,7 @@ pub fn ext_bip39_to_mini_secret(phrase: &str, password: &str) -> Vec<u8> {
 	result[..32].to_vec()
 }
 
-/// Creates a see from a bip-39 phrase
+/// Creates a BTC/ETH compatible seed from a bip-39 phrase
 ///
 /// @phrase: mnemonic phrase
 ///

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

@@ -1,8 +1,8 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0
 
-use ed25519_dalek::{Keypair, PublicKey, SecretKey, Signature};
+use std::convert::TryFrom;
+use ed25519_dalek::{Keypair, PublicKey, SecretKey, Signature, Signer as _, Verifier as _};
 use wasm_bindgen::prelude::*;
 
 /// Keypair helper function.
@@ -14,27 +14,27 @@ fn create_from_pair(pair: &[u8]) -> Keypair {
 }
 
 /// Keypair helper function
-fn create_from_parts(public: &[u8], secret: &[u8]) -> Keypair {
+fn create_from_parts(pubkey: &[u8], seckey: &[u8]) -> Keypair {
 	let mut pair = vec![];
 
-	pair.extend_from_slice(secret);
-	pair.extend_from_slice(public);
+	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 secret = SecretKey::from_bytes(seed).unwrap();
-	let public: PublicKey = (&secret).into();
+	let seckey = SecretKey::from_bytes(seed).unwrap();
+	let pubkey: PublicKey = (&seckey).into();
 
-	create_from_parts(public.as_bytes(), seed)
+	create_from_parts(pubkey.as_bytes(), seed)
 }
 
 /// PublicKey helper
-fn create_public(public: &[u8]) -> PublicKey {
-	match PublicKey::from_bytes(public) {
-		Ok(public) => return public,
+fn create_public(pubkey: &[u8]) -> PublicKey {
+	match PublicKey::from_bytes(pubkey) {
+		Ok(pubkey) => return pubkey,
 		Err(_) => panic!("Provided public key is invalid.")
 	}
 }
@@ -57,14 +57,14 @@ pub fn ext_ed_from_seed(seed: &[u8]) -> Vec<u8> {
 /// The combination of both public and private key must be provided.
 /// This is effectively equivalent to a keypair.
 ///
-/// * public: UIntArray with 32 element
+/// * pubkey: UIntArray with 32 element
 /// * private: UIntArray with 64 element
 /// * message: Arbitrary length UIntArray
 ///
 /// * returned vector is the signature consisting of 64 bytes.
 #[wasm_bindgen]
-pub fn ext_ed_sign(public: &[u8], secret: &[u8], message: &[u8]) -> Vec<u8> {
-	create_from_parts(public, secret)
+pub fn ext_ed_sign(pubkey: &[u8], seckey: &[u8], message: &[u8]) -> Vec<u8> {
+	create_from_parts(pubkey, seckey)
 		.sign(message)
 		.to_bytes()
 		.to_vec()
@@ -76,13 +76,13 @@ pub fn ext_ed_sign(public: &[u8], secret: &[u8], message: &[u8]) -> Vec<u8> {
 /// * message: Arbitrary length UIntArray
 /// * pubkey: UIntArray with 32 element
 #[wasm_bindgen]
-pub fn ext_ed_verify(signature: &[u8], message: &[u8], public: &[u8]) -> bool {
-	let signature = match Signature::from_bytes(signature) {
+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(public)
+	create_public(pubkey)
 		.verify(message, &signature)
 		.is_ok()
 }

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

@@ -1,11 +1,11 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0
 
 use blake2_rfc::blake2b::blake2b;
 use byteorder::{ByteOrder, LittleEndian};
 use hmac::Hmac;
 use pbkdf2::pbkdf2;
+use scrypt::{ScryptParams, scrypt};
 use sha2::{Digest, Sha512};
 // use secp256k1;
 use tiny_keccak::{Hasher, Keccak};
@@ -58,13 +58,13 @@ pub fn ext_keccak256(data: &[u8]) -> Vec<u8> {
 	result.to_vec()
 }
 
-/// pbkdf2 hash from an input, salt for the number of specified rounds
+/// pbkdf2 kdf from an input, salt for the number of specified rounds
 ///
 /// * data: Arbitrary data to be hashed
 /// * salt: Salt for this hash
 /// * rounds: The number of rounds to perform
 ///
-/// Returns a vecor with the hash result
+/// 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];
@@ -75,6 +75,26 @@ pub fn ext_pbkdf2(data: &[u8], salt: &[u8], rounds: u32) -> Vec<u8> {
 	result.to_vec()
 }
 
+/// scrypt kdf from input, salt and config
+///
+/// * password: Password to hash
+/// * salt: Salt for this hash
+/// * log2_n: log2(n)
+/// * r: r
+/// * p: p
+///
+/// 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 scrypt(password, salt, &params, &mut result) {
+		Ok(_) => return result.to_vec(),
+		Err(_) => panic!("Invalid scrypt hash.")
+	}
+}
+
 // /// Checks for the recoverability of a signature from message
 // ///
 // /// * message: The message
@@ -131,7 +151,7 @@ pub fn ext_pbkdf2(data: &[u8], salt: &[u8], rounds: u32) -> Vec<u8> {
 ///
 /// * 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();
@@ -148,7 +168,7 @@ 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![];
@@ -166,7 +186,7 @@ pub mod tests {
 	use hex_literal::hex;
 	use super::*;
 
-	// // Constructs the message that Ethereum RPC's `personal_sign` and `eth_sign` would sign.
+	// // Constructs the message that Ethereum RPCs `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();
@@ -215,6 +235,16 @@ pub mod tests {
 		assert_eq!(hash[..], expected[..]);
 	}
 
+	#[test]
+	fn can_scrypt() {
+		let password = b"password";
+		let salt = b"salt";
+		let expected = hex!("745731af4484f323968969eda289aeee005b5903ac561e64a5aca121797bf7734ef9fd58422e2e22183bcacba9ec87ba0c83b7a2e788f03ce0da06463433cda6");
+		let hash = ext_scrypt(password, salt, 14, 8, 1);
+
+		assert_eq!(hash[..], expected[..]);
+	}
+
 	// #[test]
 	// fn can_secp256k1_real_eth_sig() {
 	// 	let sig = hex!("7505f2880114da51b3f5d535f8687953c0ab9af4ab81e592eaebebf53b728d2b6dfd9b5bcd70fee412b1f31360e7c2774009305cb84fc50c1d0ff8034dfa5fff1c");

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

@@ -1,8 +1,8 @@
-// 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.
+// 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
@@ -64,8 +64,8 @@ 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(public: &[u8], cc: &[u8]) -> Vec<u8> {
-	PublicKey::from_bytes(public)
+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()
@@ -105,16 +105,16 @@ pub fn ext_sr_from_pair(pair: &[u8]) -> Vec<u8> {
 /// The combination of both public and private key must be provided.
 /// This is effectively equivalent to a keypair.
 ///
-/// * public: UIntArray with 32 element
+/// * pubkey: UIntArray with 32 element
 /// * private: UIntArray with 64 element
 /// * message: Arbitrary length UIntArray
 ///
 /// * returned vector is the signature consisting of 64 bytes.
 #[wasm_bindgen]
-pub fn ext_sr_sign(public: &[u8], secret: &[u8], message: &[u8]) -> Vec<u8> {
+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(public).unwrap())
+		.sign_simple(SIGNING_CTX, message, &PublicKey::from_bytes(pubkey).unwrap())
 		.to_bytes()
 		.to_vec()
 }
@@ -125,9 +125,9 @@ pub fn ext_sr_sign(public: &[u8], secret: &[u8], message: &[u8]) -> Vec<u8> {
 /// * message: Arbitrary length UIntArray
 /// * pubkey: UIntArray with 32 element
 #[wasm_bindgen]
-pub fn ext_sr_verify(signature: &[u8], message: &[u8], public: &[u8]) -> bool {
+pub fn ext_sr_verify(signature: &[u8], message: &[u8], pubkey: &[u8]) -> bool {
 	match Signature::from_bytes(signature) {
-		Ok(signature) => PublicKey::from_bytes(public).unwrap()
+		Ok(signature) => PublicKey::from_bytes(pubkey).unwrap()
 			.verify_simple(SIGNING_CTX, message, &signature)
 			.is_ok(),
 		Err(_) => false

packages/wasm-crypto/src/wasm/asm-empty.js

@@ -0,0 +1,4 @@
+// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+module.exports = null;

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

@@ -0,0 +1,6 @@
+// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Stub replaced at build time
+
+module.exports = require('./asm-empty');

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

@@ -0,0 +1,4 @@
+// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+module.exports = null;

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

@@ -0,0 +1,6 @@
+// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Stub replaced at build time
+
+module.exports = require('./bytes-empty');

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

@@ -0,0 +1,35 @@
+// Copyright 2019-2020 @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_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;
+
+  ext_bip39_generate(a: number, b: number): void;
+  ext_bip39_to_entropy(a: number, b: number, c: number): void;
+  ext_bip39_to_mini_secret(a: number, b: number, c: number, d: number, e: number): void;
+  ext_bip39_to_seed(a: number, b: number, c: number, d: number, e: number): void;
+  ext_bip39_validate(a: number, b: number): number;
+  ext_ed_from_seed(a: number, b: number, c: number): void;
+  ext_ed_sign(a: number, b: number, c: number, d: number, e: number, f: number, g: number): void;
+  ext_ed_verify(a: number, b: number, c: number, d: number, e: number, f: number): number;
+  ext_blake2b(a: number, b: number, c: number, d: number, e: number, f: number): void;
+  ext_keccak256(a: number, b: number, c: number): void;
+  ext_pbkdf2(a: number, b: number, c: number, d: number, e: number, f: number): void;
+  ext_scrypt(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): void;
+  ext_sha512(a: number, b: number, c: number): void;
+  ext_twox(a: number, b: number, c: number, d: number): void;
+  ext_sr_derive_keypair_hard(a: number, b: number, c: number, d: number, e: number): void;
+  ext_sr_derive_keypair_soft(a: number, b: number, c: number, d: number, e: number): void;
+  ext_sr_derive_public_soft(a: number, b: number, c: number, d: number, e: number): void;
+  ext_sr_from_seed(a: number, b: number, c: number): void;
+  ext_sr_sign(a: number, b: number, c: number, d: number, e: number, f: number, g: number): void;
+  ext_sr_verify(a: number, b: number, c: number, d: number, e: number, f: number): number;
+}

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

@@ -1,56 +1,66 @@
-/* eslint-disable @typescript-eslint/camelcase */
-/* eslint-disable @typescript-eslint/no-var-requires */
 // 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.
+// SPDX-License-Identifier: Apache-2.0
 // @ts-check
 
+/* eslint-disable camelcase */
+
 const { assert, u8aToHex } = require('@polkadot/util');
 
 function bip39_generate (wasm) {
-  const RESULT = wasm.bip39Generate(21);
+  const res = wasm.bip39Generate(21);
 
-  console.log('\tPHR', RESULT);
+  console.log('\tPHR', res);
 
-  assert(RESULT.split(' ').length === 21, 'ERROR: Invalid bip39 Phase length');
+  assert(res.split(' ').length === 21, 'ERROR: Invalid bip39 Phase length');
+}
+
+function bip39_generate_subsequent (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 bip39_validate (wasm) {
-  const RESULT = wasm.bip39Validate(wasm.bip39Generate(12));
+  const res = wasm.bip39Validate(wasm.bip39Generate(12));
 
-  console.log('\tVAL', RESULT);
+  console.log('\tVAL', res);
 
-  assert(RESULT, 'ERROR: Invalid bip39 validation');
+  assert(res, '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'));
+  const res = u8aToHex(wasm.bip39ToEntropy('legal winner thank year wave sausage worth useful legal winner thank yellow'));
 
-  console.log('\tENT', RESULT);
+  console.log('\tENT', res);
 
-  assert(RESULT === '0x7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f', 'ERROR: Invalid bip39 entropy');
+  assert(res === '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'));
+  const res = u8aToHex(wasm.bip39ToMiniSecret('legal winner thank year wave sausage worth useful legal winner thank yellow', 'Substrate'));
 
-  console.log('\tMIN', RESULT);
+  console.log('\tMIN', res);
 
-  assert(RESULT === '0x4313249608fe8ac10fd5886c92c4579007272cb77c21551ee5b8d60b78041685', 'ERROR: Invalid bip39 mini secret');
+  assert(res === '0x4313249608fe8ac10fd5886c92c4579007272cb77c21551ee5b8d60b78041685', 'ERROR: Invalid bip39 mini secret');
 }
 
 function bip39_toSeed (wasm) {
-  const RESULT = u8aToHex(wasm.bip39ToSeed('seed sock milk update focus rotate barely fade car face mechanic mercy', ''));
+  const res = u8aToHex(wasm.bip39ToSeed('seed sock milk update focus rotate barely fade car face mechanic mercy', ''));
 
-  console.log('\tSEE', RESULT);
+  console.log('\tSEE', res);
 
-  assert(RESULT === '0x3c121e20de068083b49c2315697fb59a2d9e8643c24e5ea7628132c58969a027', 'ERROR: Invalid bip39 mini secret');
+  assert(res === '0x3c121e20de068083b49c2315697fb59a2d9e8643c24e5ea7628132c58969a027', 'ERROR: Invalid bip39 mini secret');
 }
 
 module.exports = {
   bip39_generate,
-  bip39_validate,
+  bip39_generate_subsequent,
   bip39_toEntropy,
   bip39_toMiniSecret,
-  bip39_toSeed
+  bip39_toSeed,
+  bip39_validate
 };

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

@@ -1,9 +1,7 @@
-/* eslint-disable @typescript-eslint/camelcase */
-/* eslint-disable @typescript-eslint/no-var-requires */
 // 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
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable camelcase */
 
 const crypto = require('crypto');
 const { assert, hexToU8a, stringToU8a, u8aToHex } = require('@polkadot/util');
@@ -55,8 +53,8 @@ function ed25519_benchmark (wasm) {
 }
 
 module.exports = {
+  ed25519_benchmark,
   ed25519_pairFromSeed,
   ed25519_signAndVerify,
-  ed25519_verifyExisting,
-  ed25519_benchmark
+  ed25519_verifyExisting
 };

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

@@ -1,9 +1,7 @@
-/* eslint-disable @typescript-eslint/camelcase */
-/* eslint-disable @typescript-eslint/no-var-requires */
 // 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
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable camelcase */
 
 const { assert, stringToU8a, u8aToHex } = require('@polkadot/util');
 
@@ -42,6 +40,14 @@ function pbkdf2Hash (wasm) {
 //   assert(pk === '0x91d366769d44a7c7690428bfdf67ec7eae23d2459694685257b6fc59d1baa1fe', 'ERROR: secp256k1Recover does not match');
 // }
 
+function scryptHash (wasm) {
+  const hash = u8aToHex(wasm.scrypt(stringToU8a('password'), stringToU8a('salt'), 14, 8, 1));
+
+  console.log('\tRES', hash);
+
+  assert(hash === '0x745731af4484f323968969eda289aeee005b5903ac561e64a5aca121797bf7734ef9fd58422e2e22183bcacba9ec87ba0c83b7a2e788f03ce0da06463433cda6', 'ERROR: scryptHash does not match');
+}
+
 function sha512Hash (wasm) {
   const hash = u8aToHex(wasm.sha512(stringToU8a('hello world')));
 
@@ -64,6 +70,7 @@ module.exports = {
   blake2bHash,
   keccak256,
   pbkdf2Hash,
+  scryptHash,
   // secp256k1Recover,
   sha512Hash,
   twoxHash

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

@@ -1,7 +1,5 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
 // 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.
+// SPDX-License-Identifier: Apache-2.0
 
 const wasm = require('../../build/index');
 const bip39 = require('./bip39');

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

@@ -1,9 +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.
-/* eslint-disable @typescript-eslint/camelcase */
-/* eslint-disable @typescript-eslint/no-var-requires */
-// @ts-check
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable camelcase */
 
 const crypto = require('crypto');
 const { assert, hexToU8a, stringToU8a, u8aToHex } = require('@polkadot/util');
@@ -46,6 +44,17 @@ function sr25519_verifyExisting (wasm) {
   assert(isValid, 'ERROR: Unable to verify signature');
 }
 
+function sr25519_sign_deterministic (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 sr25519_signAndVerify (wasm) {
   const [, pk, sk] = randomPair(wasm);
   const signature = wasm.sr25519Sign(pk, sk, stringToU8a('this is a message'));
@@ -112,14 +121,15 @@ function sr25519_benchmark (wasm) {
 }
 
 module.exports = {
-  sr25519_pairFromSeed,
-  sr25519_devFromSeed,
+  sr25519_benchmark,
   sr25519_deriveHard,
   sr25519_deriveHardKnown,
   sr25519_deriveSoft,
   sr25519_deriveSoftKnown,
   sr25519_deriveSoftPubkey,
+  sr25519_devFromSeed,
+  sr25519_pairFromSeed,
   sr25519_signAndVerify,
-  sr25519_verifyExisting,
-  sr25519_benchmark
+  sr25519_sign_deterministic,
+  sr25519_verifyExisting
 };

packages/wasm-crypto/test/asm.js

@@ -1,13 +1,11 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
 // 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.
+// SPDX-License-Identifier: Apache-2.0
 
 global.WebAssembly = null;
 
 require('override-require')(
-  (request) => request === './wasm_asm_stub',
-  () => require('../build/wasm_asm')
+  (request) => request.endsWith('wasm/asm-empty'),
+  () => require('../build/wasm/asm')
 );
 
 const { runUnassisted } = require('./all');

packages/wasm-crypto/test/jest.spec.js

@@ -1,13 +1,13 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
 // 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.
+// SPDX-License-Identifier: Apache-2.0
 
-require('../build/crypto-polyfill');
+/**
+ * @jest-environment jsdom
+ */
 
 const { beforeAll, tests, wasm } = require('./all');
 
-describe('schnorrkel-js', () => {
+describe('wasm-crypto', () => {
   beforeEach(async () => {
     await beforeAll();
   });

packages/wasm-crypto/test/wasm.js

@@ -1,8 +1,5 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
 // 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
+// SPDX-License-Identifier: Apache-2.0
 
 const { runUnassisted } = require('./all');
 

scripts/build-package.sh

@@ -5,78 +5,49 @@
 
 set -e
 
-BGJ=build/wasm_bg.js
-SRC_WASM=build/wasm.js
-DEF=build/wasm.d.ts
-WSM=build/wasm_bg.wasm
-OPT=build/wasm_opt.wasm
-ASM=build/wasm_asm.js
+# also change in install-build-deps
+RUST_VER=nightly-2020-10-25
+
+WSM=pkg/wasm_bg.wasm
+OPT=pkg/wasm_opt.wasm
+ASM=build/wasm/asm.js
 
 echo "*** Building package"
 
 # cleanup old
 echo "*** Cleaning old builds"
 rm -rf ./build ./pkg
+mkdir -p build/wasm
 
-# build new via nightly & wasm-pack
+# copy our package interfaces
+echo "*** Copying package sources"
+cp package.json build/
+cp src/index.d.ts src/*.js build/
+cp src/wasm/* build/wasm/
+
+# build new via wasm-pack
 echo "*** Building WASM output"
-rustup run nightly wasm-pack build --release --scope polkadot --target nodejs
-mv pkg build
+rustup run $RUST_VER xargo build --target wasm32-unknown-unknown --release
+# rustup run $RUST_VER cargo build --target wasm32-unknown-unknown --release -Z build-std=std,panic_abort
+../../bindgen/wasm-bindgen target/wasm32-unknown-unknown/release/wasm.wasm --out-dir pkg --target web
+# wasm-pack build --release --scope polkadot --target web
 
 # optimise
 echo "*** Optimising WASM output"
+# ../../wabt/bin/wasm-strip $WSM
 ../../binaryen/bin/wasm-opt $WSM -Os -o $OPT
 
 # convert wasm to base64 structure
-echo "*** Packing WASM into base64"
-node ../../scripts/pack-wasm-base64.js
+echo "*** Packing WASM into baseX"
+node ../../scripts/pack-wasm-base.js
 
 # build asmjs version from the input (optimised) WASM
 echo "*** Building asm.js version"
 ../../binaryen/bin/wasm2js --output $ASM $OPT
 
-# cleanup the generated output, sadly there are no node-js outputs above
-sed -i -e 's/import {/\/\/ import {/g' $ASM
-sed -i -e 's/function asmFunc/var schnorrkel = require('\''\.\/wasm'\''); function asmFunc/g' $ASM
-sed -i -e 's/{abort.*},memasmFunc/schnorrkel, memasmFunc/g' $ASM
-sed -i -e 's/export var /module\.exports\./g' $ASM
-
-# copy our package interfaces
-echo "*** Copying package sources"
-cp src/js/* build/
-
-# we are swapping to a async interface for webpack support (wasm limits)
-sed -i -e 's/wasm = require/\/\/ wasm = require/g' $SRC_WASM
-
-# We don't want inline requires
-sed -i -e 's/var wasm;/const crypto = require('\''crypto'\''); let wasm; const requires = { crypto };/g' $SRC_WASM
-sed -i -e 's/return addHeapObject(require(varg0));/return addHeapObject(requires[varg0]);/g' $SRC_WASM
-
-# this creates issues in both the browser and RN (@polkadot/util has a polyfill)
-sed -i -e 's/const TextEncoder = require('\''util'\'')\.TextEncoder;/const { stringToU8a } = require('\''@polkadot\/util'\'');/g' $SRC_WASM
-sed -i -e 's/let cachedTextEncoder = new /\/\/ let cachedTextEncoder = new /g' $SRC_WASM
-sed -i -e 's/cachedTextEncoder\.encode/stringToU8a/g' $SRC_WASM
-
-# this creates issues in both the browser and RN (@polkadot/util has a polyfill)
-sed -i -e 's/const TextDecoder = require('\''util'\'')\.TextDecoder;/const { u8aToString } = require('\''@polkadot\/util'\'');/g' $SRC_WASM
-sed -i -e 's/let cachedTextDecoder = new /\/\/ let cachedTextDecoder = new /g' $SRC_WASM
-sed -i -e 's/cachedTextDecoder\.decode/u8aToString/g' $SRC_WASM
-
-# construct our promise and add ready helpers (WASM)
-echo "
-module.exports.abort = function () { throw new Error('abort'); };
-
-const createPromise = require('./wasm_promise');
-const wasmPromise = createPromise().catch(() => null);
-
-module.exports.isReady = function () { return !!wasm; }
-module.exports.waitReady = function () { return wasmPromise.then(() => !!wasm); }
-
-wasmPromise.then((_wasm) => { wasm = _wasm });
-" >> $SRC_WASM
-
-# add extra methods to type definitions
-echo "
-export function isReady(): boolean;
-export function waitReady(): Promise<boolean>;
-" >> $DEF
+# cleanup the generated asm, converting to cjs
+sed -i -e '/import {/d' $ASM
+sed -i -e '/export var /d' $ASM
+sed -i -e 's/{abort.*},memasmFunc/wbg, memasmFunc/g' $ASM
+sed -i -e 's/var retasmFunc = /module.exports = (wbg) => /' $ASM
+rm -rf build/wasm/*-e

scripts/build.sh

@@ -5,26 +5,13 @@
 
 set -e
 
-./scripts/install-build-deps.sh
-
 echo "*** Building packages"
-cd packages
+cd packages/wasm-crypto
 
-PACKAGES=( $(ls -1d *) )
+../../scripts/build-package.sh
 
-for PKG in "${PACKAGES[@]}"; do
-  if [ -f "$PKG/package.json" ]; then
-    echo "*** Building $PKG"
-    cd $PKG
+yarn test:wasm:js
 
-    ../../scripts/build-package.sh
-    ../../scripts/test-package.sh
+ls -alR build
 
-    rm -rf build/*-e build/package.json build/README.md
-    ls -al build
-
-    cd ..
-  fi
-done
-
-cd ..
+cd ../..

scripts/clean.sh

@@ -5,23 +5,10 @@
 
 set -e
 
-./scripts/install-build-deps.sh
-
 echo "*** Cleaning packages"
-cd packages
+cd packages/wasm-crypto
 
-PACKAGES=( $(ls -1d *) )
+rm -rf build
+cargo clean
 
-for PKG in "${PACKAGES[@]}"; do
-  if [ -f "$PKG/package.json" ]; then
-    echo "*** Cleaning $PKG"
-    cd $PKG
-
-    rm -rf build
-    cargo clean
-
-    cd ..
-  fi
-done
-
-cd ..
+cd ../..

scripts/install-build-deps.sh

@@ -5,43 +5,63 @@
 
 set -e
 
-# wasm2js for wasm -> asm.js
-BINARYEN=( "wasm-opt" "wasm2js" )
+# also change in build-package
+RUST_VER=nightly-2020-10-25
+
+BINARYEN_REPO=https://github.com/WebAssembly/binaryen
+BINARYEN_VER=version_97
+BINARYEN_ZIP=
+
+BINDGEN_REPO=https://github.com/rustwasm/wasm-bindgen
+BINDGEN_VER=0.2.65
+BINDGEN_ZIP=
+
+WABT_REPO=https://github.com/WebAssembly/wabt
+WABT_VER=1.0.19
+WABT_ZIP=
 
 unamestr=`uname`
 
-# install wasm-pack as required
-if ! [ -x "$(command -v wasm-pack)" ]; then
-  echo "*** Installing wasm-pack"
-  curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
-fi
+# toolchain with rust-src (for panic overrdides) and the right wasm32 toolchain
+rustup toolchain install $RUST_VER -c rust-src -t wasm32-unknown-unknown
+cargo install xargo
+
+# if ! [ -x "$(command -v wasm-pack)" ]; then
+#   echo "*** Installing wasm-pack"
+#   curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+# fi
 
-# CI, Linux
 if [[ "$unamestr" == 'Linux' ]]; then
-  if [ ! -d "binaryen" ]; then
-    echo "*** Downloading binaryen"
-    curl -L https://github.com/WebAssembly/binaryen/releases/download/version_91/binaryen-version_91-x86-linux.tar.gz | tar xz
-    mkdir -p binaryen/bin
-
-    for BIN in "${BINARYEN[@]}"; do
-      mv binaryen-version_91/$BIN binaryen/bin
-    done
-  fi
+  echo "*** Detected Linux"
+  BINARYEN_ZIP=binaryen-$BINARYEN_VER-x86_64-linux
+  BINDGEN_ZIP=wasm-bindgen-$BINDGEN_VER-x86_64-unknown-linux-musl
+  WABT_ZIP=wabt-$WABT_VER-ubuntu
+elif [[ "$unamestr" == "Darwin" ]]; then
+  echo "*** Detected Mac"
+  BINARYEN_ZIP=binaryen-$BINARYEN_VER-x86_64-macos
+  BINDGEN_ZIP=wasm-bindgen-$BINDGEN_VER-x86_64-apple-darwin
+  WABT_ZIP=wabt-$WABT_VER-macos
 else
-  # install binaryen as required
-  if [ ! -d "binaryen" ]; then
-    echo "*** Cloning binaryen"
-    git clone --recursive https://github.com/WebAssembly/binaryen.git
-    rm -rf binaryen/test
-  fi
-
-  for BIN in "${BINARYEN[@]}"; do
-    if [ ! -f "binaryen/bin/$BIN" ]; then
-      echo "*** Building $BIN"
-      cd binaryen
-      cmake . && make $BIN
-      cd ..
-    fi
-  done
+  echo "*** Unknown platform $unamestr, unable to install wasm helper binaries"
+  exit 1
 fi
 
+if [ ! -d "binaryen" ]; then
+  echo "*** Downloading binaryen"
+  curl -L $BINARYEN_REPO/releases/download/$BINARYEN_VER/$BINARYEN_ZIP.tar.gz | tar xz
+  mv binaryen-$BINARYEN_VER binaryen
+  ls -alR binaryen
+fi
+
+if [ ! -d "bindgen" ]; then
+  echo "*** Downloading bindgen"
+  curl -L $BINDGEN_REPO/releases/download/$BINDGEN_VER/$BINDGEN_ZIP.tar.gz | tar xz
+  mv $BINDGEN_ZIP bindgen
+  ls -alR bindgen
+fi
+
+# if [ ! -d "wabt" ]; then
+#   echo "*** Downloading wabt"
+#   curl -L $WABT_REPO/releases/download/$WABT_VER/$WABT_ZIP.tar.gz | tar xz
+#   mv wabt-$WABT_VER wabt
+# fi

scripts/pack-wasm-base.js

@@ -0,0 +1,11 @@
+// Copyright 2019-2020 @polkadot/wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const fs = require('fs');
+
+const buffer = fs.readFileSync('./pkg/wasm_opt.wasm');
+
+fs.writeFileSync('./build/wasm/bytes.js', `// Generated as part of the build, do not edit
+
+module.exports = Buffer.from('${buffer.toString('base64')}', 'base64');
+`);

scripts/pack-wasm-base64.js

@@ -1,11 +0,0 @@
-// Copyright 2019-2020 @polkadot/wasm 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 @typescript-eslint/no-var-requires */
-const fs = require('fs');
-const buffer = fs.readFileSync('./build/wasm_opt.wasm');
-
-fs.writeFileSync('./build/wasm_wasm.js', `
-module.exports = Buffer.from('${buffer.toString('base64')}', 'base64');
-`);

scripts/test-package.sh

@@ -1,17 +0,0 @@
-#!/usr/bin/env bash
-# Copyright 2019-2020 @polkadot/wasm authors & contributors
-# This software may be modified and distributed under the terms
-# of the Apache-2.0 license. See the LICENSE file for details.
-
-set -e
-
-echo "*** Testing WASM"
-node ./test/wasm.js
-
-echo "*** Testing ASM.js"
-node ./test/asm.js
-
-echo "*** Testing via Jest"
-yarn polkadot-dev-run-test ./test/jest.spec.js
-# FIXME, this should be via yarn
-# ../../node_modules/@polkadot/dev/scripts/polkadot-dev-run-test.js ./test/jest.spec.js

scripts/test-rust.sh

@@ -1,23 +0,0 @@
-#!/usr/bin/env bash
-# Copyright 2019-2020 @polkadot/wasm authors & contributors
-# This software may be modified and distributed under the terms
-# of the Apache-2.0 license. See the LICENSE file for details.
-
-set -e
-
-cd packages
-
-PACKAGES=( $(ls -1d *) )
-
-for PKG in "${PACKAGES[@]}"; do
-  if [ -f "$PKG/package.json" ]; then
-    cd $PKG
-    echo "*** Testing Rust $PKG"
-
-    RUST_BACKTRACE=full rustup run nightly cargo test --release -- --nocapture
-
-    cd ..
-  fi
-done
-
-cd ..

tsconfig.json

@@ -1,5 +1,5 @@
 {
-  "extends": "./node_modules/@polkadot/dev/config/tsconfig",
+  "extends": "@polkadot/dev/config/tsconfig",
   "exclude": [
     "build/**/*",
     "**/build/**/*"
@@ -7,7 +7,7 @@
   "compilerOptions": {
     "baseUrl": ".",
     "paths": {
-      "@polkadot/wasm-schnorrkel": [ "packages/wasm-schnorrkel/src" ]
+      "@polkadot/wasm-crypto": [ "packages/wasm-crypto/src" ]
     },
     "skipLibCheck": true,
     "typeRoots": [

typedoc.js

@@ -1,16 +0,0 @@
-module.exports = {
-  name: 'Polkadot JS WASM',
-  exclude: '**/*+(index|e2e|spec).ts',
-  excludeExternals: true,
-  excludeNotExported: true,
-  excludeProtected: true,
-  excludePrivate: true,
-  hideGenerator: true,
-  includeDeclarations: false,
-  out: 'docs',
-  module: 'commonjs',
-  moduleResolution: 'node',
-  mdEngine: 'gitbook',
-  stripInternal: 'true',
-  theme: 'markdown'
-};