@pezkuwi/wasm-crypto 7.5.8 → 7.5.10

package/src/bundle.ts

@@ -1,247 +0,0 @@
-// 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

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

package/src/lib.rs

@@ -1,24 +0,0 @@
-// Copyright 2019-2025 @pezkuwi/wasm-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// Use `wee_alloc` as the global allocator.
-#[global_allocator]
-static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
-
-#[path = "rs/bip39.rs"]
-pub mod bip39;
-
-#[path = "rs/ed25519.rs"]
-pub mod ed25519;
-
-#[path = "rs/hashing.rs"]
-pub mod hashing;
-
-#[path = "rs/secp256k1.rs"]
-pub mod secp256k1;
-
-#[path = "rs/sr25519.rs"]
-pub mod sr25519;
-
-#[path = "rs/vrf.rs"]
-pub mod vrf;

package/src/mod.ts

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

package/src/packageInfo.ts

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

package/src/rs/.editorconfig

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

package/src/rs/bip39.rs

@@ -1,139 +0,0 @@
-// Copyright 2019-2025 @pezkuwi/wasm-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-use bip39::{Mnemonic, MnemonicType, Language, Seed};
-use hmac::Hmac;
-use pbkdf2::pbkdf2;
-use sha2::Sha512;
-use wasm_bindgen::prelude::*;
-
-/// Generate a bip39 phrase
-///
-/// words: number of words, either 12, 15, 18 21 or 24
-///
-/// Returns the bip 39 phrase
-#[wasm_bindgen]
-pub fn ext_bip39_generate(words: u32) -> String {
-	match MnemonicType::for_word_count(words as usize) {
-		Ok(p) => Mnemonic::new(p, Language::English)
-			.into_phrase(),
-		_ => panic!("Invalid count provided.")
-	}
-}
-
-/// Create entropy from a bip39 phrase
-///
-/// * phrase: mnemonic phrase
-///
-/// Returns the entropy
-#[wasm_bindgen]
-pub fn ext_bip39_to_entropy(phrase: &str) -> Vec<u8> {
-	match Mnemonic::from_phrase(phrase, Language::English) {
-		Ok(m) => m
-			.entropy()
-			.to_vec(),
-		_ => panic!("Invalid phrase provided.")
-	}
-}
-
-/// Create a mini-secret from a bip39 phrase
-///
-/// * phrase: mnemonic phrase
-///
-/// Returns the 32-byte mini-secret via entropy
-#[wasm_bindgen]
-pub fn ext_bip39_to_mini_secret(phrase: &str, password: &str) -> Vec<u8> {
-	match Mnemonic::from_phrase(phrase, Language::English) {
-		Ok(m) => {
-			let mut res = [0u8; 64];
-			let mut seed = vec![];
-
-			seed.extend_from_slice(b"mnemonic");
-			seed.extend_from_slice(password.as_bytes());
-
-			pbkdf2::<Hmac<Sha512>>(m.entropy(), &seed, 2048, &mut res);
-
-			res[..32].to_vec()
-		},
-		_ => panic!("Invalid phrase provided.")
-	}
-}
-
-/// Creates a BTC/ETH compatible seed from a bip-39 phrase
-///
-/// @phrase: mnemonic phrase
-///
-/// Returns a 32-byte seed
-#[wasm_bindgen]
-pub fn ext_bip39_to_seed(phrase: &str, password: &str) -> Vec<u8> {
-	match Mnemonic::from_phrase(phrase, Language::English) {
-		Ok(m) => Seed::new(&m, password)
-			.as_bytes()[..32]
-			.to_vec(),
-		_ => panic!("Invalid phrase provided.")
-	}
-}
-
-/// Validates a bip39 phrase
-///
-/// * phrase: mnemonic phrase
-///
-/// Returns the true/false
-#[wasm_bindgen]
-pub fn ext_bip39_validate(phrase: &str) -> bool {
-	match Mnemonic::validate(phrase, Language::English) {
-		Ok(_) => true,
-		_ => false
-	}
-}
-
-#[cfg(test)]
-pub mod tests {
-	use hex_literal::hex;
-	use super::*;
-
-	#[test]
-	fn can_bip39_entropy() {
-		let phrase = "legal winner thank year wave sausage worth useful legal winner thank yellow";
-		let entropy = hex!("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f");
-		let res = ext_bip39_to_entropy(phrase);
-
-		assert_eq!(res, entropy);
-	}
-
-	#[test]
-	fn can_bip39_mini_secret() {
-		let phrase = "legal winner thank year wave sausage worth useful legal winner thank yellow";
-		let password = "Substrate";
-		let mini = hex!("4313249608fe8ac10fd5886c92c4579007272cb77c21551ee5b8d60b78041685");
-		let res = ext_bip39_to_mini_secret(phrase, password);
-
-		assert_eq!(res[..], mini[..]);
-	}
-
-	#[test]
-	fn can_bip39_seed() {
-		let phrase = "seed sock milk update focus rotate barely fade car face mechanic mercy";
-		let seed = hex!("3c121e20de068083b49c2315697fb59a2d9e8643c24e5ea7628132c58969a027");
-		let res = ext_bip39_to_seed(phrase, "");
-
-		assert_eq!(res[..], seed[..]);
-	}
-
-	#[test]
-	fn can_bip39_generate() {
-		let phrase = ext_bip39_generate(12);
-		let is_valid = ext_bip39_validate(&phrase);
-
-		assert!(is_valid);
-	}
-
-	#[test]
-	fn can_bip39_validate() {
-		let is_valid = ext_bip39_validate("seed sock milk update focus rotate barely fade car face mechanic mercy");
-		let is_invalid = ext_bip39_validate("wine photo extra cushion basket dwarf humor cloud truck job boat submit");
-
-		assert_eq!(is_valid, true);
-		assert_eq!(is_invalid, false);
-	}
-}

