@pezkuwi/wasm-crypto 7.5.12 → 7.5.15

package/src/initOnlyAsm.ts

@@ -0,0 +1,23 @@
+// 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
+ * 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
+});

package/src/initOnlyWasm.ts

@@ -0,0 +1,23 @@
+// 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
+ * 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
+});

package/src/initWasmAsm.ts

@@ -0,0 +1,23 @@
+// 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
+ * 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
+});

package/src/lib.rs

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

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

package/src/packageDetect.ts

@@ -0,0 +1,16 @@
+// Copyright 2017-2026 @pezkuwi/wasm-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @pezkuwi/dev
+// (packageInfo imports will be kept as-is, user-editable)
+
+import { detectPackage } from '@pezkuwi/util';
+import { packageInfo as bridgeInfo } from '@pezkuwi/wasm-bridge/packageInfo';
+import { packageInfo as asmInfo } from '@pezkuwi/wasm-crypto-asmjs/packageInfo';
+import { packageInfo as initInfo } from '@pezkuwi/wasm-crypto-init/packageInfo';
+import { packageInfo as wasmInfo } from '@pezkuwi/wasm-crypto-wasm/packageInfo';
+import { packageInfo as utilInfo } from '@pezkuwi/wasm-util/packageInfo';
+
+import { packageInfo } from './packageInfo.js';
+
+detectPackage(packageInfo, null, [asmInfo, bridgeInfo, initInfo, utilInfo, wasmInfo]);

package/src/packageInfo.ts

@@ -0,0 +1,6 @@
+// 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.15' };

package/src/rs/.editorconfig

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

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

@@ -0,0 +1,142 @@
+// 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);
+	}
+}