[CI Skip] release/stable 3.1.1

skip-checks: true

.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

@@ -2,3 +2,4 @@ exclude_patterns:
 - "**/*.spec.js"
 - "**/*.spec.ts"
 - "docs/**/*.js"
+- "**/test/**/*.js"

.eslintignore

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

.eslintrc.js

@@ -1,11 +1,22 @@
 // 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 base = require('@polkadot/dev/config/eslint');
+const base = require('@polkadot/dev/config/eslint.cjs');
 
 module.exports = {
   ...base,
+  ignorePatterns: [
+    '.eslintrc.js',
+    '.github/**',
+    '.vscode/**',
+    '.yarn/**',
+    '**/binaryen/*',
+    '**/build/*',
+    '**/coverage/*',
+    '**/node_modules/*',
+    '**/pkg/*',
+    '**/target/*'
+  ],
   parserOptions: {
     ...base.parserOptions,
     project: [

.github/workflows/pr-any.yml

@@ -9,8 +9,9 @@ jobs:
     name: ${{ matrix.step }}
     runs-on: ubuntu-latest
     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

@@ -13,7 +13,7 @@ jobs:
     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: build
@@ -24,6 +24,7 @@ jobs:
         NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
       run: |
         yarn install --immutable | grep -v 'YN0013'
+        ./scripts/install-build-deps.sh
         yarn ${{ matrix.step }}
 
   dummy:

.gitignore

@@ -1,22 +1,26 @@
-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*

.nvmrc

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

.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-2.4.0.cjs

CHANGELOG.md

@@ -1,92 +1,187 @@
 # CHANGELOG
 
+## 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

babel.config.js

@@ -1,5 +1,4 @@
 // 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
 
-module.exports = require('@polkadot/dev/config/babel');
+module.exports = require('@polkadot/dev/config/babel-config-cjs.cjs');

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,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.
+// SPDX-License-Identifier: Apache-2.0
 
-const config = require('@polkadot/dev/config/jest');
+const config = require('@polkadot/dev/config/jest.cjs');
 
 module.exports = Object.assign({}, config, {
   moduleNameMapper: {
-    '@polkadot/wasm-(schnorrkel)(.*)$': '<rootDir>/packages/wasm-$1/src/$2'
+    '@polkadot/wasm-crypto-asmjs(.*)$': '<rootDir>/packages/wasm-crypto-asmjs/build/$1',
+    '@polkadot/wasm-crypto-wasm(.*)$': '<rootDir>/packages/wasm-crypto-wasm/build/$1',
+    // eslint-disable-next-line sort-keys
+    '@polkadot/wasm-crypto(.*)$': '<rootDir>/packages/wasm-crypto/src/$1'
   },
   modulePathIgnorePatterns: [
-    '<rootDir>/packages/wasm-schnorrkel/build'
+    '<rootDir>/packages/wasm-crypto-asmjs/build',
+    '<rootDir>/packages/wasm-crypto-wasm/build',
+    '<rootDir>/packages/wasm-crypto/build'
   ],
-  resolver: './jest.resolver.js'
+  resolver: '@polkadot/dev/config/jest-resolver.cjs'
 });

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

@@ -7,19 +7,25 @@
     "packages/*"
   ],
   "resolutions": {
-    "babel-core": "^7.0.0-bridge.0"
+    "typescript": "^4.1.3"
   },
   "scripts": {
-    "build": "NIGHTLY= ./scripts/build.sh",
-    "build:release": "NIGHTLY= ./scripts/build-release.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.11.1",
-    "@polkadot/dev": "^0.55.35"
+    "@babel/core": "^7.12.10",
+    "@polkadot/dev": "^0.61.13",
+    "fflate": "^0.4.3"
   },
-  "version": "1.3.1"
+  "version": "3.1.1"
 }

packages/wasm-crypto-asmjs/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@polkadot/wasm-crypto-asmjs",
+  "version": "3.1.1",
+  "description": "Asm.js content for wasm-crypto",
+  "browser": "empty.js",
+  "main": "empty.js",
+  "module": "empty.mjs",
+  "react-native": "data.js",
+  "sideEffects": false,
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "maintainers": [],
+  "contributors": [],
+  "license": "Apache-2.0",
+  "bugs": "https://github.com/polkadot-js/wasm/issues",
+  "homepage": "https://github.com/polkadot-js/wasm",
+  "dependencies": {
+    "@babel/runtime": "^7.12.5"
+  }
+}

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

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

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

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

