@pezkuwi/wasm-crypto 7.5.7 → 7.5.9

package/Cargo.toml

@@ -0,0 +1,50 @@
+# name & version is only used internally, doesn't need to be adjusted. In the case of
+# name keep it consistent at "wasm" since the scripts (for re-use purposes) expect that
+
+[package]
+authors = ["Jaco Greeff <jacogr@gmail.com>"]
+description = "WASM bindings to Rust crypto libraries."
+edition = "2018"
+license = "Apache-2.0"
+name = "wasm"
+publish = false
+repository = "https://github.com/pezkuwichain/pezkuwi-wasm/"
+resolver = "2"
+version = "0.0.0"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+blake2-rfc = "0.2.18"
+byteorder = "1.3.1"
+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"
+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"] }
+schnorrkel = { version = "0.9.1", features = ["preaudit_deprecated", "u64_backend"] }
+scrypt = { version = "0.2", default-features = false }
+sha2 = "0.8.1"
+tiny-bip39 = { version = "0.7", default-features = false }
+tiny-keccak = { version = "2.0.1", features = ["keccak"] }
+twox-hash = "1.5.0"
+wasm-bindgen = "=0.2.90"
+wee_alloc = "0.4.3"
+
+[dev-dependencies]
+hex-literal = "0.2.0"
+rand = { version = "0.7.3", features = ["wasm-bindgen"] }
+
+[profile.release]
+codegen-units = 1
+debug = false
+debug-assertions = false
+incremental = false
+lto = true
+opt-level = "z"
+panic = "abort"
+rpath = false

package/README.md

@@ -1,18 +1,18 @@
-# @polkadot/wasm-crypto
+# @pezkuwi/wasm-crypto
 
 Wrapper around crypto hashing functions
 
 ## Usage
 
-Install the package (also requires `@polkadot/util` for `TextEncoder` polyfills - not included here as a dependency to keep the tree lean)
+Install the package (also requires `@pezkuwi/util` for `TextEncoder` polyfills - not included here as a dependency to keep the tree lean)
 
