[CI Skip] release/stable 7.0.1

skip-checks: true

.123trigger

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

.codeclimate.yml

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

.eslintrc.cjs

@@ -1,4 +1,4 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 const base = require('@polkadot/dev/config/eslint.cjs');
@@ -8,7 +8,7 @@ module.exports = {
   ignorePatterns: [
     ...base.ignorePatterns,
     '**/target/*',
-    'packages/bytes/*'
+    '**/test/*.ts'
   ],
   parserOptions: {
     ...base.parserOptions,

.github/issue_template.md

@@ -0,0 +1,86 @@
+<!--
+
+For general support, howto, coding and bundling questions, please
+use the Substrate & Polkadot StackExchange at
+
+  https://substrate.stackexchange.com/
+
+and get other ecosystem developers involved. This issues in this
+repository are meant for the tracking of feature requests and bug
+reports.
+
+While all issues are looked at non-bug and non-features would take
+quite a bit longer to get to and may yield less than satisfactory
+responses in this format.
+
+Additionally, please ensure you have done a search on the existing
+and closed issues before logging a new request. This saves time on
+all sides.
+
+-->
+
+
+* **I'm submitting a ...**
+
+<!---
+
+REQUIRED:
+
+Classify the type of report your are submitting
+
+-->
+
+  - [ ] Bug report
+  - [ ] Feature request
+  - [ ] Support request
+  - [ ] Other
+
+
+* **What is the current behavior and expected behavior?**
+
+<!---
+
+REQUIRED:
+
+If you're describing a bug, tell us what should happen. If you're
+suggesting a change/improvement, tell us how it should work.
+
+-->
+
+
+* **What is the motivation for changing the behavior?**
+
+<!---
+
+OPTIONAL:
+
+Suggest a motivation for the request or ideas how to implement the
+addition or change
+
+-->
+
+
+* **Please tell us about your environment:**
+
+<!---
+
+REQUIRED:
+
+Include as many relevant details about the environment in which you
+experienced the issue. Also ensure that you have tested against the
+latest stable releases if you believe this to be a bug
+
+-->
+
+  - Version:
+  - Environment:
+
+    - [ ] Node.js
+    - [ ] Browser
+    - [ ] Other (limited support for other environments)
+
+  - Language:
+
+    - [ ] JavaScript
+    - [ ] TypeScript (include tsc --version)
+    - [ ] Other

.github/workflows/auto-approve.yml

@@ -9,7 +9,7 @@ jobs:
     if: "! startsWith(github.event.head_commit.message, '[CI Skip]') && (!github.event.pull_request || github.event.pull_request.head.repo.full_name == github.repository)"
     runs-on: ubuntu-latest
     steps:
-      - uses: jacogr/action-approve@master
+      - uses: jacogr/action-approve@795afd1dd096a2071d7ec98740661af4e853b7da
         with:
           authors: jacogr
           labels: -auto

.github/workflows/auto-merge.yml

@@ -8,9 +8,9 @@ jobs:
   merge:
     runs-on: ubuntu-latest
     steps:
-      - uses: jacogr/action-merge@master
+      - uses: jacogr/action-merge@d2d64b4545acd93b0a9575177d3d215ae3f92029
         with:
-          checks: build,lint,test
+          checks: pr (build),pr (lint),pr (test)
           labels: -auto
           strategy: squash
           token: ${{ secrets.GH_PAT_BOT }}

.github/workflows/lock.yml

@@ -10,7 +10,7 @@ jobs:
     env:
       YARN_ENABLE_SCRIPTS: false
     steps:
-      - uses: dessant/lock-threads@v2
+      - uses: dessant/lock-threads@f1a42f0f44eb83361d617a014663e1a76cf282d2
         with:
           github-token: ${{ secrets.GH_PAT_BOT }}
           issue-lock-inactive-days: '7'

.github/workflows/pr-any.yml

@@ -3,17 +3,28 @@ on: [pull_request]
 
 jobs:
   pr:
+    continue-on-error: true
     strategy:
       matrix:
-        step: ['lint', 'test', 'build']
-    name: ${{ matrix.step }}
+        step: ['lint', 'test', 'build', 'deno']
     runs-on: ubuntu-latest
     env:
       YARN_ENABLE_SCRIPTS: false
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
+    - uses: actions/setup-node@v3
+      with:
+        node-version: 'lts/*'
+    - uses: denoland/setup-deno@v1
+      with:
+        deno-version: vx.x.x
     - name: ${{ matrix.step }}
+      if: always()
+      continue-on-error: true
       run: |
         yarn install --immutable | grep -v 'YN0013'
-        ./scripts/install-build-deps.sh
+        if [ "${{ matrix.step }}" != "lint" ]; then
+          ./scripts/install-build-deps.sh
+        fi
+        yarn polkadot-dev-deno-map
         yarn ${{ matrix.step }}

.github/workflows/push-master.yml

@@ -10,19 +10,21 @@ jobs:
     strategy:
       matrix:
         step: ['build:release']
-    name: ${{ matrix.step }}
     runs-on: ubuntu-latest
     env:
       YARN_ENABLE_SCRIPTS: false
       CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
-      GH_PAT: ${{ secrets.GH_PAT }}
-      GH_RELEASE_GITHUB_API_TOKEN: ${{ secrets.GH_PAT }}
+      GH_PAT: ${{ secrets.GH_PAT_BOT }}
+      GH_RELEASE_GITHUB_API_TOKEN: ${{ secrets.GH_PAT_BOT }}
       NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
       with:
         fetch-depth: 0
-        token: ${{ secrets.GH_PAT }}
+        token: ${{ secrets.GH_PAT_BOT }}
+    - uses: actions/setup-node@v3
+      with:
+        node-version: 'lts/*'
     - name: build
       run: |
         yarn install --immutable | grep -v 'YN0013'

.github/workflows/semgrep.yml

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

.github/workflows/stale.yml

@@ -9,7 +9,7 @@ jobs:
     env:
       YARN_ENABLE_SCRIPTS: false
     steps:
-      - uses: actions/stale@v3
+      - uses: actions/stale@98ed4cb500039dbcccf4bd9bedada4d0187f2757
         with:
           repo-token: ${{ secrets.GH_PAT_BOT }}
           stale-issue-message: 'This issue has been open for 21 days with no activity and is not labelled as an enhancement. It will be closed in 7 days.'

.gitignore

@@ -1,15 +1,16 @@
 binaryen/
 bindgen/
 build/
-build-docs/
+build-*/
 bytes/
 coverage/
-docs/.vuepress/dist/
 node_modules/
 pkg/
 target/
 tmp/
 wabt/
+/import_map.json
+/mod.ts
 .DS_Store
 .env.local
 .env.development.local

.prettierrc.cjs

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

CHANGELOG.md

@@ -1,9 +1,114 @@
 # CHANGELOG
 
+## 7.0.1 Mar 4, 2023
+
+Changes:
+
+- Swap TS -> JS compiler to use tsc (from babel)
+- Adjust all tests to use `node:test` runner (ESM & CJS variants)
+
+
+## 6.4.1 Dec 3, 2022
+
+Changes:
+
+- Add `/*#__PURE__*/` annotations for specific `export const something = someFunction(...)`
+
+
+## 6.3.1 Jul 21, 2022
+
+Changes:
+
+- Optimize packed WASM base64 decoding loop
+- Adjust test environment (no duplication)
+- Adjust CI check steps, align with other org repos
+- Remove unneeded `import_map.in.json` for Deno tests
+
+
+## 6.2.3 Jul 7, 2022
+
+Changes:
+
+- Optimize WASM init with pre-allocated buffers
+- Additional platform-specific tests
+
+
+## 6.2.2 Jul 4, 2022
+
+Changes:
+
+- Protect against potential low-level double-sign leak in dalek-ed25519 (Don't use provided input pubKey, see https://github.com/MystenLabs/ed25519-unsafe-libs)
+
+
+## 6.2.1 Jul 1, 2022
+
+Changes:
+
+- Add missing `peerDependencies` to `wasm-crypto` (`bridge` requirement)
+- Adjust `WebAssembly.{Memory, ModuleImports}` usage to cater for non-dom TS
+
+
+## 6.1.5 Jun 23, 2022
+
+Changes:
+
+- Adjust build outputs for Deno targets
+
+
+## 6.1.4 Jun 22, 2022
+
+Changes:
+
+- Adjust build outputs for Deno targets
+
+
+## 6.1.3 Jun 21, 2022
+
+Changes:
+
+- Fix bundle publish (from dev bump)
+
+
+## 6.1.2 Jun 21, 2022
+
+Changes:
+
+- Adjust assert usage in all internal non-test code
+- Additional comments where missing
+
+
+## 6.1.1 May 13, 2022
+
+Changes:
+
+- Adjust init, allow RN with default ASM.js-only fallback
+- Split `wasm-{bridge, util}` packages for internal re-use
+
+
+## 6.0.1 Apr 9, 2022
+
+- **Breaking change** In this major version the commonjs outputs are moved to a sub-folder. Since the `export` map and `main` field in `package.json` does reflect this change, there should be no usage changes. However the packages here will all need to be on the same version for internal linkage.
+
+Changes:
+
+- Update ed25519 secret key format return description
+- Output commonjs files under the `cjs/**` root
+
+
+## 5.1.1 Mar 27, 2022
+
+Changes:
+
+- Swap from `libsecp256k1` to `secp256k1` (this aligns with the Substrate use)
+- Adjust `wasm-crypto/init*` to also export `initWasm(): Promise<void>` (optional manual init)
+- Allow for `wasm-crypto/initNone` with no defined Wasm or Asm interfaces
+- Fix initialization on React Native with only ASM
+
+
 ## 5.0.1 Mar 19, 2022
 
 - **Breaking change** For users of React Native, you are now required to add `import '@polkadot/wasm-crypto/initOnlyAsm'` at your project top-level to ensure that asm.js is initialized. (Or alternatively `import '@polkadot/wasm-crypto/initWasmAsm'` to future-proof when WASM does become available)
-- **Breaking change** For users who used to map the `data` and `empty` of the internal `wasm-crypto-{wasm, asmjs}` packages in their bundlers, swap to one of the `@polkadot/wasm-crypto/init*` top-level imports to set the type of interfaces you would prefer.
+- **Breaking change** For users who used to map the `data` and `empty` of the internal `wasm-crypto-{wasm, asmjs}` packages in their bundlers, swap to one of the `@polkadot/wasm-crypto/init*` top-level imports to set the type of interfaces you would prefer. A full writeup of the rationale and other options can be found [in the FAQ](https://polkadot.js.org/docs/util-crypto/FAQ#i-dont-have-wasm-available-in-my-environment)
 
 Changes:
 

CONTRIBUTORS

@@ -1,4 +1,4 @@
-     384	Jaco                          	5.0.1 (#312)
+     549	Jaco                          	7.0.1 (#487)
        1	Evgeny                        	Fixed type (#121)
        1	Shunfan Zhou                  	Support sr25519 agreement (#209)
        1	Steve Degosserie              	Expose Schnorrkel's VRF capabilities (#170)

README.md

@@ -1,9 +1,3 @@
-[![polkadotjs](https://img.shields.io/badge/polkadot-js-orange?style=flat-square)](https://polkadot.js.org)
-![license](https://img.shields.io/badge/License-Apache%202.0-blue?logo=apache&style=flat-square)
-[![npm](https://img.shields.io/npm/v/@polkadot/wasm-crypto?logo=npm&style=flat-square)](https://www.npmjs.com/package/@polkadot/wasm-crypto)
-[![beta](https://img.shields.io/npm/v/@polkadot/wasm-crypto/beta?label=beta&logo=npm&&style=flat-square)](https://www.npmjs.com/package/@polkadot/wasm-crypto)
-[![maintainability](https://img.shields.io/codeclimate/maintainability-percentage/polkadot-js/wasm?logo=code-climate&style=flat-square)](https://codeclimate.com/github/polkadot-js/wasm/maintainability)
-
 # @polkadot/wasm
 
 Various WASM wrappers around Rust crates

babel.config.cjs

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

import_map.in.json

@@ -0,0 +1,5 @@
+{
+  "imports": {
+    "https://esm.sh/v90/@types/bn.js@~5.2/index.d.ts": "https://esm.sh/v90/@types/bn.js@5.1.0/index.d.ts"
+  }
+}

jest.config.cjs

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

package.json

@@ -10,32 +10,45 @@
     "url": "https://github.com/polkadot-js/wasm.git"
   },
   "sideEffects": false,
-  "version": "5.0.1",
+  "type": "module",
+  "version": "7.0.1",
+  "versions": {
+    "git": "7.0.1",
+    "npm": "7.0.1"
+  },
   "workspaces": [
     "packages/*"
   ],
   "scripts": {
     "build": "yarn build:wasm",
     "build:js": "./scripts/build-js.sh",
+    "build:mac": "PATH=\"/opt/homebrew/opt/llvm/bin:$PATH\" CC=/opt/homebrew/opt/llvm/bin/clang AR=/opt/homebrew/opt/llvm/bin/llvm-ar yarn build",
     "build:release": "polkadot-ci-ghact-build",
     "build:rollup": "polkadot-exec-rollup --config",
     "build:wasm": "./scripts/build.sh",
     "clean": "./scripts/clean.sh",
+    "deno": "yarn deno:build && yarn deno:check",
+    "deno:build": "WITH_DENO=1 yarn build",
+    "deno:check": "deno check --import-map=import_map.json mod.ts",
     "lint": "polkadot-dev-run-lint",
     "postinstall": "polkadot-dev-yarn-only",
-    "test": "yarn test:wasm:rust",
-    "test:wasm:js": "yarn test:wasm:js:jest && yarn test:wasm:js:node",
-    "test:wasm:js:jest": "polkadot-dev-run-test ./test/jest.spec.js",
-    "test:wasm:js:node": "cd packages/wasm-crypto && node ./test/wasm.cjs && node ./test/asm.cjs",
-    "test:wasm:rust": "cd packages/wasm-crypto && RUST_BACKTRACE=full cargo test --release -- --nocapture"
+    "test": "yarn test:wasm-crypto:rust",
+    "test:js": "yarn test:wasm-crypto:js",
+    "test:wasm-crypto:deno": "deno test --allow-read --import-map=import_map.json packages/wasm-crypto/test/deno.ts",
+    "test:wasm-crypto:js": "yarn test:wasm-crypto:js:jest && yarn test:wasm-crypto:js:node",
+    "test:wasm-crypto:js:jest": "polkadot-dev-run-test --env node --loader ./packages/wasm-crypto/test/loader-build.js test/jest.spec.ts",
+    "test:wasm-crypto:js:node": "node --no-warnings --loader ./packages/wasm-crypto/test/loader-build.js ./packages/wasm-crypto/test/wasm.js && node --no-warnings --loader ./packages/wasm-crypto/test/loader-build.js ./packages/wasm-crypto/test/asm.js",
+    "test:wasm-crypto:rust": "cd packages/wasm-crypto && RUST_BACKTRACE=full cargo test --release -- --test-threads=1 --nocapture"
   },
   "devDependencies": {
-    "@babel/core": "^7.17.8",
-    "@polkadot/dev": "^0.65.97",
-    "fflate": "^0.7.3",
-    "override-require": "^1.1.1"
+    "@babel/core": "^7.21.0",
+    "@polkadot/dev": "^0.69.26",
+    "@polkadot/util": "^10.4.2",
+    "@polkadot/x-randomvalues": "^10.4.2",
+    "@types/node": "^18.14.6",
+    "fflate": "^0.7.4"
   },
   "resolutions": {
-    "typescript": "^4.6.2"
+    "typescript": "^4.9.5"
   }
 }

packages/wasm-bridge/README.md

@@ -0,0 +1,3 @@
+# @polkadot/wasm-bridge
+
+A re-usable bridge between JS & WASM interfaces. It is used internally by `@polkadot/wasm-crypto`.

packages/wasm-bridge/package.json

@@ -0,0 +1,36 @@
+{
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/polkadot-js/wasm/issues",
+  "contributors": [],
+  "description": "A bridge layer between JS and Wasm",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "homepage": "https://github.com/polkadot-js/wasm/tree/master/packages/wasm-bridge#readme",
+  "license": "Apache-2.0",
+  "maintainers": [],
+  "name": "@polkadot/wasm-bridge",
+  "repository": {
+    "directory": "packages/wasm-bridge",
+    "type": "git",
+    "url": "https://github.com/polkadot-js/wasm.git"
+  },
+  "sideEffects": [
+    "./detectPackage.js",
+    "./detectPackage.cjs"
+  ],
+  "type": "module",
+  "version": "7.0.1",
+  "main": "index.js",
+  "dependencies": {
+    "tslib": "^2.5.0"
+  },
+  "devDependencies": {
+    "@polkadot/util": "^10.4.2",
+    "@polkadot/x-randomvalues": "^10.4.2"
+  },
+  "peerDependencies": {
+    "@polkadot/util": "*",
+    "@polkadot/x-randomvalues": "*"
+  }
+}

packages/wasm-bridge/src/bridge.ts

@@ -0,0 +1,213 @@
+// Copyright 2019-2023 @polkadot/wasm-bridge authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// A number of functions are "unsafe" and purposefully so - it is
+// assumed that where the bridge is used, it is correctly wrapped
+// in a safeguard (see withWasm in the wasm-crypto package) which
+// then ensures that the internal wasm instance here is available
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+import type { BridgeBase, InitFn, InitPromise, WasmBaseInstance, WasmImports } from './types';
+
+import { stringToU8a, u8aToString } from '@polkadot/util';
+
+import { Wbg } from './wbg';
+
+/**
+ * @name Bridge
+ * @description
+ * Creates a bridge between the JS and WASM environments.
+ *
+ * For any bridge it is passed an function white is then called internally at the
+ * time of initialization. This affectively implements the layer between WASM and
+ * the native environment, providing all the plumbing needed for the Wbg classes.
+ */
+export class Bridge<C extends WasmBaseInstance> implements BridgeBase<C> {
+  #cachegetInt32: Int32Array | null;
+  #cachegetUint8: Uint8Array | null;
+  #createWasm: InitFn<C>;
+  #heap: unknown[];
+  #heapNext: number;
+  #wasm: C | null;
+  #wasmError: string | null;
+  #wasmPromise: InitPromise<C> | null;
+  #wbg: WasmImports;
+  #type: 'asm' | 'wasm' | 'none';
+
+  constructor (createWasm: InitFn<C>) {
+    this.#createWasm = createWasm;
+    this.#cachegetInt32 = null;
+    this.#cachegetUint8 = null;
+    this.#heap = new Array(32)
+      .fill(undefined)
+      .concat(undefined, null, true, false);
+    this.#heapNext = this.#heap.length;
+    this.#type = 'none';
+    this.#wasm = null;
+    this.#wasmError = null;
+    this.#wasmPromise = null;
+    this.#wbg = { ...new Wbg(this) };
+  }
+
+  /** @description Returns the init error */
+  get error (): string | null {
+    return this.#wasmError;
+  }
+
+  /** @description Returns the init type */
+  get type (): 'asm' | 'wasm' | 'none' {
+    return this.#type;
+  }
+
+  /** @description Returns the created wasm interface */
+  get wasm (): C | null {
+    return this.#wasm;
+  }
+
+  /** @description Performs the wasm initialization */
+  async init (createWasm?: InitFn<C>): Promise<C | null> {
+    if (!this.#wasmPromise || createWasm) {
+      this.#wasmPromise = (createWasm || this.#createWasm)(this.#wbg);
+    }
+
+    const { error, type, wasm } = await this.#wasmPromise;
+
+    this.#type = type;
+    this.#wasm = wasm;
+    this.#wasmError = error;
+
+    return this.#wasm;
+  }
+
+  /**
+   * @internal
+   * @description Gets an object from the heap
+   */
+  getObject (idx: number): unknown {
+    return this.#heap[idx];
+  }
+
+  /**
+   * @internal
+   * @description Removes an object from the heap
+   */
+  dropObject (idx: number) {
+    if (idx < 36) {
+      return;
+    }
+
+    this.#heap[idx] = this.#heapNext;
+    this.#heapNext = idx;
+  }
+
+  /**
+   * @internal
+   * @description Retrieves and removes an object to the heap
+   */
+  takeObject (idx: number): unknown {
+    const ret = this.getObject(idx);
+
+    this.dropObject(idx);
+
+    return ret;
+  }
+
+  /**
+   * @internal
+   * @description Adds an object to the heap
+   */
+  addObject (obj: unknown): number {
+    if (this.#heapNext === this.#heap.length) {
+      this.#heap.push(this.#heap.length + 1);
+    }
+
+    const idx = this.#heapNext;
+
+    this.#heapNext = this.#heap[idx] as number;
+    this.#heap[idx] = obj;
+
+    return idx;
+  }
+
+  /**
+   * @internal
+   * @description Retrieve an Int32 in the WASM interface
+   */
+  getInt32 (): Int32Array {
+    if (this.#cachegetInt32 === null || this.#cachegetInt32.buffer !== this.#wasm!.memory.buffer) {
+      this.#cachegetInt32 = new Int32Array(this.#wasm!.memory.buffer);
+    }
+
+    return this.#cachegetInt32;
+  }
+
+  /**
+   * @internal
+   * @description Retrieve an Uint8Array in the WASM interface
+   */
+  getUint8 (): Uint8Array {
+    if (this.#cachegetUint8 === null || this.#cachegetUint8.buffer !== this.#wasm!.memory.buffer) {
+      this.#cachegetUint8 = new Uint8Array(this.#wasm!.memory.buffer);
+    }
+
+    return this.#cachegetUint8;
+  }
+
+  /**
+   * @internal
+   * @description Retrieves an Uint8Array in the WASM interface
+   */
+  getU8a (ptr: number, len: number): Uint8Array {
+    return this.getUint8().subarray(ptr / 1, ptr / 1 + len);
+  }
+
+  /**
+   * @internal
+   * @description Retrieves a string in the WASM interface
+   */
+  getString (ptr: number, len: number): string {
+    return u8aToString(this.getU8a(ptr, len));
+  }
+
+  /**
+   * @internal
+   * @description Allocates an Uint8Array in the WASM interface
+   */
+  allocU8a (arg: Uint8Array): [number, number] {
+    const ptr = this.#wasm!.__wbindgen_malloc(arg.length * 1);
+
+    this.getUint8().set(arg, ptr / 1);
+
+    return [ptr, arg.length];
+  }
+
+  /**
+   * @internal
+   * @description Allocates a string in the WASM interface
+   */
+  allocString (arg: string): [number, number] {
+    return this.allocU8a(stringToU8a(arg));
+  }
+
+  /**
+   * @internal
+   * @description Retrieves an Uint8Array from the WASM interface
+   */
+  resultU8a (): Uint8Array {
+    const r0 = this.getInt32()[8 / 4 + 0];
+    const r1 = this.getInt32()[8 / 4 + 1];
+    const ret = this.getU8a(r0, r1).slice();
+
+    this.#wasm!.__wbindgen_free(r0, r1 * 1);
+
+    return ret;
+  }
+
+  /**
+   * @internal
+   * @description Retrieve a string from the WASM interface
+   */
+  resultString (): string {
+    return u8aToString(this.resultU8a());
+  }
+}

packages/wasm-bridge/src/bundle.ts

@@ -0,0 +1,5 @@
+// Copyright 2019-2023 @polkadot/wasm-bridge authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './bridge';
+export * from './init';

packages/wasm-bridge/src/detectOther.ts

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

packages/wasm-bridge/src/detectPackage.ts

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

packages/wasm-bridge/src/index.ts

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

packages/wasm-bridge/src/init.ts

@@ -0,0 +1,47 @@
+// Copyright 2019-2023 @polkadot/wasm-bundle authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { InitFn, InitPromise, InitResult, WasmBaseInstance, WasmImports } from './types';
+
+/**
+ * @name createWasmFn
+ * @description
+ * Create a WASM (or ASM.js) creator interface based on the supplied information.
+ *
+ * It will attempt to create a WASM interface first and if this fails or is not available in
+ * the environment, will fallback to attempting to create an ASM.js interface.
+ */
+export function createWasmFn <C extends WasmBaseInstance> (root: string, wasmBytes: null | Uint8Array, asmFn: null | ((wbg: WasmImports) => C)): InitFn<C> {
+  return async (wbg: WasmImports): InitPromise<C> => {
+    const result: InitResult<C> = {
+      error: null,
+      type: 'none',
+      wasm: null
+    };
+
+    try {
+      if (!wasmBytes || !wasmBytes.length) {
+        throw new Error('No WebAssembly provided for initialization');
+      } else if (typeof WebAssembly !== 'object' || typeof WebAssembly.instantiate !== 'function') {
+        throw new Error('WebAssembly is not available in your environment');
+      }
+
+      const source = await WebAssembly.instantiate(wasmBytes, { wbg });
+
+      result.wasm = source.instance.exports as unknown as C;
+      result.type = 'wasm';
+    } catch (error) {
+      // if we have a valid supplied asm.js, return that
+      if (typeof asmFn === 'function') {
+        result.wasm = asmFn(wbg);
+        result.type = 'asm';
+      } else {
+        result.error = `FATAL: Unable to initialize @polkadot/wasm-${root}:: ${(error as Error).message}`;
+
+        console.error(result.error);
+      }
+    }
+
+    return result;
+  };
+}

packages/wasm-bridge/src/mod.ts

@@ -0,0 +1,4 @@
+// Copyright 2019-2023 @polkadot/wasm-bridge authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index';

packages/wasm-bridge/src/packageInfo.ts

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

packages/wasm-bridge/src/types.ts

@@ -0,0 +1,47 @@
+// Copyright 2019-2023 @polkadot/wasm-bridge authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Use non-strong types instead of WasmImports which may not
+// be available as part of the TS environment types (it needs dom)
+export type WasmImports = Record<string, (...args: never[]) => unknown>;
+
+// Use non-strong types instead of WebAssembly.Memory which may not
+// be available as part of the TS environment types (it needs dom)
+export type WasmMemory = { buffer: ArrayBuffer };
+
+export declare interface InitResult<C extends WasmBaseInstance> {
+  error: string | null;
+  type: 'asm' | 'wasm' | 'none';
+  wasm: C | null;
+}
+
+export type InitPromise <C extends WasmBaseInstance> = Promise<InitResult<C>>;
+
+export type InitFn <C extends WasmBaseInstance> = (wbg: WasmImports) => InitPromise<C>;
+
+export interface BridgeBase<C extends WasmBaseInstance> extends InitResult<C> {
+  init (createWasm?: InitFn<C>): Promise<C | null>;
+  getObject (idx: number): unknown;
+  dropObject (idx: number): void;
+  takeObject (idx: number): unknown;
+  addObject (obj: unknown): number;
+  getInt32 (): Int32Array;
+  getUint8 (): Uint8Array;
+  getU8a (ptr: number, len: number): Uint8Array;
+  getString (ptr: number, len: number): string;
+  allocU8a (arg: Uint8Array): [number, number];
+  allocString (arg: string): [number, number];
+  resultU8a (): Uint8Array;
+  resultString (): string;
+}
+
+export interface WasmBaseInstance {
+  memory: WasmMemory;
+
+  // wbindgen functions (required and used internally)
+
+  __wbindgen_exn_store (a: number): void;
+  __wbindgen_free (a: number, b: number): void;
+  __wbindgen_malloc (a: number): number;
+  __wbindgen_realloc (a: number, b: number, c: number): number;
+}

packages/wasm-bridge/src/wbg.ts

@@ -0,0 +1,84 @@
+// Copyright 2019-2023 @polkadot/wasm-bridge authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { BridgeBase, WasmBaseInstance } from './types';
+
+import { getRandomValues } from '@polkadot/x-randomvalues';
+
+const DEFAULT_CRYPTO = { getRandomValues };
+const DEFAULT_SELF = { crypto: DEFAULT_CRYPTO };
+
+/**
+ * @name Wbg
+ * @description
+ * This defines the internal interfaces that wasm-bindgen used to communicate
+ * with the host layer. None of these functions are available to the user, rather
+ * they are called internally from the WASM code itself.
+ *
+ * The interfaces here are exposed in the imports on the created WASM interfaces.
+ *
+ * Internally the implementation does a thin layer into the supplied bridge.
+ */
+export class Wbg<C extends WasmBaseInstance> {
+  #bridge: BridgeBase<C>;
+
+  constructor (bridge: BridgeBase<C>) {
+    this.#bridge = bridge;
+  }
+
+  /** @internal */
+  abort = (): never => {
+    throw new Error('abort');
+  };
+
+  /** @internal */
+  __wbindgen_is_undefined = (idx: number): boolean => {
+    return this.#bridge.getObject(idx) === undefined;
+  };
+
+  /** @internal */
+  __wbindgen_throw = (ptr: number, len: number): boolean => {
+    throw new Error(this.#bridge.getString(ptr, len));
+  };
+
+  /** @internal */
+  __wbg_self_1b7a39e3a92c949c = (): number => {
+    return this.#bridge.addObject(DEFAULT_SELF);
+  };
+
+  /** @internal */
+  __wbg_require_604837428532a733 = (ptr: number, len: number): never => {
+    throw new Error(`Unable to require ${this.#bridge.getString(ptr, len)}`);
+  };
+
+  /** @internal */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  __wbg_crypto_968f1772287e2df0 = (_idx: number): number => {
+    return this.#bridge.addObject(DEFAULT_CRYPTO);
+  };
+
+  /** @internal */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  __wbg_getRandomValues_a3d34b4fee3c2869 = (_idx: number): number => {
+    return this.#bridge.addObject(DEFAULT_CRYPTO.getRandomValues);
+  };
+
+  /** @internal */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  __wbg_getRandomValues_f5e14ab7ac8e995d = (_arg0: number, ptr: number, len: number): void => {
+    DEFAULT_CRYPTO.getRandomValues(this.#bridge.getU8a(ptr, len));
+  };
+
+  /** @internal */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  __wbg_randomFillSync_d5bd2d655fdf256a = (_idx: number, _ptr: number, _len: number): never => {
+    throw new Error('randomFillsync is not available');
+
+    // getObject(idx).randomFillSync(getU8a(ptr, len));
+  };
+
+  /** @internal */
+  __wbindgen_object_drop_ref = (idx: number): void => {
+    this.#bridge.takeObject(idx);
+  };
+}

packages/wasm-bridge/tsconfig.build.json

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

packages/wasm-crypto-asmjs/README.md

@@ -0,0 +1,3 @@
+## @polkadot/wasm-crypto-asmjs
+
+Asm.js build outputs.

packages/wasm-crypto-asmjs/package.json

@@ -17,13 +17,13 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "5.0.1",
+  "version": "7.0.1",
   "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.17.8"
+    "tslib": "^2.5.0"
   },
   "devDependencies": {
-    "@polkadot/util": "^8.5.1"
+    "@polkadot/util": "^10.4.2"
   },
   "peerDependencies": {
     "@polkadot/util": "*"

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

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

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

@@ -0,0 +1,6 @@
+// Copyright 2019-2023 @polkadot/wasm-crypto-wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const data = require('../data');
+
+module.exports = data;

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

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

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-// Copyright 2017-2022 @polkadot/wasm-crypto-asmjs authors & contributors
+// Copyright 2017-2023 @polkadot/wasm-crypto-asmjs authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 // Do not edit, auto-generated by @polkadot/dev

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

@@ -1,4 +1,4 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto-asmjs authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto-asmjs authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import './detectPackage';

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

@@ -0,0 +1,4 @@
+// Copyright 2019-2023 @polkadot/wasm-crypto-asmjs authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index';

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

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

packages/wasm-crypto-init/README.md

@@ -0,0 +1,3 @@
+## @polkadot/wasm-crypto-init
+
+Internal `@polkadot/wasm-crypto` initialization functions for Browser, Node & RN.

packages/wasm-crypto-init/package.json

@@ -0,0 +1,41 @@
+{
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/polkadot-js/wasm/issues",
+  "contributors": [],
+  "description": "Init handlers for wasm-crypto",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "homepage": "https://github.com/polkadot-js/wasm/tree/master/packages/wasm-crypto-init#readme",
+  "license": "Apache-2.0",
+  "maintainers": [],
+  "name": "@polkadot/wasm-crypto-init",
+  "repository": {
+    "directory": "packages/wasm-crypto-init",
+    "type": "git",
+    "url": "https://github.com/polkadot-js/wasm.git"
+  },
+  "sideEffects": [
+    "./detectPackage.js",
+    "./detectPackage.cjs"
+  ],
+  "type": "module",
+  "version": "7.0.1",
+  "browser": "wasm.js",
+  "main": "wasm.js",
+  "react-native": "asm.js",
+  "dependencies": {
+    "@polkadot/wasm-bridge": "7.0.1",
+    "@polkadot/wasm-crypto-asmjs": "7.0.1",
+    "@polkadot/wasm-crypto-wasm": "7.0.1",
+    "tslib": "^2.5.0"
+  },
+  "devDependencies": {
+    "@polkadot/util": "^10.4.2",
+    "@polkadot/x-randomvalues": "^10.4.2"
+  },
+  "peerDependencies": {
+    "@polkadot/util": "*",
+    "@polkadot/x-randomvalues": "*"
+  }
+}

packages/wasm-crypto-init/src/asm.ts

@@ -0,0 +1,17 @@
+// Copyright 2019-2023 @polkadot/wasm-crypto-init authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { InitFn } from '@polkadot/wasm-bridge/types';
+import type { WasmCryptoInstance } from './types';
+
+import { createWasmFn } from '@polkadot/wasm-bridge';
+import { asmJsInit } from '@polkadot/wasm-crypto-asmjs';
+
+export { packageInfo } from './packageInfo';
+
+/**
+ * @name createWasm
+ * @description
+ * Creates an interface using only ASM.js
+ */
+export const createWasm: InitFn<WasmCryptoInstance> = /*#__PURE__*/ createWasmFn('crypto', null, asmJsInit);

packages/wasm-crypto-init/src/both.ts

@@ -0,0 +1,18 @@
+// Copyright 2019-2023 @polkadot/wasm-crypto-init authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { InitFn } from '@polkadot/wasm-bridge/types';
+import type { WasmCryptoInstance } from './types';
+
+import { createWasmFn } from '@polkadot/wasm-bridge';
+import { asmJsInit } from '@polkadot/wasm-crypto-asmjs';
+import { wasmBytes } from '@polkadot/wasm-crypto-wasm';
+
+export { packageInfo } from './packageInfo';
+
+/**
+ * @name createWasm
+ * @description
+ * Creates an interface using WASM and a fallback ASM.js
+ */
+export const createWasm: InitFn<WasmCryptoInstance> = /*#__PURE__*/ createWasmFn('crypto', wasmBytes, asmJsInit);

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

@@ -0,0 +1,4 @@
+// Copyright 2019-2023 @polkadot/wasm-crypto-init authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './wasm';

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

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

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

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

packages/wasm-crypto-init/src/mod.ts

@@ -0,0 +1,4 @@
+// Copyright 2019-2023 @polkadot/wasm-crypto-init authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './wasm';

packages/wasm-crypto-init/src/none.ts

@@ -0,0 +1,16 @@
+// Copyright 2019-2023 @polkadot/wasm-crypto-init authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { InitFn } from '@polkadot/wasm-bridge/types';
+import type { WasmCryptoInstance } from './types';
+
+import { createWasmFn } from '@polkadot/wasm-bridge';
+
+export { packageInfo } from './packageInfo';
+
+/**
+ * @name createWasm
+ * @description
+ * Creates an interface using no WASM and no ASM.js
+ */
+export const createWasm: InitFn<WasmCryptoInstance> = /*#__PURE__*/ createWasmFn('crypto', null, null);

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

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

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

@@ -1,22 +1,12 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto-init authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import type { WasmBaseInstance } from '@polkadot/wasm-bridge/types';
+
 /* eslint-disable camelcase */
 
 // wasm-pack build output (formatted) from pkg/wasm_bg.d.ts
-export interface WasmCryptoInstance {
-  memory: WebAssembly.Memory;
-
-  // wbindgen functions (required and used internally)
-
-  __wbindgen_free(a: number, b: number): void;
-
-  __wbindgen_malloc(a: number): number;
-
-  __wbindgen_realloc(a: number, b: number, c: number): number;
-
-  __wbindgen_exn_store(a: number): void;
-
+export interface WasmCryptoInstance extends WasmBaseInstance {
   // exposed functions
 
   ext_bip39_generate(resLen: 8, words: number): void;
@@ -83,5 +73,3 @@ export interface WasmCryptoInstance {
 
   ext_vrf_verify(ptrPub: number, lenPub: number, ptrCtx: number, lenCtx: number, ptrMsg: number, lenMsg: number, ptrExtra: number, lenExtra: number, ptrProof: number, lenProof: number): number;
 }
-
-export type AsmCreator = (wbg: Record<string, WebAssembly.ImportValue>) => WasmCryptoInstance;

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

@@ -0,0 +1,17 @@
+// Copyright 2019-2023 @polkadot/wasm-crypto-init authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { InitFn } from '@polkadot/wasm-bridge/types';
+import type { WasmCryptoInstance } from './types';
+
+import { createWasmFn } from '@polkadot/wasm-bridge';
+import { wasmBytes } from '@polkadot/wasm-crypto-wasm';
+
+export { packageInfo } from './packageInfo';
+
+/**
+ * @name createWasm
+ * @description
+ * Creates an interface using only WASM
+ */
+export const createWasm: InitFn<WasmCryptoInstance> = /*#__PURE__*/ createWasmFn('crypto', wasmBytes, null);

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

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "references": [
+    { "path": "../wasm-bridge/tsconfig.build.json" },
+    { "path": "../wasm-crypto-asmjs/tsconfig.build.json" },
+    { "path": "../wasm-crypto-wasm/tsconfig.build.json" }
+  ]
+}

packages/wasm-crypto-wasm/README.md

@@ -0,0 +1,3 @@
+## @polkadot/wasm-crypto-wasm
+
+Wasm build outputs.

packages/wasm-crypto-wasm/package.json

@@ -17,13 +17,14 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "5.0.1",
+  "version": "7.0.1",
   "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.17.8"
+    "@polkadot/wasm-util": "7.0.1",
+    "tslib": "^2.5.0"
   },
   "devDependencies": {
-    "@polkadot/util": "^8.5.1"
+    "@polkadot/util": "^10.4.2"
   },
   "peerDependencies": {
     "@polkadot/util": "*"

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

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

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

@@ -1,10 +1,19 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto-wasm authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto-wasm authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { base64Decode } from './base64';
-import { bytes, sizeUncompressed } from './bytes';
-import { unzlibSync } from './fflate';
+import { base64Decode, unzlibSync } from '@polkadot/wasm-util';
+
+import { bytes, lenIn, lenOut } from './cjs/bytes.js';
 
 export { packageInfo } from './packageInfo';
 
-export const wasmBytes = unzlibSync(base64Decode(bytes), new Uint8Array(sizeUncompressed));
+/**
+ * @name wasmBytes
+ * @description
+ * The decoded WASM interface as exposed by this package.
+ *
+ * The build process will output into cjs/* into a compressed base64 format.
+ * Upon loading the exposed bytes will be decoded and decompressed from this
+ * specific format and returned.
+ */
+export const wasmBytes = /*#__PURE__*/ unzlibSync(base64Decode(bytes, new Uint8Array(lenIn)), new Uint8Array(lenOut));

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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+// Copyright 2019-2023 @polkadot/wasm-crypto-wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const bytes = require('../bytes');
+
+module.exports = bytes;

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

@@ -0,0 +1,8 @@
+// Copyright 2019-2023 @polkadot/wasm-crypto-wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export declare const bytes: string;
+
+export declare const lenIn: number;
+
+export declare const lenOut: number;

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

@@ -0,0 +1,8 @@
+// Copyright 2019-2023 @polkadot/wasm-crypto-wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export const bytes = '';
+
+export const lenIn = 0;
+
+export const lenOut = 0;

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

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

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

@@ -1,4 +1,4 @@
-// Copyright 2017-2022 @polkadot/wasm-crypto-wasm authors & contributors
+// Copyright 2017-2023 @polkadot/wasm-crypto-wasm authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 // Do not edit, auto-generated by @polkadot/dev

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

@@ -1,4 +1,4 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto-wasm authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto-wasm authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import './detectPackage';

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

@@ -0,0 +1,4 @@
+// Copyright 2019-2023 @polkadot/wasm-crypto-wasm authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index';

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

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

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

@@ -5,5 +5,7 @@
     "outDir": "./build",
     "rootDir": "./src"
   },
-  "references": []
+  "references": [
+    { "path": "../wasm-util/tsconfig.build.json" }
+  ]
 }

packages/wasm-crypto/Cargo.lock

@@ -52,12 +52,6 @@ dependencies = [
  "rustc-demangle",
 ]
 
-[[package]]
-name = "base64"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
-
 [[package]]
 name = "bitflags"
 version = "1.2.1"
@@ -83,16 +77,7 @@ dependencies = [
  "block-padding",
  "byte-tools",
  "byteorder",
- "generic-array 0.12.3",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
-dependencies = [
- "generic-array 0.14.4",
+ "generic-array",
 ]
 
 [[package]]
@@ -122,6 +107,12 @@ version = "1.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
 
+[[package]]
+name = "cc"
+version = "1.0.73"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+
 [[package]]
 name = "cfg-if"
 version = "0.1.10"
@@ -149,15 +140,6 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
 
-[[package]]
-name = "cpufeatures"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95059428f66df56b63431fdb4e1947ed2190586af5c5a8a8b71122bdf5a7f469"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "crunchy"
 version = "0.2.2"
@@ -170,20 +152,10 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4434400df11d95d556bac068ddfedd482915eb18fe8bea89bc80b6e4b1c179e5"
 dependencies = [
- "generic-array 0.12.3",
+ "generic-array",
  "subtle 1.0.0",
 ]
 
-[[package]]
-name = "crypto-mac"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b584a330336237c1eecd3e94266efb216c56ed91225d634cb2991c5f3fd1aeab"
-dependencies = [
- "generic-array 0.14.4",
- "subtle 2.2.3",
-]
-
 [[package]]
 name = "curve25519-dalek"
 version = "2.1.0"
@@ -191,8 +163,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d85653f070353a16313d0046f173f70d1aadd5b42600a14de626f0dfb3473a5"
 dependencies = [
  "byteorder",
- "digest 0.8.1",
- "rand_core 0.5.1",
+ "digest",
+ "rand_core",
  "subtle 2.2.3",
  "zeroize",
 ]
@@ -203,16 +175,7 @@ version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
 dependencies = [
- "generic-array 0.12.3",
-]
-
-[[package]]
-name = "digest"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
-dependencies = [
- "generic-array 0.14.4",
+ "generic-array",
 ]
 
 [[package]]
@@ -232,9 +195,9 @@ checksum = "21a8a37f4e8b35af971e6db5e3897e7a6344caa3f92f6544f88125a1f5f0035a"
 dependencies = [
  "curve25519-dalek",
  "ed25519",
- "rand 0.7.3",
+ "rand",
  "serde",
- "sha2 0.8.2",
+ "sha2",
  "zeroize",
 ]
 
@@ -275,16 +238,6 @@ dependencies = [
  "typenum",
 ]
 
-[[package]]
-name = "generic-array"
-version = "0.14.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
-dependencies = [
- "typenum",
- "version_check",
-]
-
 [[package]]
 name = "getrandom"
 version = "0.1.14"
@@ -341,29 +294,8 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5dcb5e64cda4c23119ab41ba960d1e170a774c8e4b9d9e6a9bc18aabf5e59695"
 dependencies = [
- "crypto-mac 0.7.0",
- "digest 0.8.1",
-]
-
-[[package]]
-name = "hmac"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "126888268dcc288495a26bf004b38c5fdbb31682f992c84ceb046a1f0fe38840"
-dependencies = [
- "crypto-mac 0.8.0",
- "digest 0.9.0",
-]
-
-[[package]]
-name = "hmac-drbg"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17ea0a1394df5b6574da6e0c1ade9e78868c9fb0a4e5ef4428e32da4676b85b1"
-dependencies = [
- "digest 0.9.0",
- "generic-array 0.14.4",
- "hmac 0.8.1",
+ "crypto-mac",
+ "digest",
 ]
 
 [[package]]
@@ -393,55 +325,6 @@ version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8521a1b57e76b1ec69af7599e75e38e7b7fad6610f037db8c79b127201b5d119"
 
-[[package]]
-name = "libsecp256k1"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0452aac8bab02242429380e9b2f94ea20cea2b37e2c1777a1358799bbe97f37"
-dependencies = [
- "arrayref",
- "base64",
- "digest 0.9.0",
- "hmac-drbg",
- "lazy_static",
- "libsecp256k1-core",
- "libsecp256k1-gen-ecmult",
- "libsecp256k1-gen-genmult",
- "rand 0.8.4",
- "serde",
- "sha2 0.9.8",
- "typenum",
-]
-
-[[package]]
-name = "libsecp256k1-core"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5be9b9bb642d8522a44d533eab56c16c738301965504753b03ad1de3425d5451"
-dependencies = [
- "crunchy",
- "digest 0.9.0",
- "subtle 2.2.3",
-]
-
-[[package]]
-name = "libsecp256k1-gen-ecmult"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3038c808c55c87e8a172643a7d87187fc6c4174468159cb3090659d55bcb4809"
-dependencies = [
- "libsecp256k1-core",
-]
-
-[[package]]
-name = "libsecp256k1-gen-genmult"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3db8d6ba2cec9eacc40e6e8ccc98931840301f1006e95647ceb2dd5c3aa06f7c"
-dependencies = [
- "libsecp256k1-core",
-]
-
 [[package]]
 name = "lock_api"
 version = "0.3.4"
@@ -474,7 +357,7 @@ checksum = "c6feca46f4fa3443a01769d768727f10c10a20fdb65e52dc16a81f0c8269bb78"
 dependencies = [
  "byteorder",
  "keccak",
- "rand_core 0.5.1",
+ "rand_core",
  "zeroize",
 ]
 
@@ -514,12 +397,6 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
 
-[[package]]
-name = "opaque-debug"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
-
 [[package]]
 name = "parking_lot"
 version = "0.10.2"
@@ -551,7 +428,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "006c038a43a45995a9670da19e67600114740e8511d4333bf97a56e66a7542d9"
 dependencies = [
  "byteorder",
- "crypto-mac 0.7.0",
+ "crypto-mac",
 ]
 
 [[package]]
@@ -592,22 +469,11 @@ checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
 dependencies = [
  "getrandom 0.1.14",
  "libc",
- "rand_chacha 0.2.2",
- "rand_core 0.5.1",
+ "rand_chacha",
+ "rand_core",
  "rand_hc",
 ]
 
-[[package]]
-name = "rand"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
-dependencies = [
- "libc",
- "rand_chacha 0.3.1",
- "rand_core 0.6.3",
-]
-
 [[package]]
 name = "rand_chacha"
 version = "0.2.2"
@@ -615,17 +481,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
 dependencies = [
  "ppv-lite86",
- "rand_core 0.5.1",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core 0.6.3",
+ "rand_core",
 ]
 
 [[package]]
@@ -637,22 +493,13 @@ dependencies = [
  "getrandom 0.1.14",
 ]
 
-[[package]]
-name = "rand_core"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
-dependencies = [
- "getrandom 0.2.3",
-]
-
 [[package]]
 name = "rand_hc"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
 dependencies = [
- "rand_core 0.5.1",
+ "rand_core",
 ]
 
 [[package]]
@@ -684,9 +531,9 @@ dependencies = [
  "curve25519-dalek",
  "getrandom 0.1.14",
  "merlin",
- "rand 0.7.3",
- "rand_core 0.5.1",
- "sha2 0.8.2",
+ "rand",
+ "rand_core",
+ "sha2",
  "subtle 2.2.3",
  "zeroize",
 ]
@@ -705,9 +552,27 @@ checksum = "656c79d0e90d0ab28ac86bf3c3d10bfbbac91450d3f190113b4e76d9fec3cfdd"
 dependencies = [
  "byte-tools",
  "byteorder",
- "hmac 0.7.1",
+ "hmac",
  "pbkdf2",
- "sha2 0.8.2",
+ "sha2",
+]
+
+[[package]]
+name = "secp256k1"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c42e6f1735c5f00f51e43e28d6634141f2bcad10931b2609ddd74a86d751260"
+dependencies = [
+ "secp256k1-sys",
+]
+
+[[package]]
+name = "secp256k1-sys"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "957da2573cde917463ece3570eab4a0b3f19de6f1646cde62e6fd3868f566036"
+dependencies = [
+ "cc",
 ]
 
 [[package]]
@@ -715,20 +580,6 @@ name = "serde"
 version = "1.0.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5317f7588f0a5078ee60ef675ef96735a1442132dc645eb1d12c018620ed8cd3"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.114"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a0be94b04690fbaed37cddffc5c134bf537c8e3329d53e982fe04c374978f8e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
 
 [[package]]
 name = "sha2"
@@ -736,23 +587,10 @@ version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a256f46ea78a0c0d9ff00077504903ac881a1dafdc20da66545699e7776b3e69"
 dependencies = [
- "block-buffer 0.7.3",
- "digest 0.8.1",
+ "block-buffer",
+ "digest",
  "fake-simd",
- "opaque-debug 0.2.3",
-]
-
-[[package]]
-name = "sha2"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b69f9a4c9740d74c5baa3fd2e547f9525fa8088a8a958e0ca2409a514e33f5fa"
-dependencies = [
- "block-buffer 0.9.0",
- "cfg-if 1.0.0",
- "cpufeatures",
- "digest 0.9.0",
- "opaque-debug 0.3.0",
+ "opaque-debug",
 ]
 
 [[package]]
@@ -809,12 +647,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b0165e045cc2ae1660270ca65e1676dbaab60feb0f91b10f7d0665e9b47e31f2"
 dependencies = [
  "failure",
- "hmac 0.7.1",
+ "hmac",
  "once_cell",
  "pbkdf2",
- "rand 0.7.3",
+ "rand",
  "rustc-hash",
- "sha2 0.8.2",
+ "sha2",
  "unicode-normalization",
 ]
 
@@ -839,7 +677,7 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3bfd5b7557925ce778ff9b9ef90e3ade34c524b5ff10e239c69a42d546d2af56"
 dependencies = [
- "rand 0.7.3",
+ "rand",
 ]
 
 [[package]]
@@ -863,12 +701,6 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"
 
-[[package]]
-name = "version_check"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
-
 [[package]]
 name = "wasi"
 version = "0.9.0+wasi-snapshot-preview1"
@@ -891,14 +723,14 @@ dependencies = [
  "ed25519-dalek",
  "getrandom 0.2.3",
  "hex-literal",
- "hmac 0.7.1",
- "libsecp256k1",
+ "hmac",
  "merlin",
  "pbkdf2",
- "rand 0.7.3",
+ "rand",
  "schnorrkel",
  "scrypt",
- "sha2 0.8.2",
+ "secp256k1",
+ "sha2",
  "tiny-bip39",
  "tiny-keccak",
  "twox-hash",

packages/wasm-crypto/Cargo.toml

@@ -22,7 +22,7 @@ curve25519-dalek = { version = "2.1.0", default-features = false }
 ed25519-dalek = { version = "1.0.0-pre.4", features = [] }
 getrandom = { version="0.2.3", features = ["js"] }
 hmac = "0.7.0"
-libsecp256k1 = { version = "0.7.0", default-features = false, features=["hmac", "lazy-static-context"] }
+secp256k1 = { version = "0.21.2", default-features = false, features = ["recovery", "global-context"] }
 merlin = { version = "2.0", default-features = false }
 pbkdf2 = { version = "0.3.0", default-features = false }
 rand = { version="0.7.3", default-features = false, features = ["wasm-bindgen"] }

packages/wasm-crypto/LICENSE

@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                    http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-  "License" shall mean the terms and conditions for use, reproduction,
-  and distribution as defined by Sections 1 through 9 of this document.
-
-  "Licensor" shall mean the copyright owner or entity authorized by
-  the copyright owner that is granting the License.
-
-  "Legal Entity" shall mean the union of the acting entity and all
-  other entities that control, are controlled by, or are under common
-  control with that entity. For the purposes of this definition,
-  "control" means (i) the power, direct or indirect, to cause the
-  direction or management of such entity, whether by contract or
-  otherwise, or (ii) ownership of fifty percent (50%) or more of the
-  outstanding shares, or (iii) beneficial ownership of such entity.
-
-  "You" (or "Your") shall mean an individual or Legal Entity
-  exercising permissions granted by this License.
-
-  "Source" form shall mean the preferred form for making modifications,
-  including but not limited to software source code, documentation
-  source, and configuration files.
-
-  "Object" form shall mean any form resulting from mechanical
-  transformation or translation of a Source form, including but
-  not limited to compiled object code, generated documentation,
-  and conversions to other media types.
-
-  "Work" shall mean the work of authorship, whether in Source or
-  Object form, made available under the License, as indicated by a
-  copyright notice that is included in or attached to the work
-  (an example is provided in the Appendix below).
-
-  "Derivative Works" shall mean any work, whether in Source or Object
-  form, that is based on (or derived from) the Work and for which the
-  editorial revisions, annotations, elaborations, or other modifications
-  represent, as a whole, an original work of authorship. For the purposes
-  of this License, Derivative Works shall not include works that remain
-  separable from, or merely link (or bind by name) to the interfaces of,
-  the Work and Derivative Works thereof.
-
-  "Contribution" shall mean any work of authorship, including
-  the original version of the Work and any modifications or additions
-  to that Work or Derivative Works thereof, that is intentionally
-  submitted to Licensor for inclusion in the Work by the copyright owner
-  or by an individual or Legal Entity authorized to submit on behalf of
-  the copyright owner. For the purposes of this definition, "submitted"
-  means any form of electronic, verbal, or written communication sent
-  to the Licensor or its representatives, including but not limited to
-  communication on electronic mailing lists, source code control systems,
-  and issue tracking systems that are managed by, or on behalf of, the
-  Licensor for the purpose of discussing and improving the Work, but
-  excluding communication that is conspicuously marked or otherwise
-  designated in writing by the copyright owner as "Not a Contribution."
-
-  "Contributor" shall mean Licensor and any individual or Legal Entity
-  on behalf of whom a Contribution has been received by Licensor and
-  subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-  this License, each Contributor hereby grants to You a perpetual,
-  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-  copyright license to reproduce, prepare Derivative Works of,
-  publicly display, publicly perform, sublicense, and distribute the
-  Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-  this License, each Contributor hereby grants to You a perpetual,
-  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-  (except as stated in this section) patent license to make, have made,
-  use, offer to sell, sell, import, and otherwise transfer the Work,
-  where such license applies only to those patent claims licensable
-  by such Contributor that are necessarily infringed by their
-  Contribution(s) alone or by combination of their Contribution(s)
-  with the Work to which such Contribution(s) was submitted. If You
-  institute patent litigation against any entity (including a
-  cross-claim or counterclaim in a lawsuit) alleging that the Work
-  or a Contribution incorporated within the Work constitutes direct
-  or contributory patent infringement, then any patent licenses
-  granted to You under this License for that Work shall terminate
-  as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-  Work or Derivative Works thereof in any medium, with or without
-  modifications, and in Source or Object form, provided that You
-  meet the following conditions:
-
-  (a) You must give any other recipients of the Work or
-      Derivative Works a copy of this License; and
-
-  (b) You must cause any modified files to carry prominent notices
-      stating that You changed the files; and
-
-  (c) You must retain, in the Source form of any Derivative Works
-      that You distribute, all copyright, patent, trademark, and
-      attribution notices from the Source form of the Work,
-      excluding those notices that do not pertain to any part of
-      the Derivative Works; and
-
-  (d) If the Work includes a "NOTICE" text file as part of its
-      distribution, then any Derivative Works that You distribute must
-      include a readable copy of the attribution notices contained
-      within such NOTICE file, excluding those notices that do not
-      pertain to any part of the Derivative Works, in at least one
-      of the following places: within a NOTICE text file distributed
-      as part of the Derivative Works; within the Source form or
-      documentation, if provided along with the Derivative Works; or,
-      within a display generated by the Derivative Works, if and
-      wherever such third-party notices normally appear. The contents
-      of the NOTICE file are for informational purposes only and
-      do not modify the License. You may add Your own attribution
-      notices within Derivative Works that You distribute, alongside
-      or as an addendum to the NOTICE text from the Work, provided
-      that such additional attribution notices cannot be construed
-      as modifying the License.
-
-  You may add Your own copyright statement to Your modifications and
-  may provide additional or different license terms and conditions
-  for use, reproduction, or distribution of Your modifications, or
-  for any such Derivative Works as a whole, provided Your use,
-  reproduction, and distribution of the Work otherwise complies with
-  the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-  any Contribution intentionally submitted for inclusion in the Work
-  by You to the Licensor shall be under the terms and conditions of
-  this License, without any additional terms or conditions.
-  Notwithstanding the above, nothing herein shall supersede or modify
-  the terms of any separate license agreement you may have executed
-  with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-  names, trademarks, service marks, or product names of the Licensor,
-  except as required for reasonable and customary use in describing the
-  origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-  agreed to in writing, Licensor provides the Work (and each
-  Contributor provides its Contributions) on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-  implied, including, without limitation, any warranties or conditions
-  of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-  PARTICULAR PURPOSE. You are solely responsible for determining the
-  appropriateness of using or redistributing the Work and assume any
-  risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-  whether in tort (including negligence), contract, or otherwise,
-  unless required by applicable law (such as deliberate and grossly
-  negligent acts) or agreed to in writing, shall any Contributor be
-  liable to You for damages, including any direct, indirect, special,
-  incidental, or consequential damages of any character arising as a
-  result of this License or out of the use or inability to use the
-  Work (including but not limited to damages for loss of goodwill,
-  work stoppage, computer failure or malfunction, or any and all
-  other commercial damages or losses), even if such Contributor
-  has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-  the Work or Derivative Works thereof, You may choose to offer,
-  and charge a fee for, acceptance of support, warranty, indemnity,
-  or other liability obligations and/or rights consistent with this
-  License. However, in accepting such obligations, You may act only
-  on Your own behalf and on Your sole responsibility, not on behalf
-  of any other Contributor, and only if You agree to indemnify,
-  defend, and hold each Contributor harmless for any liability
-  incurred by, or claims asserted against, such Contributor by reason
-  of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-  To apply the Apache License to your work, attach the following
-  boilerplate notice, with the fields enclosed by brackets "[]"
-  replaced with your own identifying information. (Don't include
-  the brackets!)  The text should be enclosed in the appropriate
-  comment syntax for the file format. We also recommend that a
-  file or class name and description of purpose be included on the
-  same "printed page" as the copyright notice for easier
-  identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

packages/wasm-crypto/README.md

@@ -11,21 +11,19 @@ Install the package (also requires `@polkadot/util` for `TextEncoder` polyfills
 Use it -
 
 ```js
-const { u8aToHex } = require('@polkadot/util');
-const { bip39Generate, bip39ToSeed, waitReady } = require('@polkadot/wasm-crypto');
+import { u8aToHex } from '@polkadot/util';
+import { bip39Generate, bip39ToSeed, waitReady } from '@polkadot/wasm-crypto';
 
-async function main () {
-  // first wait until the WASM has been loaded (async init)
-  await waitReady();
+// first wait until the WASM has been loaded (async init)
+await waitReady();
 
-  // generate phrase
-  const phrase = bip39Generate(12);
+// generate phrase
+const phrase = bip39Generate(12);
 
-  // get ed25519 seed from phrase
-  const seed = bip39ToSeed(phrase, '');
+// get ed25519 seed from phrase
+const seed = bip39ToSeed(phrase, '');
 
-  // display
-  console.log('phrase:', phrase);
-  console.log('seed:', u8aToHex(seed));
-}
+// display
+console.log('phrase:', phrase);
+console.log('seed:', u8aToHex(seed));
 ```

packages/wasm-crypto/package.json

@@ -18,6 +18,8 @@
   "sideEffects": [
     "./detectPackage.js",
     "./detectPackage.cjs",
+    "./initNone.js",
+    "./initNone.cjs",
     "./initOnlyAsm.js",
     "./initOnlyAsm.cjs",
     "./initOnlyWasm.js",
@@ -26,16 +28,19 @@
     "./initWasmAsm.cjs"
   ],
   "type": "module",
-  "version": "5.0.1",
+  "version": "7.0.1",
   "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.17.8",
-    "@polkadot/wasm-crypto-asmjs": "^5.0.1",
-    "@polkadot/wasm-crypto-wasm": "^5.0.1"
+    "@polkadot/wasm-bridge": "7.0.1",
+    "@polkadot/wasm-crypto-asmjs": "7.0.1",
+    "@polkadot/wasm-crypto-init": "7.0.1",
+    "@polkadot/wasm-crypto-wasm": "7.0.1",
+    "@polkadot/wasm-util": "7.0.1",
+    "tslib": "^2.5.0"
   },
   "devDependencies": {
-    "@polkadot/util": "^8.5.1",
-    "@polkadot/x-randomvalues": "^8.5.1"
+    "@polkadot/util": "^10.4.2",
+    "@polkadot/x-randomvalues": "^10.4.2"
   },
   "peerDependencies": {
     "@polkadot/util": "*",

packages/wasm-crypto/src/bridge.ts

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

packages/wasm-crypto/src/bundle.ts

@@ -1,222 +1,247 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { __bridge, allocString, allocU8a, getWasm, resultString, resultU8a, withWasm } from './bridge';
-import { setWasmOnlyPromise } from './init';
+import type { WasmCryptoInstance } from '@polkadot/wasm-crypto-init/types';
+
+import { bridge, initBridge } from './init';
 
 export { packageInfo } from './packageInfo';
+export { bridge };
 
-export const bip39Generate = withWasm((wasm, words: 12 | 15 | 18 | 21 | 24): string => {
+// Removes the first parameter (expected as WasmCryptoInstance) and leaves the
+// rest of the parameters in-tack. This allows us to dynamically create a function
+// return from the withWasm helper
+type PopFirst<T extends unknown[]> =
+  T extends [WasmCryptoInstance, ...infer N]
+    ? N
+    : [];
+
+/**
+ * @internal
+ * @description
+ * This create an extenal interface function from the signature, all the while checking
+ * the actual bridge wasm interface to ensure it has been initialized.
+ *
+ * This means that we can call it
+ *
+ *   withWasm(wasm: WasmCryptoInstance, a: number, b: string) => Uint8Array
+ *
+ * and in this case it will create an interface function with the signarure
+ *
+ *   (a: number, b: string) => Uint8Array
+ */
+function withWasm <T, F extends (wasm: WasmCryptoInstance, ...params: never[]) => T> (fn: F): (...params: PopFirst<Parameters<F>>) => ReturnType<F> {
+  return (...params: PopFirst<Parameters<F>>): ReturnType<F> => {
+    if (!bridge.wasm) {
+      throw new Error('The WASM interface has not been initialized. Ensure that you wait for the initialization Promise with waitReady() from @polkadot/wasm-crypto (or cryptoWaitReady() from @polkadot/util-crypto) before attempting to use WASM-only interfaces.');
+    }
+
+    return fn(bridge.wasm, ...params) as ReturnType<F>;
+  };
+}
+
+export const bip39Generate = /*#__PURE__*/ withWasm((wasm, words: 12 | 15 | 18 | 21 | 24): string => {
   wasm.ext_bip39_generate(8, words);
 
-  return resultString();
+  return bridge.resultString();
 });
 
-export const bip39ToEntropy = withWasm((wasm, phrase: string): Uint8Array => {
-  wasm.ext_bip39_to_entropy(8, ...allocString(phrase));
+export const bip39ToEntropy = /*#__PURE__*/ withWasm((wasm, phrase: string): Uint8Array => {
+  wasm.ext_bip39_to_entropy(8, ...bridge.allocString(phrase));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const bip39ToMiniSecret = withWasm((wasm, phrase: string, password: string): Uint8Array => {
-  wasm.ext_bip39_to_mini_secret(8, ...allocString(phrase), ...allocString(password));
+export const bip39ToMiniSecret = /*#__PURE__*/ withWasm((wasm, phrase: string, password: string): Uint8Array => {
+  wasm.ext_bip39_to_mini_secret(8, ...bridge.allocString(phrase), ...bridge.allocString(password));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const bip39ToSeed = withWasm((wasm, phrase: string, password: string): Uint8Array => {
-  wasm.ext_bip39_to_seed(8, ...allocString(phrase), ...allocString(password));
+export const bip39ToSeed = /*#__PURE__*/ withWasm((wasm, phrase: string, password: string): Uint8Array => {
+  wasm.ext_bip39_to_seed(8, ...bridge.allocString(phrase), ...bridge.allocString(password));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const bip39Validate = withWasm((wasm, phrase: string): boolean => {
-  const ret = wasm.ext_bip39_validate(...allocString(phrase));
+export const bip39Validate = /*#__PURE__*/ withWasm((wasm, phrase: string): boolean => {
+  const ret = wasm.ext_bip39_validate(...bridge.allocString(phrase));
 
   return ret !== 0;
 });
 
-export const ed25519KeypairFromSeed = withWasm((wasm, seed: Uint8Array): Uint8Array => {
-  wasm.ext_ed_from_seed(8, ...allocU8a(seed));
+export const ed25519KeypairFromSeed = /*#__PURE__*/ withWasm((wasm, seed: Uint8Array): Uint8Array => {
+  wasm.ext_ed_from_seed(8, ...bridge.allocU8a(seed));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const ed25519Sign = withWasm((wasm, pubkey: Uint8Array, seckey: Uint8Array, message: Uint8Array): Uint8Array => {
-  wasm.ext_ed_sign(8, ...allocU8a(pubkey), ...allocU8a(seckey), ...allocU8a(message));
+export const ed25519Sign = /*#__PURE__*/ withWasm((wasm, pubkey: Uint8Array, seckey: Uint8Array, message: Uint8Array): Uint8Array => {
+  wasm.ext_ed_sign(8, ...bridge.allocU8a(pubkey), ...bridge.allocU8a(seckey), ...bridge.allocU8a(message));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const ed25519Verify = withWasm((wasm, signature: Uint8Array, message: Uint8Array, pubkey: Uint8Array): boolean => {
-  const ret = wasm.ext_ed_verify(...allocU8a(signature), ...allocU8a(message), ...allocU8a(pubkey));
+export const ed25519Verify = /*#__PURE__*/ withWasm((wasm, signature: Uint8Array, message: Uint8Array, pubkey: Uint8Array): boolean => {
+  const ret = wasm.ext_ed_verify(...bridge.allocU8a(signature), ...bridge.allocU8a(message), ...bridge.allocU8a(pubkey));
 
   return ret !== 0;
 });
 
-let secpLazyInit = false;
+export const secp256k1FromSeed = /*#__PURE__*/ withWasm((wasm, seckey: Uint8Array): Uint8Array => {
+  wasm.ext_secp_from_seed(8, ...bridge.allocU8a(seckey));
 
-export const secp256k1FromSeed = withWasm((wasm, seckey: Uint8Array): Uint8Array => {
-  // HACK In an asm.js environment, the static initialization seems to trip up the
-  // first usage of the keypair generation
-  // https://github.com/polkadot-js/wasm/issues/307
-  if (!secpLazyInit && __bridge.type === 'asm') {
-    wasm.ext_secp_from_seed(8, ...allocU8a(seckey));
-    resultU8a();
-  }
-
-  secpLazyInit = true;
-  wasm.ext_secp_from_seed(8, ...allocU8a(seckey));
-
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const secp256k1Compress = withWasm((wasm, pubkey: Uint8Array): Uint8Array => {
-  wasm.ext_secp_pub_compress(8, ...allocU8a(pubkey));
+export const secp256k1Compress = /*#__PURE__*/ withWasm((wasm, pubkey: Uint8Array): Uint8Array => {
+  wasm.ext_secp_pub_compress(8, ...bridge.allocU8a(pubkey));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const secp256k1Expand = withWasm((wasm, pubkey: Uint8Array): Uint8Array => {
-  wasm.ext_secp_pub_expand(8, ...allocU8a(pubkey));
+export const secp256k1Expand = /*#__PURE__*/ withWasm((wasm, pubkey: Uint8Array): Uint8Array => {
+  wasm.ext_secp_pub_expand(8, ...bridge.allocU8a(pubkey));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const secp256k1Recover = withWasm((wasm, msgHash: Uint8Array, sig: Uint8Array, recovery: number): Uint8Array => {
-  wasm.ext_secp_recover(8, ...allocU8a(msgHash), ...allocU8a(sig), recovery);
+export const secp256k1Recover = /*#__PURE__*/ withWasm((wasm, msgHash: Uint8Array, sig: Uint8Array, recovery: number): Uint8Array => {
+  wasm.ext_secp_recover(8, ...bridge.allocU8a(msgHash), ...bridge.allocU8a(sig), recovery);
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const secp256k1Sign = withWasm((wasm, msgHash: Uint8Array, seckey: Uint8Array): Uint8Array => {
-  wasm.ext_secp_sign(8, ...allocU8a(msgHash), ...allocU8a(seckey));
+export const secp256k1Sign = /*#__PURE__*/ withWasm((wasm, msgHash: Uint8Array, seckey: Uint8Array): Uint8Array => {
+  wasm.ext_secp_sign(8, ...bridge.allocU8a(msgHash), ...bridge.allocU8a(seckey));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const sr25519DeriveKeypairHard = withWasm((wasm, pair: Uint8Array, cc: Uint8Array): Uint8Array => {
-  wasm.ext_sr_derive_keypair_hard(8, ...allocU8a(pair), ...allocU8a(cc));
+export const sr25519DeriveKeypairHard = /*#__PURE__*/ withWasm((wasm, pair: Uint8Array, cc: Uint8Array): Uint8Array => {
+  wasm.ext_sr_derive_keypair_hard(8, ...bridge.allocU8a(pair), ...bridge.allocU8a(cc));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const sr25519DeriveKeypairSoft = withWasm((wasm, pair: Uint8Array, cc: Uint8Array): Uint8Array => {
-  wasm.ext_sr_derive_keypair_soft(8, ...allocU8a(pair), ...allocU8a(cc));
+export const sr25519DeriveKeypairSoft = /*#__PURE__*/ withWasm((wasm, pair: Uint8Array, cc: Uint8Array): Uint8Array => {
+  wasm.ext_sr_derive_keypair_soft(8, ...bridge.allocU8a(pair), ...bridge.allocU8a(cc));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const sr25519DerivePublicSoft = withWasm((wasm, pubkey: Uint8Array, cc: Uint8Array): Uint8Array => {
-  wasm.ext_sr_derive_public_soft(8, ...allocU8a(pubkey), ...allocU8a(cc));
+export const sr25519DerivePublicSoft = /*#__PURE__*/ withWasm((wasm, pubkey: Uint8Array, cc: Uint8Array): Uint8Array => {
+  wasm.ext_sr_derive_public_soft(8, ...bridge.allocU8a(pubkey), ...bridge.allocU8a(cc));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const sr25519KeypairFromSeed = withWasm((wasm, seed: Uint8Array): Uint8Array => {
-  wasm.ext_sr_from_seed(8, ...allocU8a(seed));
+export const sr25519KeypairFromSeed = /*#__PURE__*/ withWasm((wasm, seed: Uint8Array): Uint8Array => {
+  wasm.ext_sr_from_seed(8, ...bridge.allocU8a(seed));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const sr25519Sign = withWasm((wasm, pubkey: Uint8Array, secret: Uint8Array, message: Uint8Array): Uint8Array => {
-  wasm.ext_sr_sign(8, ...allocU8a(pubkey), ...allocU8a(secret), ...allocU8a(message));
+export const sr25519Sign = /*#__PURE__*/ withWasm((wasm, pubkey: Uint8Array, secret: Uint8Array, message: Uint8Array): Uint8Array => {
+  wasm.ext_sr_sign(8, ...bridge.allocU8a(pubkey), ...bridge.allocU8a(secret), ...bridge.allocU8a(message));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const sr25519Verify = withWasm((wasm, signature: Uint8Array, message: Uint8Array, pubkey: Uint8Array): boolean => {
-  const ret = wasm.ext_sr_verify(...allocU8a(signature), ...allocU8a(message), ...allocU8a(pubkey));
+export const sr25519Verify = /*#__PURE__*/ withWasm((wasm, signature: Uint8Array, message: Uint8Array, pubkey: Uint8Array): boolean => {
+  const ret = wasm.ext_sr_verify(...bridge.allocU8a(signature), ...bridge.allocU8a(message), ...bridge.allocU8a(pubkey));
 
   return ret !== 0;
 });
 
-export const sr25519Agree = withWasm((wasm, pubkey: Uint8Array, secret: Uint8Array): Uint8Array => {
-  wasm.ext_sr_agree(8, ...allocU8a(pubkey), ...allocU8a(secret));
+export const sr25519Agree = /*#__PURE__*/ withWasm((wasm, pubkey: Uint8Array, secret: Uint8Array): Uint8Array => {
+  wasm.ext_sr_agree(8, ...bridge.allocU8a(pubkey), ...bridge.allocU8a(secret));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const vrfSign = withWasm((wasm, secret: Uint8Array, context: Uint8Array, message: Uint8Array, extra: Uint8Array): Uint8Array => {
-  wasm.ext_vrf_sign(8, ...allocU8a(secret), ...allocU8a(context), ...allocU8a(message), ...allocU8a(extra));
+export const vrfSign = /*#__PURE__*/ withWasm((wasm, secret: Uint8Array, context: Uint8Array, message: Uint8Array, extra: Uint8Array): Uint8Array => {
+  wasm.ext_vrf_sign(8, ...bridge.allocU8a(secret), ...bridge.allocU8a(context), ...bridge.allocU8a(message), ...bridge.allocU8a(extra));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const vrfVerify = withWasm((wasm, pubkey: Uint8Array, context: Uint8Array, message: Uint8Array, extra: Uint8Array, outAndProof: Uint8Array): boolean => {
-  const ret = wasm.ext_vrf_verify(...allocU8a(pubkey), ...allocU8a(context), ...allocU8a(message), ...allocU8a(extra), ...allocU8a(outAndProof));
+export const vrfVerify = /*#__PURE__*/ withWasm((wasm, pubkey: Uint8Array, context: Uint8Array, message: Uint8Array, extra: Uint8Array, outAndProof: Uint8Array): boolean => {
+  const ret = wasm.ext_vrf_verify(...bridge.allocU8a(pubkey), ...bridge.allocU8a(context), ...bridge.allocU8a(message), ...bridge.allocU8a(extra), ...bridge.allocU8a(outAndProof));
 
   return ret !== 0;
 });
 
-export const blake2b = withWasm((wasm, data: Uint8Array, key: Uint8Array, size: number): Uint8Array => {
-  wasm.ext_blake2b(8, ...allocU8a(data), ...allocU8a(key), size);
+export const blake2b = /*#__PURE__*/ withWasm((wasm, data: Uint8Array, key: Uint8Array, size: number): Uint8Array => {
+  wasm.ext_blake2b(8, ...bridge.allocU8a(data), ...bridge.allocU8a(key), size);
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const hmacSha256 = withWasm((wasm, key: Uint8Array, data: Uint8Array): Uint8Array => {
-  wasm.ext_hmac_sha256(8, ...allocU8a(key), ...allocU8a(data));
+export const hmacSha256 = /*#__PURE__*/ withWasm((wasm, key: Uint8Array, data: Uint8Array): Uint8Array => {
+  wasm.ext_hmac_sha256(8, ...bridge.allocU8a(key), ...bridge.allocU8a(data));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const hmacSha512 = withWasm((wasm, key: Uint8Array, data: Uint8Array): Uint8Array => {
-  wasm.ext_hmac_sha512(8, ...allocU8a(key), ...allocU8a(data));
+export const hmacSha512 = /*#__PURE__*/ withWasm((wasm, key: Uint8Array, data: Uint8Array): Uint8Array => {
+  wasm.ext_hmac_sha512(8, ...bridge.allocU8a(key), ...bridge.allocU8a(data));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const keccak256 = withWasm((wasm, data: Uint8Array): Uint8Array => {
-  wasm.ext_keccak256(8, ...allocU8a(data));
+export const keccak256 = /*#__PURE__*/ withWasm((wasm, data: Uint8Array): Uint8Array => {
+  wasm.ext_keccak256(8, ...bridge.allocU8a(data));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const keccak512 = withWasm((wasm, data: Uint8Array): Uint8Array => {
-  wasm.ext_keccak512(8, ...allocU8a(data));
+export const keccak512 = /*#__PURE__*/ withWasm((wasm, data: Uint8Array): Uint8Array => {
+  wasm.ext_keccak512(8, ...bridge.allocU8a(data));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const pbkdf2 = withWasm((wasm, data: Uint8Array, salt: Uint8Array, rounds: number): Uint8Array => {
-  wasm.ext_pbkdf2(8, ...allocU8a(data), ...allocU8a(salt), rounds);
+export const pbkdf2 = /*#__PURE__*/ withWasm((wasm, data: Uint8Array, salt: Uint8Array, rounds: number): Uint8Array => {
+  wasm.ext_pbkdf2(8, ...bridge.allocU8a(data), ...bridge.allocU8a(salt), rounds);
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const scrypt = withWasm((wasm, password: Uint8Array, salt: Uint8Array, log2n: number, r: number, p: number): Uint8Array => {
-  wasm.ext_scrypt(8, ...allocU8a(password), ...allocU8a(salt), log2n, r, p);
+export const scrypt = /*#__PURE__*/ withWasm((wasm, password: Uint8Array, salt: Uint8Array, log2n: number, r: number, p: number): Uint8Array => {
+  wasm.ext_scrypt(8, ...bridge.allocU8a(password), ...bridge.allocU8a(salt), log2n, r, p);
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const sha256 = withWasm((wasm, data: Uint8Array): Uint8Array => {
-  wasm.ext_sha256(8, ...allocU8a(data));
+export const sha256 = /*#__PURE__*/ withWasm((wasm, data: Uint8Array): Uint8Array => {
+  wasm.ext_sha256(8, ...bridge.allocU8a(data));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const sha512 = withWasm((wasm, data: Uint8Array): Uint8Array => {
-  wasm.ext_sha512(8, ...allocU8a(data));
+export const sha512 = /*#__PURE__*/ withWasm((wasm, data: Uint8Array): Uint8Array => {
+  wasm.ext_sha512(8, ...bridge.allocU8a(data));
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
-export const twox = withWasm((wasm, data: Uint8Array, rounds: number) => {
-  wasm.ext_twox(8, ...allocU8a(data), rounds);
+export const twox = /*#__PURE__*/ withWasm((wasm, data: Uint8Array, rounds: number) => {
+  wasm.ext_twox(8, ...bridge.allocU8a(data), rounds);
 
-  return resultU8a();
+  return bridge.resultU8a();
 });
 
 export function isReady (): boolean {
-  return !!getWasm();
+  return !!bridge.wasm;
 }
 
-export function waitReady (): Promise<boolean> {
-  return (
-    __bridge.wasmPromise || setWasmOnlyPromise()
-  )
-    .then(() => isReady())
-    .catch(() => false);
+export async function waitReady (): Promise<boolean> {
+  try {
+    const wasm = await initBridge();
+
+    return !!wasm;
+  } catch {
+    return false;
+  }
 }

packages/wasm-crypto/src/detectOther.ts

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

packages/wasm-crypto/src/detectPackage.ts

@@ -1,4 +1,4 @@
-// Copyright 2017-2022 @polkadot/wasm-crypto authors & contributors
+// Copyright 2017-2023 @polkadot/wasm-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 // Do not edit, auto-generated by @polkadot/dev

packages/wasm-crypto/src/imports.ts

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

packages/wasm-crypto/src/index.ts

@@ -1,4 +1,4 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import './detectPackage';

packages/wasm-crypto/src/init.ts

@@ -1,41 +1,25 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { AsmCreator, WasmCryptoInstance } from './types';
+import type { InitFn } from '@polkadot/wasm-bridge/types';
+import type { WasmCryptoInstance } from '@polkadot/wasm-crypto-init/types';
 
-import { assert } from '@polkadot/util';
-import { wasmBytes } from '@polkadot/wasm-crypto-wasm';
+import { Bridge } from '@polkadot/wasm-bridge';
+import { createWasm } from '@polkadot/wasm-crypto-init';
 
-import { __bridge } from './bridge';
-import * as imports from './imports';
+/**
+ * @name bridge
+ * @description
+ * The JS <-> WASM bridge that is in operation. For the specific package
+ * it is a global, i.e. all operations happens on this specific bridge
+ */
+export const bridge = new Bridge<WasmCryptoInstance>(createWasm);
 
-async function createPromise (wasmBytes: Uint8Array | null, asmFn: AsmCreator | null): Promise<void> {
-  try {
-    assert(typeof WebAssembly !== 'undefined' && wasmBytes && wasmBytes.length, 'WebAssembly is not available in your environment');
-
-    const source = await WebAssembly.instantiate(wasmBytes, { wbg: imports });
-
-    __bridge.wasm = source.instance.exports as unknown as WasmCryptoInstance;
-  } catch (error) {
-    // if we have a valid supplied asm.js, return that
-    if (asmFn) {
-      __bridge.type = 'asm';
-      __bridge.wasm = asmFn(imports);
-    } else {
-      console.error('FATAL: Unable to initialize @polkadot/wasm-crypto');
-      console.error(error);
-
-      __bridge.wasm = null;
-    }
-  }
-}
-
-export function setPromise (wasmBytes: Uint8Array | null, asmFn: AsmCreator | null): Promise<void> {
-  __bridge.wasmPromise = createPromise(wasmBytes, asmFn);
-
-  return __bridge.wasmPromise;
-}
-
-export function setWasmOnlyPromise (): Promise<void> {
-  return setPromise(wasmBytes, null);
+/**
+ * @name initBridge
+ * @description
+ * Creates a new bridge interface with the (optional) initialization function
+ */
+export async function initBridge (createWasm?: InitFn<WasmCryptoInstance>): Promise<WasmCryptoInstance | null> {
+  return bridge.init(createWasm);
 }

packages/wasm-crypto/src/initNone.ts

@@ -0,0 +1,23 @@
+// Copyright 2019-2023 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { createWasm } from '@polkadot/wasm-crypto-init/none';
+
+import { initBridge } from './init';
+
+/**
+ * @name initWasm
+ * @description
+ * For historic purposes and for tighter control on init, specifically performing
+ * a WASM initialization with no interface whatsoever (no WASM, no ASM.js)
+ *
+ * Generally should not be used unless you want explicit control over which
+ * interfaces are initialized.
+ */
+export async function initWasm (): Promise<void> {
+  await initBridge(createWasm);
+}
+
+initWasm().catch((): void => {
+  // cannot happen, initWasm doesn't throw
+});

packages/wasm-crypto/src/initOnlyAsm.ts

@@ -1,8 +1,23 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { asmJsInit } from '@polkadot/wasm-crypto-asmjs';
+import { createWasm } from '@polkadot/wasm-crypto-init/asm';
 
-import { setPromise } from './init';
+import { initBridge } from './init';
 
-setPromise(null, asmJsInit).catch(() => undefined);
+/**
+ * @name initWasm
+ * @description
+ * For historic purposes and for tighter control on init, specifically performing
+ * a WASM initialization with only ASM.js
+ *
+ * Generally should not be used unless you want explicit control over which
+ * interfaces are initialized.
+ */
+export async function initWasm (): Promise<void> {
+  await initBridge(createWasm);
+}
+
+initWasm().catch((): void => {
+  // cannot happen, initWasm doesn't throw
+});

packages/wasm-crypto/src/initOnlyWasm.ts

@@ -1,6 +1,23 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { setWasmOnlyPromise } from './init';
+import { createWasm } from '@polkadot/wasm-crypto-init/wasm';
 
-setWasmOnlyPromise().catch(() => undefined);
+import { initBridge } from './init';
+
+/**
+ * @name initWasm
+ * @description
+ * For historic purposes and for tighter control on init, specifically performing
+ * a WASM initialization with only WASM (generally the default for most platforms)
+ *
+ * Generally should not be used unless you want explicit control over which
+ * interfaces are initialized.
+ */
+export async function initWasm (): Promise<void> {
+  await initBridge(createWasm);
+}
+
+initWasm().catch((): void => {
+  // cannot happen, initWasm doesn't throw
+});

packages/wasm-crypto/src/initWasmAsm.ts

@@ -1,9 +1,23 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { asmJsInit } from '@polkadot/wasm-crypto-asmjs';
-import { wasmBytes } from '@polkadot/wasm-crypto-wasm';
+import { createWasm } from '@polkadot/wasm-crypto-init/both';
 
-import { setPromise } from './init';
+import { initBridge } from './init';
 
-setPromise(wasmBytes, asmJsInit).catch(() => undefined);
+/**
+ * @name initWasm
+ * @description
+ * For historic purposes and for tighter control on init, specifically performing
+ * a WASM initialization with ASM and an ASM.js fallback
+ *
+ * Generally should not be used unless you want explicit control over which
+ * interfaces are initialized.
+ */
+export async function initWasm (): Promise<void> {
+  await initBridge(createWasm);
+}
+
+initWasm().catch((): void => {
+  // cannot happen, initWasm doesn't throw
+});

packages/wasm-crypto/src/lib.rs

@@ -1,4 +1,4 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 // Use `wee_alloc` as the global allocator.

packages/wasm-crypto/src/mod.ts

@@ -0,0 +1,4 @@
+// Copyright 2019-2023 @polkadot/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index';

packages/wasm-crypto/src/packageInfo.ts

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

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

@@ -1,4 +1,4 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 use bip39::{Mnemonic, MnemonicType, Language, Seed};

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

@@ -1,4 +1,4 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 use std::convert::TryFrom;
@@ -6,15 +6,14 @@ use ed25519_dalek::{Keypair, PublicKey, SecretKey, Signature, Signer as _, Verif
 use wasm_bindgen::prelude::*;
 
 /// Keypair helper function
-fn new_from_parts(pubkey: &[u8], seckey: &[u8]) -> Keypair {
-	let mut pair = vec![];
+fn new_from_seed(seed: &[u8]) -> Keypair {
+	match SecretKey::from_bytes(seed) {
+		Ok(secret) => {
+			let public: PublicKey = (&secret).into();
 
-	pair.extend_from_slice(seckey);
-	pair.extend_from_slice(pubkey);
-
-	match Keypair::from_bytes(&pair) {
-		Ok(p) => p,
-		_ => panic!("Provided pair is invalid.")
+			Keypair { secret: secret, public: public }
+		},
+		_ => panic!("Invalid seed provided.")
 	}
 }
 
@@ -22,20 +21,13 @@ fn new_from_parts(pubkey: &[u8], seckey: &[u8]) -> Keypair {
 ///
 /// * seed: UIntArray with 32 element
 ///
-/// returned vector is the concatenation of first the private key (64 bytes)
-/// followed by the public key (32) bytes.
+/// returned vector is the concatenation of first the seed (32 bytes)
+/// followed by the public key (32) bytes, as the full secret keys.
 #[wasm_bindgen]
 pub fn ext_ed_from_seed(seed: &[u8]) -> Vec<u8> {
-	match &SecretKey::from_bytes(seed) {
-		Ok(s) => {
-			let pubkey: PublicKey = s.into();
-
-			new_from_parts(pubkey.as_bytes(), seed)
-				.to_bytes()
-				.to_vec()
-		},
-		_ => panic!("Invalid seed provided.")
-	}
+	new_from_seed(seed)
+		.to_bytes()
+		.to_vec()
 }
 
 /// Sign a message
@@ -43,14 +35,16 @@ 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.
 ///
-/// * pubkey: UIntArray with 32 element
+/// * _: UIntArray with 32 element (was pubkey, now ignored)
 /// * 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(pubkey: &[u8], seckey: &[u8], message: &[u8]) -> Vec<u8> {
-	new_from_parts(pubkey, seckey)
+pub fn ext_ed_sign(_: &[u8], seckey: &[u8], message: &[u8]) -> Vec<u8> {
+	// https://github.com/MystenLabs/ed25519-unsafe-libs
+	// we never use the provided pubkey
+	new_from_seed(seckey)
 		.sign(message)
 		.to_bytes()
 		.to_vec()

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

@@ -1,4 +1,4 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 use blake2_rfc::blake2b::blake2b;

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

@@ -1,22 +1,12 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-use libsecp256k1::{Message, PublicKey, RecoveryId, SecretKey, Signature, recover, sign};
+use secp256k1::{ecdsa::{RecoverableSignature, RecoveryId}, Message, PublicKey, SecretKey, SECP256K1};
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
 pub fn ext_secp_pub_compress(pubkey: &[u8]) -> Vec<u8> {
-	match PublicKey::parse_slice(&pubkey, None) {
-		Ok(p) => p
-			.serialize_compressed()
-			.to_vec(),
-		_ => panic!("Invalid pubkey provided.")
-	}
-}
-
-#[wasm_bindgen]
-pub fn ext_secp_pub_expand(pubkey: &[u8]) -> Vec<u8> {
-	match PublicKey::parse_slice(&pubkey, None) {
+	match PublicKey::from_slice(&pubkey) {
 		Ok(p) => p
 			.serialize()
 			.to_vec(),
@@ -24,15 +14,25 @@ pub fn ext_secp_pub_expand(pubkey: &[u8]) -> Vec<u8> {
 	}
 }
 
+#[wasm_bindgen]
+pub fn ext_secp_pub_expand(pubkey: &[u8]) -> Vec<u8> {
+	match PublicKey::from_slice(&pubkey) {
+		Ok(p) => p
+			.serialize_uncompressed()
+			.to_vec(),
+		_ => panic!("Invalid pubkey provided.")
+	}
+}
+
 #[wasm_bindgen]
 pub fn ext_secp_from_seed(seed: &[u8]) -> Vec<u8> {
-	match SecretKey::parse_slice(seed) {
+	match SecretKey::from_slice(seed) {
 		Ok(s) => {
 			let mut res = vec![];
-			let pubkey = PublicKey::from_secret_key(&s);
+			let pubkey = PublicKey::from_secret_key(SECP256K1, &s);
 
-			res.extend_from_slice(&s.serialize());
-			res.extend_from_slice(&pubkey.serialize_compressed());
+			res.extend_from_slice(&s.serialize_secret());
+			res.extend_from_slice(&pubkey.serialize());
 
 			res
 		},
@@ -41,28 +41,32 @@ pub fn ext_secp_from_seed(seed: &[u8]) -> Vec<u8> {
 }
 
 #[wasm_bindgen]
-pub fn ext_secp_recover(hash: &[u8], sig: &[u8], rec: u8) -> Vec<u8> {
-	match (Message::parse_slice(hash), Signature::parse_standard_slice(sig), RecoveryId::parse(rec)) {
-		(Ok(m), Ok(s), Ok(r)) =>
-			match recover(&m, &s, &r) {
+pub fn ext_secp_recover(hash: &[u8], sig: &[u8], rec: i32) -> Vec<u8> {
+	match RecoveryId::from_i32(rec) {
+		Ok(r) => match (Message::from_slice(hash), RecoverableSignature::from_compact(&sig, r)) {
+			(Ok(m), Ok(s)) => match s.recover(&m) {
 				Ok(k) => k
-					.serialize_compressed()
+					.serialize()
 					.to_vec(),
-				_ => panic!("Invalid message provided.")
+				_ => panic!("Unable to recover.")
 			},
+			_ => panic!("Invalid signature provided.")
+		},
 		_ => panic!("Invalid recovery data provided.")
 	}
 }
 
 #[wasm_bindgen]
 pub fn ext_secp_sign(hash: &[u8], seckey: &[u8]) -> Vec<u8> {
-	match (Message::parse_slice(hash), SecretKey::parse_slice(seckey)) {
+	match (Message::from_slice(hash), SecretKey::from_slice(seckey)) {
 		(Ok(m), Ok(s)) => {
 			let mut res = vec![];
-			let (sig, rec) = sign(&m, &s);
+			let (rec, sig) = SECP256K1
+				.sign_ecdsa_recoverable(&m, &s)
+				.serialize_compact();
 
-			res.extend_from_slice(&sig.serialize());
-			res.push(rec.into());
+			res.extend_from_slice(&sig);
+			res.push(rec.to_i32() as u8);
 
 			res
 		},

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

@@ -1,4 +1,4 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 // Copyright 2019 Paritytech via https://github.com/paritytech/schnorrkel-js/

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

@@ -1,4 +1,4 @@
-// Copyright 2019-2022 @polkadot/wasm-crypto authors & contributors
+// Copyright 2019-2023 @polkadot/wasm-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 // Copyright 2019 Paritytech via https://github.com/paritytech/schnorrkel-js/