packages/wasm-crypto-wasm/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@polkadot/wasm-crypto-wasm",
+  "version": "3.1.1",
+  "description": "Wasm content for wasm-crypto",
+  "browser": "data.js",
+  "main": "data.js",
+  "module": "data.mjs",
+  "react-native": "data.js",
+  "sideEffects": false,
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "maintainers": [],
+  "contributors": [],
+  "license": "Apache-2.0",
+  "bugs": "https://github.com/polkadot-js/wasm/issues",
+  "homepage": "https://github.com/polkadot-js/wasm",
+  "dependencies": {
+    "@babel/runtime": "^7.12.5"
+  }
+}

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

@@ -0,0 +1,8 @@
+// Copyright 2017-2020 @polkadot/wasm-crypto-wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export const buffer = Buffer.from([]);
+
+export const sizeCompressed = 0;
+
+export const sizeUncompressed = 0;

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

@@ -0,0 +1,7 @@
+// Copyright 2017-2020 @polkadot/wasm-crypto-wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { buffer, sizeUncompressed } from './buffer';
+import { unzlibSync } from './fflate';
+
+export const wasmBytes = unzlibSync(buffer, new Uint8Array(sizeUncompressed));

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

@@ -0,0 +1,4 @@
+// Copyright 2017-2020 @polkadot/wasm-crypto-wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export const wasmBytes = null;

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

@@ -0,0 +1,342 @@
+// Copyright 2017-2020 @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/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,17 +12,16 @@ 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.4", 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.9.1", features = ["nightly", "preaudit_deprecated", "u64_backend"] }
+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 }
@@ -36,8 +35,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,26 @@
 {
   "name": "@polkadot/wasm-crypto",
-  "version": "1.3.1",
+  "version": "3.1.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"
-  },
   "main": "index.js",
-  "types": "index.d.ts",
+  "module": "index.mjs",
+  "sideEffects": [
+    "./detectPackage.js",
+    "./detectPackage.mjs"
+  ],
+  "dependencies": {
+    "@babel/runtime": "^7.12.5",
+    "@polkadot/wasm-crypto-asmjs": "^3.1.1",
+    "@polkadot/wasm-crypto-wasm": "^3.1.1"
+  },
   "devDependencies": {
-    "@polkadot/dev": "^0.55.35",
-    "@polkadot/util": "^3.0.1",
+    "@polkadot/dev": "^0.61.13",
+    "@polkadot/util": "^5.0.2-9",
+    "@polkadot/x-randomvalues": "^5.0.2-9",
     "override-require": "^1.1.1"
   },
   "peerDependencies": {
-    "@polkadot/util": "*"
+    "@polkadot/util": "*",
+    "@polkadot/x-randomvalues": "*"
   }
 }

packages/wasm-crypto/src/bridge.ts