-`yarn add @polkadot/wasm-crypto @polkadot/util`
+`yarn add @pezkuwi/wasm-crypto @pezkuwi/util`
 
 Use it -
 
 ```js
-import { u8aToHex } from '@polkadot/util';
-import { bip39Generate, bip39ToSeed, waitReady } from '@polkadot/wasm-crypto';
+import { u8aToHex } from '@pezkuwi/util';
+import { bip39Generate, bip39ToSeed, waitReady } from '@pezkuwi/wasm-crypto';
 
 // first wait until the WASM has been loaded (async init)
 await waitReady();

package/Xargo.toml

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

package/package.json

@@ -1,191 +1,45 @@
 {
-  "author": "Jaco Greeff <jacogr@gmail.com>",
-  "bugs": "https://github.com/pezkuwi-js/wasm/issues",
+  "author": "PezkuwiChain <dev@pezkuwichain.io>",
+  "bugs": "https://github.com/pezkuwichain/pezkuwi-wasm/issues",
   "description": "A wasm interface layer for use by @pezkuwi/util-crypto",
   "engines": {
     "node": ">=18"
   },
-  "homepage": "https://github.com/pezkuwi-js/wasm/tree/master/packages/wasm-crypto#readme",
+  "homepage": "https://github.com/pezkuwichain/pezkuwi-wasm/tree/master/packages/wasm-crypto#readme",
   "license": "Apache-2.0",
   "name": "@pezkuwi/wasm-crypto",
   "repository": {
     "directory": "packages/wasm-crypto",
     "type": "git",
-    "url": "https://github.com/pezkuwi-js/wasm.git"
+    "url": "https://github.com/pezkuwichain/pezkuwi-wasm.git"
   },
   "sideEffects": [
     "./initNone.js",
-    "./cjs/initNone.js",
+    "./initNone.cjs",
     "./initOnlyAsm.js",
-    "./cjs/initOnlyAsm.js",
+    "./initOnlyAsm.cjs",
     "./initOnlyWasm.js",
-    "./cjs/initOnlyWasm.js",
+    "./initOnlyWasm.cjs",
     "./initWasmAsm.js",
-    "./cjs/initWasmAsm.js",
+    "./initWasmAsm.cjs",
     "./packageDetect.js",
-    "./cjs/packageDetect.js"
+    "./packageDetect.cjs"
   ],
   "type": "module",
-  "version": "7.5.7",
-  "main": "./cjs/index.js",
-  "module": "./index.js",
-  "types": "./index.d.ts",
-  "exports": {
-    "./cjs/package.json": "./cjs/package.json",
-    "./cjs/*": "./cjs/*.js",
-    ".": {
-      "module": {
-        "types": "./index.d.ts",
-        "default": "./index.js"
-      },
-      "require": {
-        "types": "./cjs/index.d.ts",
-        "default": "./cjs/index.js"
-      },
-      "default": {
-        "types": "./index.d.ts",
-        "default": "./index.js"
-      }
-    },
-    "./bundle": {
-      "module": {
-        "types": "./bundle.d.ts",
-        "default": "./bundle.js"
-      },
-      "require": {
-        "types": "./cjs/bundle.d.ts",
-        "default": "./cjs/bundle.js"
-      },
-      "default": {
-        "types": "./bundle.d.ts",
-        "default": "./bundle.js"
-      }
-    },
-    "./init": {
-      "module": {
-        "types": "./init.d.ts",
-        "default": "./init.js"
-      },
-      "require": {
-        "types": "./cjs/init.d.ts",
-        "default": "./cjs/init.js"
-      },
-      "default": {
-        "types": "./init.d.ts",
-        "default": "./init.js"
-      }
-    },
-    "./initNone": {
-      "module": {
-        "types": "./initNone.d.ts",
-        "default": "./initNone.js"
-      },
-      "require": {
-        "types": "./cjs/initNone.d.ts",
-        "default": "./cjs/initNone.js"
-      },
-      "default": {
-        "types": "./initNone.d.ts",
-        "default": "./initNone.js"
-      }
-    },
-    "./initOnlyAsm": {
-      "module": {
-        "types": "./initOnlyAsm.d.ts",
-        "default": "./initOnlyAsm.js"
-      },
-      "require": {
-        "types": "./cjs/initOnlyAsm.d.ts",
-        "default": "./cjs/initOnlyAsm.js"
-      },
-      "default": {
-        "types": "./initOnlyAsm.d.ts",
-        "default": "./initOnlyAsm.js"
-      }
-    },
-    "./initOnlyWasm": {
-      "module": {
-        "types": "./initOnlyWasm.d.ts",
-        "default": "./initOnlyWasm.js"
-      },
-      "require": {
-        "types": "./cjs/initOnlyWasm.d.ts",
-        "default": "./cjs/initOnlyWasm.js"
-      },
-      "default": {
-        "types": "./initOnlyWasm.d.ts",
-        "default": "./initOnlyWasm.js"
-      }
-    },
-    "./initWasmAsm": {
-      "module": {
-        "types": "./initWasmAsm.d.ts",
-        "default": "./initWasmAsm.js"
-      },
-      "require": {
-        "types": "./cjs/initWasmAsm.d.ts",
-        "default": "./cjs/initWasmAsm.js"
-      },
-      "default": {
-        "types": "./initWasmAsm.d.ts",
-        "default": "./initWasmAsm.js"
-      }
-    },
-    "./package.json": {
-      "require": "./cjs/package.json",
-      "default": "./package.json"
-    },
-    "./packageDetect": {
-      "module": {
-        "types": "./packageDetect.d.ts",
-        "default": "./packageDetect.js"
-      },
-      "require": {
-        "types": "./cjs/packageDetect.d.ts",
-        "default": "./cjs/packageDetect.js"
-      },
-      "default": {
-        "types": "./packageDetect.d.ts",
-        "default": "./packageDetect.js"
-      }
-    },
-    "./packageInfo.js": {
-      "module": {
-        "types": "./packageInfo.d.ts",
-        "default": "./packageInfo.js"
-      },
-      "require": {
-        "types": "./cjs/packageInfo.d.ts",
-        "default": "./cjs/packageInfo.js"
-      },
-      "default": {
-        "types": "./packageInfo.d.ts",
-        "default": "./packageInfo.js"
-      }
-    },
-    "./packageInfo": {
-      "module": {
-        "types": "./packageInfo.d.ts",
-        "default": "./packageInfo.js"
-      },
-      "require": {
-        "types": "./cjs/packageInfo.d.ts",
-        "default": "./cjs/packageInfo.js"
-      },
-      "default": {
-        "types": "./packageInfo.d.ts",
-        "default": "./packageInfo.js"
-      }
-    }
-  },
+  "version": "7.5.9",
+  "main": "index.js",
   "dependencies": {
-    "@pezkuwi/wasm-bridge": "7.5.7",
-    "@pezkuwi/wasm-crypto-asmjs": "7.5.7",
-    "@pezkuwi/wasm-crypto-init": "7.5.7",
-    "@pezkuwi/wasm-crypto-wasm": "7.5.7",
-    "@pezkuwi/wasm-util": "7.5.7",
+    "@pezkuwi/wasm-bridge": "7.5.9",
+    "@pezkuwi/wasm-crypto-asmjs": "7.5.9",
+    "@pezkuwi/wasm-crypto-init": "7.5.9",
+    "@pezkuwi/wasm-crypto-wasm": "7.5.9",
+    "@pezkuwi/wasm-util": "7.5.9",
     "tslib": "^2.7.0"
   },
+  "devDependencies": {
+    "@pezkuwi/util": "^14.0.1",
+    "@pezkuwi/x-randomvalues": "^14.0.1"
+  },
   "peerDependencies": {
     "@pezkuwi/util": "*",
     "@pezkuwi/x-randomvalues": "*"

package/src/bundle.ts

@@ -0,0 +1,247 @@
+// Copyright 2019-2026 @pezkuwi/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { WasmCryptoInstance } from '@pezkuwi/wasm-crypto-init/types';
+
+import { bridge, initBridge } from './init.js';
+
+export { packageInfo } from './packageInfo.js';
+export { bridge };
+
+// 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 @pezkuwi/wasm-crypto (or cryptoWaitReady() from @pezkuwi/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 bridge.resultString();
+});
+
+export const bip39ToEntropy = /*#__PURE__*/ withWasm((wasm, phrase: string): Uint8Array => {
+  wasm.ext_bip39_to_entropy(8, ...bridge.allocString(phrase));
+
+  return bridge.resultU8a();
+});
+
+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 bridge.resultU8a();
+});
+
+export const bip39ToSeed = /*#__PURE__*/ withWasm((wasm, phrase: string, password: string): Uint8Array => {
+  wasm.ext_bip39_to_seed(8, ...bridge.allocString(phrase), ...bridge.allocString(password));
+
+  return bridge.resultU8a();
+});
+
+export const bip39Validate = /*#__PURE__*/ withWasm((wasm, phrase: string): boolean => {
+  const ret = wasm.ext_bip39_validate(...bridge.allocString(phrase));
+
+  return ret !== 0;
+});
+
+export const ed25519KeypairFromSeed = /*#__PURE__*/ withWasm((wasm, seed: Uint8Array): Uint8Array => {
+  wasm.ext_ed_from_seed(8, ...bridge.allocU8a(seed));
+
+  return bridge.resultU8a();
+});
+
+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 bridge.resultU8a();
+});
+
+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;
+});
+
+export const secp256k1FromSeed = /*#__PURE__*/ withWasm((wasm, seckey: Uint8Array): Uint8Array => {
+  wasm.ext_secp_from_seed(8, ...bridge.allocU8a(seckey));
+
+  return bridge.resultU8a();
+});
+
+export const secp256k1Compress = /*#__PURE__*/ withWasm((wasm, pubkey: Uint8Array): Uint8Array => {
+  wasm.ext_secp_pub_compress(8, ...bridge.allocU8a(pubkey));
+
+  return bridge.resultU8a();
+});
+
+export const secp256k1Expand = /*#__PURE__*/ withWasm((wasm, pubkey: Uint8Array): Uint8Array => {
+  wasm.ext_secp_pub_expand(8, ...bridge.allocU8a(pubkey));
+
+  return bridge.resultU8a();
+});
+
+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 bridge.resultU8a();
+});
+
+export const secp256k1Sign = /*#__PURE__*/ withWasm((wasm, msgHash: Uint8Array, seckey: Uint8Array): Uint8Array => {
+  wasm.ext_secp_sign(8, ...bridge.allocU8a(msgHash), ...bridge.allocU8a(seckey));
+
+  return bridge.resultU8a();
+});
+
+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 bridge.resultU8a();
+});
+
+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 bridge.resultU8a();
+});
+
+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 bridge.resultU8a();
+});
+
+export const sr25519KeypairFromSeed = /*#__PURE__*/ withWasm((wasm, seed: Uint8Array): Uint8Array => {
+  wasm.ext_sr_from_seed(8, ...bridge.allocU8a(seed));
+
+  return bridge.resultU8a();
+});
+
+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 bridge.resultU8a();
+});
+
+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 = /*#__PURE__*/ withWasm((wasm, pubkey: Uint8Array, secret: Uint8Array): Uint8Array => {
+  wasm.ext_sr_agree(8, ...bridge.allocU8a(pubkey), ...bridge.allocU8a(secret));
+
+  return bridge.resultU8a();
+});
+
+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 bridge.resultU8a();
+});
+
+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 = /*#__PURE__*/ withWasm((wasm, data: Uint8Array, key: Uint8Array, size: number): Uint8Array => {
+  wasm.ext_blake2b(8, ...bridge.allocU8a(data), ...bridge.allocU8a(key), size);
+
+  return bridge.resultU8a();
+});
+
+export const hmacSha256 = /*#__PURE__*/ withWasm((wasm, key: Uint8Array, data: Uint8Array): Uint8Array => {
+  wasm.ext_hmac_sha256(8, ...bridge.allocU8a(key), ...bridge.allocU8a(data));
+
+  return bridge.resultU8a();
+});
+
+export const hmacSha512 = /*#__PURE__*/ withWasm((wasm, key: Uint8Array, data: Uint8Array): Uint8Array => {
+  wasm.ext_hmac_sha512(8, ...bridge.allocU8a(key), ...bridge.allocU8a(data));
+
+  return bridge.resultU8a();
+});
+
+export const keccak256 = /*#__PURE__*/ withWasm((wasm, data: Uint8Array): Uint8Array => {
+  wasm.ext_keccak256(8, ...bridge.allocU8a(data));
+
+  return bridge.resultU8a();
+});
+
+export const keccak512 = /*#__PURE__*/ withWasm((wasm, data: Uint8Array): Uint8Array => {
+  wasm.ext_keccak512(8, ...bridge.allocU8a(data));
+
+  return bridge.resultU8a();
+});
+
+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 bridge.resultU8a();
+});
+
+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 bridge.resultU8a();
+});
+
+export const sha256 = /*#__PURE__*/ withWasm((wasm, data: Uint8Array): Uint8Array => {
+  wasm.ext_sha256(8, ...bridge.allocU8a(data));
+
+  return bridge.resultU8a();
+});
+
+export const sha512 = /*#__PURE__*/ withWasm((wasm, data: Uint8Array): Uint8Array => {
+  wasm.ext_sha512(8, ...bridge.allocU8a(data));
+
+  return bridge.resultU8a();
+});
+
+export const twox = /*#__PURE__*/ withWasm((wasm, data: Uint8Array, rounds: number) => {
+  wasm.ext_twox(8, ...bridge.allocU8a(data), rounds);
+
+  return bridge.resultU8a();
+});
+
+export function isReady (): boolean {
+  return !!bridge.wasm;
+}
+
+export async function waitReady (): Promise<boolean> {
+  try {
+    const wasm = await initBridge();
+
+    return !!wasm;
+  } catch {
+    return false;
+  }
+}

package/src/index.ts

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

package/{init.d.ts → src/init.ts}

@@ -1,16 +1,25 @@
+// Copyright 2019-2026 @pezkuwi/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
 import type { InitFn } from '@pezkuwi/wasm-bridge/types';
 import type { WasmCryptoInstance } from '@pezkuwi/wasm-crypto-init/types';
+
 import { Bridge } from '@pezkuwi/wasm-bridge';
+import { createWasm } from '@pezkuwi/wasm-crypto-init';
+
 /**
  * @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 declare const bridge: Bridge<WasmCryptoInstance>;
+export const bridge = new Bridge<WasmCryptoInstance>(createWasm);
+
 /**
  * @name initBridge
  * @description
  * Creates a new bridge interface with the (optional) initialization function
  */
-export declare function initBridge(createWasm?: InitFn<WasmCryptoInstance>): Promise<WasmCryptoInstance | null>;
+export async function initBridge (createWasm?: InitFn<WasmCryptoInstance>): Promise<WasmCryptoInstance | null> {
+  return bridge.init(createWasm);
+}

package/{initNone.js → src/initNone.ts}

@@ -1,5 +1,10 @@
+// Copyright 2019-2026 @pezkuwi/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
 import { createWasm } from '@pezkuwi/wasm-crypto-init/none';
+
 import { initBridge } from './init.js';
+
 /**
  * @name initWasm
  * @description
@@ -9,9 +14,10 @@ import { initBridge } from './init.js';
  * Generally should not be used unless you want explicit control over which
  * interfaces are initialized.
  */
-export async function initWasm() {
-    await initBridge(createWasm);
+export async function initWasm (): Promise<void> {
+  await initBridge(createWasm);
 }
-initWasm().catch(() => {
-    // cannot happen, initWasm doesn't throw
+
+initWasm().catch((): void => {
+  // cannot happen, initWasm doesn't throw
 });

package/{initOnlyAsm.js → src/initOnlyAsm.ts}

@@ -1,5 +1,10 @@
+// Copyright 2019-2026 @pezkuwi/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
 import { createWasm } from '@pezkuwi/wasm-crypto-init/asm';
+
 import { initBridge } from './init.js';
+
 /**
  * @name initWasm
  * @description
@@ -9,9 +14,10 @@ import { initBridge } from './init.js';
  * Generally should not be used unless you want explicit control over which
  * interfaces are initialized.
  */
-export async function initWasm() {
-    await initBridge(createWasm);
+export async function initWasm (): Promise<void> {
+  await initBridge(createWasm);
 }
-initWasm().catch(() => {
-    // cannot happen, initWasm doesn't throw
+
+initWasm().catch((): void => {
+  // cannot happen, initWasm doesn't throw
 });

package/{initOnlyWasm.js → src/initOnlyWasm.ts}

@@ -1,5 +1,10 @@
+// Copyright 2019-2026 @pezkuwi/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
 import { createWasm } from '@pezkuwi/wasm-crypto-init/wasm';
+
 import { initBridge } from './init.js';
+
 /**
  * @name initWasm
  * @description
@@ -9,9 +14,10 @@ import { initBridge } from './init.js';
  * Generally should not be used unless you want explicit control over which
  * interfaces are initialized.
  */
-export async function initWasm() {
-    await initBridge(createWasm);
+export async function initWasm (): Promise<void> {
+  await initBridge(createWasm);
 }
-initWasm().catch(() => {
-    // cannot happen, initWasm doesn't throw
+
+initWasm().catch((): void => {
+  // cannot happen, initWasm doesn't throw
 });

package/{initWasmAsm.js → src/initWasmAsm.ts}

@@ -1,5 +1,10 @@
+// Copyright 2019-2026 @pezkuwi/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
 import { createWasm } from '@pezkuwi/wasm-crypto-init/both';
+
 import { initBridge } from './init.js';
+
 /**
  * @name initWasm
  * @description
@@ -9,9 +14,10 @@ import { initBridge } from './init.js';
  * Generally should not be used unless you want explicit control over which
  * interfaces are initialized.
  */
-export async function initWasm() {
-    await initBridge(createWasm);
+export async function initWasm (): Promise<void> {
+  await initBridge(createWasm);
 }
-initWasm().catch(() => {
-    // cannot happen, initWasm doesn't throw
+
+initWasm().catch((): void => {
+  // cannot happen, initWasm doesn't throw
 });