chore: some fixes

Author: shumkov

packages/js-evo-sdk/src/wallet/functions.ts

@@ -1,9 +1,9 @@
 import * as wasm from '../wasm.js';
 
 export namespace wallet {
-  export async function generateMnemonic(wordCount?: number, languageCode?: string): Promise<string> {
+  export async function generateMnemonic(params?: wasm.GenerateMnemonicParams): Promise<string> {
     await wasm.ensureInitialized();
-    return wasm.WasmSdk.generateMnemonic(wordCount ?? null, languageCode ?? null);
+    return wasm.WasmSdk.generateMnemonic(params ?? null);
   }
 
   export async function validateMnemonic(mnemonic: string, languageCode?: string): Promise<boolean> {

packages/js-evo-sdk/tests/functional/wallet.spec.mjs

@@ -2,7 +2,7 @@ import { wallet } from '../../dist/evo-sdk.module.js';
 
 describe('wallet helpers', () => {
   it('generateMnemonic() returns phrase and validateMnemonic() succeeds', async () => {
-    const mnemonic = await wallet.generateMnemonic(12, 'en');
+    const mnemonic = await wallet.generateMnemonic({ wordCount: 12, languageCode: 'en' });
     expect(mnemonic).to.be.a('string');
     expect(await wallet.validateMnemonic(mnemonic, 'en')).to.equal(true);
   });
@@ -12,8 +12,12 @@ describe('wallet helpers', () => {
     const seed = await wallet.mnemonicToSeed(mnemonic);
     expect(seed).to.be.instanceOf(Uint8Array);
     expect(await wallet.deriveKeyFromSeedPhrase({ mnemonic, passphrase: null, network: 'testnet' })).to.exist();
-    expect(await wallet.deriveKeyFromSeedWithPath({ mnemonic, passphrase: null, path: "m/44'/5'/0'", network: 'testnet' })).to.exist();
-    expect(await wallet.deriveKeyFromSeedWithExtendedPath({ mnemonic, passphrase: null, path: "m/15'/0'", network: 'testnet' })).to.exist();
+    expect(await wallet.deriveKeyFromSeedWithPath({
+      mnemonic, passphrase: null, path: "m/44'/5'/0'", network: 'testnet',
+    })).to.exist();
+    expect(await wallet.deriveKeyFromSeedWithExtendedPath({
+      mnemonic, passphrase: null, path: "m/15'/0'", network: 'testnet',
+    })).to.exist();
   });
 
   it('key utilities return expected shapes', async () => {

packages/wasm-sdk/src/wallet/extended_derivation.rs

@@ -274,11 +274,11 @@ impl WasmSdk {
             "Options object is required",
             "deriveDashpayContactKey options",
         )?;
-        let sender_id_formatted = {
+        let sender_id_hex = {
             let id: dash_sdk::dpp::prelude::Identifier = sender_identity_id.into();
             hex::encode(id.as_bytes())
         };
-        let receiver_id_formatted = {
+        let receiver_id_hex = {
             let id: dash_sdk::dpp::prelude::Identifier = receiver_identity_id.into();
             hex::encode(id.as_bytes())
         };
@@ -294,16 +294,16 @@ impl WasmSdk {
         // m / 9' / coin_type' / 15' / account' / sender_id / receiver_id / index
         let path = format!(
             "m/9'/{}'/{}'/{}'/0x{}/0x{}/{}",
-            coin_type, 15, account, sender_id_formatted, receiver_id_formatted, address_index
+            coin_type, 15, account, sender_id_hex, receiver_id_hex, address_index
         );
         debug!(target : "wasm_sdk", path = % path, "DashPay contact path");
 
         // Reuse common derivation logic
         let common = derive_common_from_mnemonic(&mnemonic, passphrase, &network, &path)?;
         Ok(DashpayContactKeyInfoWasm::from_common(
             common,
-            sender_id_formatted,
-            receiver_id_formatted,
+            sender_id_hex,
+            receiver_id_hex,
             account,
             address_index,
         ))

packages/wasm-sdk/src/wallet/key_derivation.rs

@@ -3,7 +3,7 @@
 //! Implements BIP32, BIP39, and BIP44 standards for hierarchical deterministic key derivation
 
 use crate::error::WasmSdkError;
-use crate::queries::utils::deserialize_required_query;
+use crate::queries::utils::{deserialize_query_with_default, deserialize_required_query};
 use crate::sdk::WasmSdk;
 use bip39::{Language, Mnemonic};
 use dash_sdk::dpp::dashcore;
@@ -18,6 +18,19 @@ use std::str::FromStr;
 use wasm_bindgen::prelude::*;
 
 // TypeScript option bags (module scope) for wallet derivation helpers
+#[wasm_bindgen(typescript_custom_section)]
+const GENERATE_MNEMONIC_PARAMS_TS: &'static str = r#"
+export interface GenerateMnemonicParams {
+  wordCount?: number;
+  languageCode?: string;
+}
+"#;
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(typescript_type = "GenerateMnemonicParams")]
+    pub type GenerateMnemonicParamsJs;
+}
+
 #[wasm_bindgen(typescript_custom_section)]
 const DERIVE_FROM_SEED_PHRASE_OPTS_TS: &'static str = r#"
 export interface DeriveKeyFromSeedPhraseParams {
@@ -48,6 +61,15 @@ extern "C" {
 }
 
 // Inputs parsed from options (module scope)
+#[derive(Default, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct GenerateMnemonicInput {
+    #[serde(default)]
+    word_count: Option<u32>,
+    #[serde(default)]
+    language_code: Option<String>,
+}
+
 #[derive(serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct DeriveFromSeedPhraseInput {
@@ -197,9 +219,16 @@ impl WasmSdk {
     /// Generate a new mnemonic phrase
     #[wasm_bindgen(js_name = "generateMnemonic")]
     pub fn generate_mnemonic(
-        #[wasm_bindgen(js_name = "wordCount")] word_count: Option<u32>,
-        #[wasm_bindgen(js_name = "languageCode")] language_code: Option<String>,
+        params: Option<GenerateMnemonicParamsJs>,
     ) -> Result<String, WasmSdkError> {
+        let GenerateMnemonicInput {
+            word_count,
+            language_code,
+        } = deserialize_query_with_default(
+            params,
+            "generateMnemonic options",
+        )?;
+
         let words = word_count.unwrap_or(12);
 
         // Validate word count and calculate entropy bytes
@@ -295,7 +324,7 @@ impl WasmSdk {
     /// Derive a key from mnemonic phrase using BIP39/BIP44
     #[wasm_bindgen(js_name = "deriveKeyFromSeedPhrase")]
     pub fn derive_key_from_seed_phrase(
-        #[wasm_bindgen(unchecked_param_type = "DeriveKeyFromSeedPhraseParams")] params: JsValue,
+        params: DeriveKeyFromSeedPhraseParamsJs,
     ) -> Result<JsValue, WasmSdkError> {
         let DeriveFromSeedPhraseInput {
             mnemonic,
@@ -359,7 +388,7 @@ impl WasmSdk {
     /// Derive a key from seed phrase with arbitrary path
     #[wasm_bindgen(js_name = "deriveKeyFromSeedWithPath")]
     pub fn derive_key_from_seed_with_path(
-        #[wasm_bindgen(unchecked_param_type = "DeriveKeyFromSeedWithPathParams")] params: JsValue,
+        params: DeriveKeyFromSeedWithPathParamsJs,
     ) -> Result<JsValue, WasmSdkError> {
         use dash_sdk::dpp::key_wallet::{DerivationPath, ExtendedPrivKey};
 

packages/wasm-sdk/tests/unit/key-generation.spec.mjs

@@ -9,19 +9,19 @@ describe('Keys and mnemonics', () => {
 
   describe('mnemonic', () => {
     it('generates 12 and 24 words and validates', () => {
-      const m12 = sdk.WasmSdk.generateMnemonic(12);
+      const m12 = sdk.WasmSdk.generateMnemonic({ wordCount: 12 });
       expect(m12.split(' ').length).to.equal(12);
       expect(sdk.WasmSdk.validateMnemonic(m12)).to.equal(true);
 
-      const m24 = sdk.WasmSdk.generateMnemonic(24);
+      const m24 = sdk.WasmSdk.generateMnemonic({ wordCount: 24 });
       expect(m24.split(' ').length).to.equal(24);
       expect(sdk.WasmSdk.validateMnemonic(m24)).to.equal(true);
     });
 
     it('supports language wordlists', () => {
       const langs = ['en', 'es', 'fr', 'it', 'ja', 'ko', 'pt', 'cs'];
       for (const lang of langs) {
-        const m = sdk.WasmSdk.generateMnemonic(12, lang);
+        const m = sdk.WasmSdk.generateMnemonic({ wordCount: 12, languageCode: lang });
         expect(sdk.WasmSdk.validateMnemonic(m, lang)).to.equal(true);
       }
     });