@@ -0,0 +1,96 @@
+// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+import type { AsmCreator, WasmCryptoInstance } from './types';
+
+import { assert, stringToU8a, u8aToString } from '@polkadot/util';
+
+let wasm: WasmCryptoInstance | null = null;
+let cachegetInt32: Int32Array | null = null;
+let cachegetUint8: Uint8Array | null = null;
+
+export async function initWasm (wasmBytes: Uint8Array | null, asmFn: AsmCreator | null, wbg: Record<string, WebAssembly.ImportValue>): Promise<void> {
+  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 as unknown as WasmCryptoInstance;
+  } catch (error) {
+    // if we have a valid supplied asm.js, return that
+    if (asmFn) {
+      wasm = asmFn(wbg);
+    } else {
+      console.error('FATAL: Unable to initialize @polkadot/wasm-crypto');
+      console.error(error);
+
+      wasm = null;
+    }
+  }
+}
+
+// FIXME We really would love to clean this up and have a sign like (wasm, ...params) => T
+// Alas, TypeScript foo is not that great today, so we sadly have an extra closure here
+export function withWasm <T, F extends (...params: never[]) => T> (fn: (wasm: WasmCryptoInstance) => F): F {
+  return ((...params: never[]): T => {
+    assert(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(wasm)(...params);
+  }) as unknown as F;
+}
+
+export function getWasm (): WasmCryptoInstance {
+  return wasm!;
+}
+
+export function getInt32 (): Int32Array {
+  if (cachegetInt32 === null || cachegetInt32.buffer !== wasm!.memory.buffer) {
+    cachegetInt32 = new Int32Array(wasm!.memory.buffer);
+  }
+
+  return cachegetInt32;
+}
+
+export function getUint8 (): Uint8Array {
+  if (cachegetUint8 === null || cachegetUint8.buffer !== wasm!.memory.buffer) {
+    cachegetUint8 = new Uint8Array(wasm!.memory.buffer);
+  }
+
+  return 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 = 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();
+
+  wasm!.__wbindgen_free(r0, r1 * 1);
+
+  return ret;
+}
+
+export function resultString (): string {
+  return u8aToString(resultU8a());
+}

packages/wasm-crypto/src/detectPackage.ts

@@ -0,0 +1,25 @@
+// Copyright 2017-2020 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// For esm, this should be import.meta.url or to get the same behavior as __dirname, we can use
+//
+//   new URL(import.meta.url).pathname)
+//
+// The issue is the WP4 has "some" issues with import.meta.url. So because of bundlers, we can't have
+// nice things... In this case it is even worse since import.meta.url won't even make it compile, so
+// there is a complete dead end with usage thereof
+//
+// When that is fixed, a solution is to have both .js & .mjs files, with the following content -
+//
+// cjs: util.detectPackage(packageInfo, () => __dirname);
+// esm: detectPackage(packageInfo, () => import.meta.url);
+//
+// With the above we additionally need a .d.ts to just export the packageInfo
+
+import { detectPackage } from '@polkadot/util';
+
+import packageInfo from './package-info.json';
+
+detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname);
+
+export { packageInfo };

packages/wasm-crypto/src/imports.ts