package/src/rs/ed25519.rs

@@ -1,142 +0,0 @@
-// Copyright 2019-2025 @pezkuwi/wasm-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-use std::convert::TryFrom;
-use ed25519_dalek::{Keypair, PublicKey, SecretKey, Signature, Signer as _, Verifier as _};
-use wasm_bindgen::prelude::*;
-
-/// Keypair helper function
-fn new_from_seed(seed: &[u8]) -> Keypair {
-	match SecretKey::from_bytes(seed) {
-		Ok(secret) => {
-			let public: PublicKey = (&secret).into();
-
-			Keypair { secret: secret, public: public }
-		},
-		_ => panic!("Invalid seed provided.")
-	}
-}
-
-/// Generate a key pair.
-///
-/// * seed: UIntArray with 32 element
-///
-/// 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> {
-	new_from_seed(seed)
-		.to_bytes()
-		.to_vec()
-}
-
-/// Sign a message
-///
-/// The combination of both public and private key must be provided.
-/// This is effectively equivalent to a keypair.
-///
-/// * _: 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(_: &[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()
-}
-
-/// Verify a message and its corresponding against a public key;
-///
-/// * signature: UIntArray with 64 element
-/// * message: Arbitrary length UIntArray
-/// * pubkey: UIntArray with 32 element
-#[wasm_bindgen]
-pub fn ext_ed_verify(signature: &[u8], message: &[u8], pubkey: &[u8]) -> bool {
-	match (Signature::try_from(signature), PublicKey::from_bytes(pubkey)) {
-		(Ok(s), Ok(k)) => k
-			.verify(message, &s)
-			.is_ok(),
-		_ => false
-	}
-}
-
-#[cfg(test)]
-pub mod tests {
-	extern crate rand;
-
-	use hex_literal::hex;
-	use super::*;
-	use ed25519_dalek::{SIGNATURE_LENGTH, KEYPAIR_LENGTH, SECRET_KEY_LENGTH};
-
-	fn generate_random_seed() -> Vec<u8> {
-		(0..32).map(|_| rand::random::<u8>() ).collect()
-	}
-
-	#[test]
-	fn can_new_keypair() {
-		let seed = generate_random_seed();
-		let keypair = ext_ed_from_seed(seed.as_slice());
-
-		assert!(keypair.len() == KEYPAIR_LENGTH);
-	}
-
-	#[test]
-	fn creates_pair_from_known() {
-		let seed = b"12345678901234567890123456789012";
-		let expected = hex!("2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee");
-		let keypair = ext_ed_from_seed(seed);
-		let public = &keypair[SECRET_KEY_LENGTH..KEYPAIR_LENGTH];
-
-		assert_eq!(public, expected);
-	}
-
-	#[test]
-	fn can_sign_message() {
-		let seed = generate_random_seed();
-		let keypair = ext_ed_from_seed(seed.as_slice());
-		let private = &keypair[0..SECRET_KEY_LENGTH];
-		let public = &keypair[SECRET_KEY_LENGTH..KEYPAIR_LENGTH];
-		let message = b"this is a message";
-		let signature = ext_ed_sign(public, private, message);
-
-		assert!(signature.len() == SIGNATURE_LENGTH);
-	}
-
-	#[test]
-	fn can_verify_message() {
-		let seed = generate_random_seed();
-		let keypair = ext_ed_from_seed(seed.as_slice());
-		let private = &keypair[0..SECRET_KEY_LENGTH];
-		let public = &keypair[SECRET_KEY_LENGTH..KEYPAIR_LENGTH];
-		let message = b"this is a message";
-		let signature = ext_ed_sign(public, private, message);
-		let is_valid = ext_ed_verify(&signature[..], message, public);
-
-		assert!(is_valid);
-	}
-
-	#[test]
-	fn can_verify_known() {
-		let public = hex!("2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee");
-		let message = b"this is a message";
-		let signature = hex!("90588f3f512496f2dd40571d162e8182860081c74e2085316e7c4396918f07da412ee029978e4dd714057fe973bd9e7d645148bf7b66680d67c93227cde95202");
-		let is_valid = ext_ed_verify(&signature, message, &public);
-
-		assert!(is_valid);
-	}
-
-	#[test]
-	fn can_verify_known_wrong() {
-		let public = hex!("2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee");
-		let message = b"this is a message";
-		let signature = &[0u8; 64];
-		let is_valid = ext_ed_verify(signature, message, &public);
-
-		assert_eq!(is_valid, false);
-	}
-}