@@ -0,0 +1,90 @@
+// Copyright 2019-2020 @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 __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,231 @@
+// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import './detectPackage';
+
+import { asmJsInit } from '@polkadot/wasm-crypto-asmjs';
+import { wasmBytes } from '@polkadot/wasm-crypto-wasm';
+
+import { allocString, allocU8a, getWasm, initWasm, resultString, resultU8a, withWasm } from './bridge';
+import * as imports from './imports';
+
+const wasmPromise = initWasm(wasmBytes, asmJsInit, imports).catch(() => null);
+
+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 => {
+    const [ptr0, len0] = allocString(phrase);
+
+    wasm.ext_bip39_to_entropy(8, ptr0, len0);
+
+    return resultU8a();
+  }
+);
+
+export const bip39ToMiniSecret = withWasm((wasm) =>
+  (phrase: string, password: string): Uint8Array => {
+    const [ptr0, len0] = allocString(phrase);
+    const [ptr1, len1] = allocString(password);
+
+    wasm.ext_bip39_to_mini_secret(8, ptr0, len0, ptr1, len1);
+
+    return resultU8a();
+  }
+);
+
+export const bip39ToSeed = withWasm((wasm) =>
+  (phrase: string, password: string): Uint8Array => {
+    const [ptr0, len0] = allocString(phrase);
+    const [ptr1, len1] = allocString(password);
+
+    wasm.ext_bip39_to_seed(8, ptr0, len0, ptr1, len1);
+
+    return resultU8a();
+  }
+);
+
+export const bip39Validate = withWasm((wasm) =>
+  (phrase: string): boolean => {
+    const [ptr0, len0] = allocString(phrase);
+    const ret = wasm.ext_bip39_validate(ptr0, len0);
+
+    return ret !== 0;
+  }
+);
+
+export const ed25519KeypairFromSeed = withWasm((wasm) =>
+  (seed: Uint8Array): Uint8Array => {
+    const [ptr0, len0] = allocU8a(seed);
+
+    wasm.ext_ed_from_seed(8, ptr0, len0);
+
+    return resultU8a();
+  }
+);
+
+export const ed25519Sign = withWasm((wasm) =>
+  (pubkey: Uint8Array, seckey: Uint8Array, message: Uint8Array): Uint8Array => {
+    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();
+  }
+);
+
+export const ed25519Verify = withWasm((wasm) =>
+  (signature: Uint8Array, message: Uint8Array, pubkey: Uint8Array): boolean => {
+    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;
+  }
+);
+
+export const sr25519DeriveKeypairHard = withWasm((wasm) =>
+  (pair: Uint8Array, cc: Uint8Array): Uint8Array => {
+    const [ptr0, len0] = allocU8a(pair);
+    const [ptr1, len1] = allocU8a(cc);
+
+    wasm.ext_sr_derive_keypair_hard(8, ptr0, len0, ptr1, len1);
+
+    return resultU8a();
+  }
+);
+
+export const sr25519DeriveKeypairSoft = withWasm((wasm) =>
+  (pair: Uint8Array, cc: Uint8Array): Uint8Array => {
+    const [ptr0, len0] = allocU8a(pair);
+    const [ptr1, len1] = allocU8a(cc);
+
+    wasm.ext_sr_derive_keypair_soft(8, ptr0, len0, ptr1, len1);
+
+    return resultU8a();
+  }
+);
+
+export const sr25519DerivePublicSoft = withWasm((wasm) =>
+  (pubkey: Uint8Array, cc: Uint8Array): Uint8Array => {
+    const [ptr0, len0] = allocU8a(pubkey);
+    const [ptr1, len1] = allocU8a(cc);
+
+    wasm.ext_sr_derive_public_soft(8, ptr0, len0, ptr1, len1);
+
+    return resultU8a();
+  }
+);
+
+export const sr25519KeypairFromSeed = withWasm((wasm) =>
+  (seed: Uint8Array): Uint8Array => {
+    const [ptr0, len0] = allocU8a(seed);
+
+    wasm.ext_sr_from_seed(8, ptr0, len0);
+
+    return resultU8a();
+  }
+);
+
+export const sr25519Sign = withWasm((wasm) =>
+  (pubkey: Uint8Array, secret: Uint8Array, message: Uint8Array): Uint8Array => {
+    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();
+  }
+);
+
+export const sr25519Verify = withWasm((wasm) =>
+  (signature: Uint8Array, message: Uint8Array, pubkey: Uint8Array): boolean => {
+    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;
+  }
+);
+
+export const blake2b = withWasm((wasm) =>
+  (data: Uint8Array, key: Uint8Array, size: number): Uint8Array => {
+    const [ptr0, len0] = allocU8a(data);
+    const [ptr1, len1] = allocU8a(key);
+
+    wasm.ext_blake2b(8, ptr0, len0, ptr1, len1, size);
+
+    return resultU8a();
+  }
+);
+
+export const keccak256 = withWasm((wasm) =>
+  (data: Uint8Array): Uint8Array => {
+    const [ptr0, len0] = allocU8a(data);
+
+    wasm.ext_keccak256(8, ptr0, len0);
+
+    return resultU8a();
+  }
+);
+
+export const pbkdf2 = withWasm((wasm) =>
+  (data: Uint8Array, salt: Uint8Array, rounds: number): Uint8Array => {
+    const [ptr0, len0] = allocU8a(data);
+    const [ptr1, len1] = allocU8a(salt);
+
+    wasm.ext_pbkdf2(8, ptr0, len0, ptr1, len1, rounds);
+
+    return resultU8a();
+  }
+);
+
+export const scrypt = withWasm((wasm) =>
+  (password: Uint8Array, salt: Uint8Array, log2n: number, r: number, p: number): Uint8Array => {
+    const [ptr0, len0] = allocU8a(password);
+    const [ptr1, len1] = allocU8a(salt);
+
+    wasm.ext_scrypt(8, ptr0, len0, ptr1, len1, log2n, r, p);
+
+    return resultU8a();
+  }
+);
+
+export const sha512 = withWasm((wasm) =>
+  (data: Uint8Array): Uint8Array => {
+    const [ptr0, len0] = allocU8a(data);
+
+    wasm.ext_sha512(8, ptr0, len0);
+
+    return resultU8a();
+  }
+);
+
+export const twox = withWasm((wasm) =>
+  (data: Uint8Array, rounds: number) => {
+    const [ptr0, len0] = allocU8a(data);
+
+    wasm.ext_twox(8, ptr0, len0, rounds);
+
+    return resultU8a();
+  }
+);
+
+export function isReady (): boolean {
+  return !!getWasm();
+}
+
+export function waitReady (): Promise<boolean> {
+  return wasmPromise.then(() => isReady());
+}

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/json.d.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2020 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Be able to import json in TS
+// https://stackoverflow.com/questions/49996456/importing-json-file-in-typescript
+declare module '*.json' {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const value: any;
+
+  export default value;
+}

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,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.
+// 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;
@@ -48,6 +47,20 @@ pub fn ext_bip39_to_mini_secret(phrase: &str, password: &str) -> Vec<u8> {
 	result[..32].to_vec()
 }
 
+/// 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> {
+	let mnemonic = Mnemonic::from_phrase(phrase, Language::English).unwrap();
+
+	Seed::new(&mnemonic, password)
+		.as_bytes()[..32]
+		.to_vec()
+}
+
 /// Validates a bip39 phrase
 ///
 /// * phrase: mnemonic phrase
@@ -85,6 +98,15 @@ pub mod tests {
 		assert_eq!(result[..], 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 result = ext_bip39_to_seed(phrase, "");
+
+		assert_eq!(result[..], seed[..]);
+	}
+
 	#[test]
 	fn can_bip39_generate() {
 		let phrase = ext_bip39_generate(12);

packages/wasm-crypto/src/rs/ed25519.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 std::convert::TryFrom;
 use ed25519_dalek::{Keypair, PublicKey, SecretKey, Signature, Signer as _, Verifier as _};

packages/wasm-crypto/src/rs/hashing.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 blake2_rfc::blake2b::blake2b;
 use byteorder::{ByteOrder, LittleEndian};
@@ -152,7 +151,7 @@ pub fn ext_scrypt(password: &[u8], salt: &[u8], log2_n: u8, r: u32, p: u32) -> V
 ///
 /// * 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,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![];
@@ -187,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();

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

packages/wasm-crypto/src/types.ts

@@ -0,0 +1,37 @@
+// 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;
+}
+
+export type AsmCreator = (wbg: Record<string, WebAssembly.ImportValue>) => WasmCryptoInstance;

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

@@ -0,0 +1,12 @@
+// Copyright 2019-2020 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+require('override-require')(
+  (request) =>
+    request.endsWith('@polkadot/wasm-crypto-asmjs') ||
+    request.endsWith('@polkadot/wasm-crypto-wasm'),
+  (request) =>
+    request.endsWith('@polkadot/wasm-crypto-asmjs')
+      ? require('../../wasm-crypto-asmjs/build/data')
+      : require('../../wasm-crypto-wasm/build/empty')
+);

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

@@ -1,47 +1,65 @@
 // 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, 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 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 = {
   bip39_generate,
+  bip39_generate_subsequent,
   bip39_toEntropy,
   bip39_toMiniSecret,
+  bip39_toSeed,
   bip39_validate
 };

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

@@ -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
 
 /* eslint-disable camelcase */
 

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

@@ -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
 
 /* eslint-disable camelcase */
 

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

@@ -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
 
 const wasm = require('../../build/index');
 const bip39 = require('./bip39');

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

@@ -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
 
 /* eslint-disable camelcase */
 
@@ -45,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'));
@@ -120,5 +130,6 @@ module.exports = {
   sr25519_devFromSeed,
   sr25519_pairFromSeed,
   sr25519_signAndVerify,
+  sr25519_sign_deterministic,
   sr25519_verifyExisting
 };

packages/wasm-crypto/test/asm.js

@@ -1,13 +1,9 @@
 // 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')
-);
+require('./alias-imports');
 
 const { runUnassisted } = require('./all');
 

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

@@ -1,12 +1,15 @@
 // 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
+ */
+
+// override-require in jest.config.js
 
 const { beforeAll, tests, wasm } = require('./all');
 
-describe('schnorrkel-js', () => {
+describe('wasm-crypto', () => {
   beforeEach(async () => {
     await beforeAll();
   });

packages/wasm-crypto/test/wasm.js

@@ -1,6 +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.
+// SPDX-License-Identifier: Apache-2.0
+
+require('./alias-imports');
 
 const { runUnassisted } = require('./all');
 

scripts/build-js.sh

@@ -5,11 +5,7 @@
 
 set -e
 
-echo "*** Testing WASM"
-node ./test/wasm.js
+DEST=packages/wasm-crypto/build/esm
 
-echo "*** Testing ASM.js"
-node ./test/asm.js
-
-echo "*** Testing via Jest"
-yarn polkadot-dev-run-test ./test/jest.spec.js
+./scripts/clean-js.sh
+yarn polkadot-dev-build-ts

scripts/build-package.sh

@@ -1,101 +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
-
-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
-
-echo "*** Building package"
-
-# cleanup old
-echo "*** Cleaning old builds"
-rm -rf ./build ./pkg
-
-# build new via nightly & wasm-pack
-echo "*** Building WASM output"
-rustup run nightly$NIGHTLY wasm-pack build --release --scope polkadot --target nodejs
-mv pkg build
-
-# optimise
-echo "*** Optimising WASM output"
-../../binaryen/bin/wasm-opt $WSM -Os -o $OPT
-
-# convert wasm to base64 structure
-echo "*** Packing WASM into base64"
-node ../../scripts/pack-wasm-base64.js
-
-# build asmjs version from the input (optimised) WASM
-echo "*** Building asm.js version"
-../../binaryen/bin/wasm2js --output $ASM $OPT
-
-# cleanup the generated asm, converting to cjs
-sed -i -e '/import {/d' $ASM
-echo "const imported = require('./wasm');
-$(cat $ASM)" > $ASM
-sed -i -e 's/{abort.*},memasmFunc/imported, 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/
-
-echo "const crypto = require('crypto');
-const { stringToU8a, u8aToString } = require('@polkadot/util');
-
-const requires = { crypto };
-
-$(cat $SRC_WASM)
-" > $SRC_WASM
-
-# whack comments
-sed -i -e '/^\/\*\*/d' $SRC_WASM
-sed -i -e '/^\*/d' $SRC_WASM
-sed -i -e '/^\*\//d' $SRC_WASM
-
-# we are swapping to a async interface for webpack support (wasm limits)
-sed -i -e '/^wasm = require/d' $SRC_WASM
-
-# We don't want inline requires
-sed -i -e 's/ret = require(getStringFromWasm0(arg0, arg1));/ret = requires[getStringFromWasm0(arg0, arg1)];/g' $SRC_WASM
-
-# this creates issues in both the browser and RN (@polkadot/util has a polyfill)
-sed -i -e '/^const { TextEncoder } = require/d' $SRC_WASM
-sed -i -e '/^let cachedTextEncoder = new /d' $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 '/^const { TextDecoder } = require/d' $SRC_WASM
-sed -i -e '/^let cachedTextDecoder = new/d' $SRC_WASM
-sed -i -e 's/cachedTextDecoder\.decode/u8aToString/g' $SRC_WASM
-
-# this is where we get the actual bg file
-sed -i -e '/^const path = require/d' $SRC_WASM
-sed -i -e '/^const bytes = require/d' $SRC_WASM
-sed -i -e '/^const wasmModule =/d' $SRC_WASM
-sed -i -e '/^const wasmInstance =/d' $SRC_WASM
-sed -i -e '/^wasm = wasmInstance/d' $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

scripts/build-wasm.sh

@@ -0,0 +1,48 @@
+#!/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
+
+# also change in install-build-deps
+RUST_VER=nightly-2020-10-25
+
+WSM=bytes/wasm_bg.wasm
+OPT=bytes/wasm_opt.wasm
+ASM=wasm-crypto-asmjs/build/data.js
+
+# build new via wasm-pack
+echo "*** Building Rust sources"
+cd wasm-crypto
+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
+cd ..
+
+echo "*** Converting to WASM"
+../bindgen/wasm-bindgen wasm-crypto/target/wasm32-unknown-unknown/release/wasm.wasm --out-dir bytes --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 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 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 = /const asmJsInit = (wbg) => /' $ASM
+echo "module.exports = { asmJsInit };" >> $ASM
+
+# cleanups
+rm -rf wasm-crypto-asmjs/build/*-e
+rm -rf wasm-crypto-wasm/build/*-e

scripts/build.sh

@@ -5,27 +5,24 @@
 
 set -e
 
-rustup toolchain install nightly$NIGHTLY
-./scripts/install-build-deps.sh
+echo "*** Building JavaScript"
+./scripts/build-js.sh
 
-echo "*** Building packages"
+echo "*** Building WASM"
 cd packages
 
-PACKAGES=( $(ls -1d *) )
+../scripts/build-wasm.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
-
-    rm -rf build/*-e build/package.json build/README.md
-    ls -al build
-
-    cd ..
-  fi
-done
+echo ""
+echo "*** wasm-crypto"
+ls -alR wasm-crypto/build
+echo ""
+echo "*** wasm-crypto-asmjs"
+ls -alR wasm-crypto-asmjs/build
+echo ""
+echo "*** wasm-crypto-wasm"
+ls -alR wasm-crypto-wasm/build
 
 cd ..

scripts/clean-js.sh

@@ -5,5 +5,6 @@
 
 set -e
 
-rustup toolchain install nightly$NIGHTLY
-yarn polkadot-ci-ghact-build
+# cleanup old
+echo "*** Cleaning old builds"
+rm -rf packages/*/build packages/bytes

scripts/clean.sh

@@ -5,23 +5,11 @@
 
 set -e
 
-./scripts/install-build-deps.sh
+./scripts/clean-js.sh
 
-echo "*** Cleaning packages"
-cd packages
+echo "*** Cleaning wasm"
+cd packages/wasm-crypto
 
-PACKAGES=( $(ls -1d *) )
+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,48 @@
+// Copyright 2019-2020 @polkadot/wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const fs = require('fs');
+const { formatNumber } = require('@polkadot/util');
+
+const A_NAME = 'wasm-crypto-asmjs';
+const W_NAME = 'wasm-crypto-wasm';
+
+function hdr (package) {
+  return `// Copyright 2019-2020 @polkadot/${package} authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Generated as part of the build, do not edit
+`;
+}
+
+// only one of the deps are included, here are the details for package.json -
+//   "fflate": "^0.4.2"
+//   "lz4js": "^0.2.0"
+function getWasmBuffer (lib = 'fflate') {
+  const data = fs.readFileSync('./bytes/wasm_opt.wasm');
+  const compressed = lib === 'fflate'
+    ? Buffer.from(require('fflate').zlibSync(data, { level: 9 }))
+    : Buffer.from(require('lz4js').compress(data));
+
+  console.log(`*** Compressed WASM via ${lib}: ${formatNumber(data.length)} -> ${formatNumber(compressed.length)} (${(100 * compressed.length / data.length).toFixed(2)}%)`);
+
+  return { compressed, sizeUncompressed: data.length };
+}
+
+fs.writeFileSync(`./${A_NAME}/build/data.mjs`, `${hdr(A_NAME)}
+export { asmJsInit } from './data.js';
+`);
+
+fs.writeFileSync(`./${W_NAME}/build/buffer.mjs`, `${hdr(W_NAME)}
+export { buffer, sizeCompressed, sizeUncompressed } from './buffer.js';
+`);
+
+const { compressed, sizeUncompressed } = getWasmBuffer();
+
+fs.writeFileSync(`./${W_NAME}/build/buffer.js`, `${hdr(W_NAME)}
+const sizeCompressed = ${compressed.length};
+const sizeUncompressed = ${sizeUncompressed};
+const buffer = Buffer.from('${compressed.toString('base64')}', 'base64');
+
+module.exports = { buffer, sizeCompressed, sizeUncompressed };
+`);

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-rust.sh

@@ -1,25 +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
-
-rustup toolchain install nightly$NIGHTLY
-
-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$NIGHTLY cargo test --release -- --nocapture
-
-    cd ..
-  fi
-done
-
-cd ..

tsconfig.json

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

typedoc.js

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