refactor: cleanups params

shumkov · shumkov · commit 80c177272036 · 2025-11-11T00:33:19.000+07:00
diff --git a/packages/js-evo-sdk/src/protocol/facade.ts b/packages/js-evo-sdk/src/protocol/facade.ts
@@ -7,15 +7,13 @@ export class ProtocolFacade {
   async versionUpgradeState(): Promise<any> { const w = await this.sdk.getWasmSdkConnected(); return w.getProtocolVersionUpgradeState(); }
   async versionUpgradeStateWithProof(): Promise<any> { const w = await this.sdk.getWasmSdkConnected(); return w.getProtocolVersionUpgradeStateWithProofInfo(); }
 
-  async versionUpgradeVoteStatus(params: { startProTxHash: string; count: number }): Promise<any> {
-    const { startProTxHash, count } = params;
+  async versionUpgradeVoteStatus(startProTxHash: string | Uint8Array, count: number): Promise<any> {
     const w = await this.sdk.getWasmSdkConnected();
-    return w.getProtocolVersionUpgradeVoteStatus(startProTxHash, count);
+    return w.getProtocolVersionUpgradeVoteStatus(startProTxHash as any, count);
   }
 
-  async versionUpgradeVoteStatusWithProof(params: { startProTxHash: string; count: number }): Promise<any> {
-    const { startProTxHash, count } = params;
+  async versionUpgradeVoteStatusWithProof(startProTxHash: string | Uint8Array, count: number): Promise<any> {
     const w = await this.sdk.getWasmSdkConnected();
-    return w.getProtocolVersionUpgradeVoteStatusWithProofInfo(startProTxHash, count);
+    return w.getProtocolVersionUpgradeVoteStatusWithProofInfo(startProTxHash as any, count);
   }
 }
diff --git a/packages/js-evo-sdk/src/tokens/facade.ts b/packages/js-evo-sdk/src/tokens/facade.ts
@@ -60,7 +60,7 @@ export class TokensFacade {
     return w.getIdentityTokenBalancesWithProofInfo(identityId, tokenIds);
   }
 
-  async identityTokenInfos(identityId: wasm.IdentifierLike, tokenIds: wasm.IdentifierLike[], _opts: { limit?: number; offset?: number } = {}): Promise<any> {
+  async identityTokenInfos(identityId: wasm.IdentifierLike, tokenIds: wasm.IdentifierLike[]): Promise<any> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getIdentityTokenInfos(identityId, tokenIds);
   }
diff --git a/packages/js-evo-sdk/src/wallet/functions.ts b/packages/js-evo-sdk/src/wallet/functions.ts
@@ -16,32 +16,24 @@ export namespace wallet {
     return wasm.WasmSdk.mnemonicToSeed(mnemonic, passphrase ?? null);
   }
 
-  export async function deriveKeyFromSeedPhrase(mnemonic: string, passphrase: string | null | undefined, network: string): Promise<any> {
+  export async function deriveKeyFromSeedPhrase(opts: wasm.DeriveKeyFromSeedPhraseOptions): Promise<any> {
     await wasm.ensureInitialized();
-    return wasm.WasmSdk.deriveKeyFromSeedPhrase(mnemonic, passphrase ?? null, network);
+    return wasm.WasmSdk.deriveKeyFromSeedPhrase(opts);
   }
 
-  export async function deriveKeyFromSeedWithPath(mnemonic: string, passphrase: string | null | undefined, path: string, network: string): Promise<any> {
+  export async function deriveKeyFromSeedWithPath(opts: wasm.DeriveKeyFromSeedWithPathOptions): Promise<any> {
     await wasm.ensureInitialized();
-    return wasm.WasmSdk.deriveKeyFromSeedWithPath(mnemonic, passphrase ?? null, path, network);
+    return wasm.WasmSdk.deriveKeyFromSeedWithPath(opts);
   }
 
-  export async function deriveKeyFromSeedWithExtendedPath(mnemonic: string, passphrase: string | null | undefined, path: string, network: string): Promise<any> {
+  export async function deriveKeyFromSeedWithExtendedPath(opts: wasm.DeriveKeyFromSeedWithExtendedPathOptions): Promise<any> {
     await wasm.ensureInitialized();
-    return wasm.WasmSdk.deriveKeyFromSeedWithExtendedPath(mnemonic, passphrase ?? null, path, network);
+    return wasm.WasmSdk.deriveKeyFromSeedWithExtendedPath(opts);
   }
 
-  export async function deriveDashpayContactKey(mnemonic: string, passphrase: string | null | undefined, senderIdentityId: string, receiverIdentityId: string, account: number, addressIndex: number, network: string): Promise<any> {
+  export async function deriveDashpayContactKey(opts: wasm.DeriveDashpayContactKeyOptions): Promise<any> {
     await wasm.ensureInitialized();
-    return wasm.WasmSdk.deriveDashpayContactKey(
-      mnemonic,
-      passphrase ?? null,
-      senderIdentityId,
-      receiverIdentityId,
-      account,
-      addressIndex,
-      network,
-    );
+    return wasm.WasmSdk.deriveDashpayContactKey(opts);
   }
 
   export async function derivationPathBip44Mainnet(account: number, change: number, index: number): Promise<any> {
diff --git a/packages/js-evo-sdk/tests/functional/protocol.spec.mjs b/packages/js-evo-sdk/tests/functional/protocol.spec.mjs
@@ -16,10 +16,7 @@ describe('Protocol', function protocolSuite() {
   });
 
   it('versionUpgradeVoteStatus() returns vote window status', async () => {
-    const res = await sdk.protocol.versionUpgradeVoteStatus({
-      startProTxHash: TEST_IDS.proTxHash,
-      count: 1,
-    });
+    const res = await sdk.protocol.versionUpgradeVoteStatus(TEST_IDS.proTxHash, 1);
     expect(res).to.exist();
   });
 });
diff --git a/packages/js-evo-sdk/tests/functional/wallet.spec.mjs b/packages/js-evo-sdk/tests/functional/wallet.spec.mjs
@@ -11,9 +11,9 @@ describe('wallet helpers', () => {
     const mnemonic = await wallet.generateMnemonic();
     const seed = await wallet.mnemonicToSeed(mnemonic);
     expect(seed).to.be.instanceOf(Uint8Array);
-    expect(await wallet.deriveKeyFromSeedPhrase(mnemonic, null, 'testnet')).to.exist();
-    expect(await wallet.deriveKeyFromSeedWithPath(mnemonic, null, "m/44'/5'/0'", 'testnet')).to.exist();
-    expect(await wallet.deriveKeyFromSeedWithExtendedPath(mnemonic, null, "m/15'/0'", 'testnet')).to.exist();
+    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();
   });
 
   it('key utilities return expected shapes', async () => {
diff --git a/packages/js-evo-sdk/tests/unit/facades/protocol.spec.mjs b/packages/js-evo-sdk/tests/unit/facades/protocol.spec.mjs
@@ -24,10 +24,18 @@ describe('ProtocolFacade', () => {
     expect(wasmSdk.getProtocolVersionUpgradeStateWithProofInfo).to.be.calledOnce();
   });
 
-  it('versionUpgradeVoteStatus and withProof forward with args', async () => {
-    await client.protocol.versionUpgradeVoteStatus({ startProTxHash: 'h', count: 5 });
-    await client.protocol.versionUpgradeVoteStatusWithProof({ startProTxHash: 'g', count: 3 });
+  it('versionUpgradeVoteStatus and withProof forward with positional args', async () => {
+    await client.protocol.versionUpgradeVoteStatus('h', 5);
+    await client.protocol.versionUpgradeVoteStatusWithProof('g', 3);
     expect(wasmSdk.getProtocolVersionUpgradeVoteStatus).to.be.calledOnceWithExactly('h', 5);
     expect(wasmSdk.getProtocolVersionUpgradeVoteStatusWithProofInfo).to.be.calledOnceWithExactly('g', 3);
   });
+
+  it('versionUpgradeVoteStatus accepts Uint8Array and positional args', async () => {
+    const bytes = new Uint8Array([0xde, 0xad, 0xbe, 0xef]);
+    await client.protocol.versionUpgradeVoteStatus(bytes, 2);
+    await client.protocol.versionUpgradeVoteStatusWithProof(bytes, 4);
+    expect(wasmSdk.getProtocolVersionUpgradeVoteStatus).to.be.calledWith(bytes, 2);
+    expect(wasmSdk.getProtocolVersionUpgradeVoteStatusWithProofInfo).to.be.calledWith(bytes, 4);
+  });
 });
diff --git a/packages/wasm-sdk/src/queries/protocol.rs b/packages/wasm-sdk/src/queries/protocol.rs
@@ -1,6 +1,7 @@
 use crate::error::WasmSdkError;
 use crate::queries::ProofMetadataResponseWasm;
 use crate::sdk::WasmSdk;
+use dash_sdk::dpp::dashcore::hashes::{sha256d, Hash as _};
 use js_sys::Map;
 use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::JsValue;
@@ -113,21 +114,39 @@ impl WasmSdk {
     #[wasm_bindgen(js_name = "getProtocolVersionUpgradeVoteStatus")]
     pub async fn get_protocol_version_upgrade_vote_status(
         &self,
-        #[wasm_bindgen(js_name = "startProTxHash")] start_pro_tx_hash: &str,
+        #[wasm_bindgen(js_name = "startProTxHash")]
+        #[wasm_bindgen(unchecked_param_type = "string | Uint8Array")]
+        start_pro_tx_hash: JsValue,
         count: u32,
     ) -> Result<Map, WasmSdkError> {
         use dash_sdk::dpp::dashcore::ProTxHash;
         use dash_sdk::platform::types::version_votes::MasternodeProtocolVoteEx;
         use drive_proof_verifier::types::MasternodeProtocolVote;
         use std::str::FromStr;
-        let start_hash =
-            if start_pro_tx_hash.is_empty() {
+        let start_hash = if let Some(s) = start_pro_tx_hash.as_string() {
+            if s.is_empty() {
                 None
             } else {
-                Some(ProTxHash::from_str(start_pro_tx_hash).map_err(|e| {
+                Some(ProTxHash::from_str(&s).map_err(|e| {
                     WasmSdkError::invalid_argument(format!("Invalid ProTxHash: {}", e))
                 })?)
-            };
+            }
+        } else {
+            let bytes = js_sys::Uint8Array::new(&start_pro_tx_hash).to_vec();
+            if bytes.is_empty() {
+                None
+            } else {
+                if bytes.len() != 32 {
+                    return Err(WasmSdkError::invalid_argument(
+                        "ProTxHash must be 32 bytes or an empty value",
+                    ));
+                }
+                let mut arr = [0u8; 32];
+                arr.copy_from_slice(&bytes);
+                let raw = sha256d::Hash::from_byte_array(arr);
+                Some(ProTxHash::from_raw_hash(raw))
+            }
+        };
         let votes_result =
             MasternodeProtocolVote::fetch_votes(self.as_ref(), start_hash, Some(count)).await?;
         let votes_map = Map::new();
@@ -183,7 +202,9 @@ impl WasmSdk {
     #[wasm_bindgen(js_name = "getProtocolVersionUpgradeVoteStatusWithProofInfo")]
     pub async fn get_protocol_version_upgrade_vote_status_with_proof_info(
         &self,
-        #[wasm_bindgen(js_name = "startProTxHash")] start_pro_tx_hash: &str,
+        #[wasm_bindgen(js_name = "startProTxHash")]
+        #[wasm_bindgen(unchecked_param_type = "string | Uint8Array")]
+        start_pro_tx_hash: JsValue,
         count: u32,
     ) -> Result<JsValue, WasmSdkError> {
         let _ = (self, start_pro_tx_hash, count);
diff --git a/packages/wasm-sdk/src/wallet/extended_derivation.rs b/packages/wasm-sdk/src/wallet/extended_derivation.rs
@@ -3,33 +3,97 @@
 //! Implements 256-bit derivation paths for DashPay contact keys
 use crate::error::WasmSdkError;
 use crate::sdk::WasmSdk;
+use crate::queries::utils::deserialize_required_query;
 use dash_sdk::dpp::dashcore;
 use dash_sdk::dpp::dashcore::secp256k1::Secp256k1;
 use dash_sdk::dpp::key_wallet::{bip32, DerivationPath, ExtendedPrivKey};
 use std::str::FromStr;
 use tracing::debug;
 use wasm_bindgen::prelude::*;
+
+// TypeScript option bags (module scope) for extended derivation helpers
+#[wasm_bindgen(typescript_custom_section)]
+const DERIVE_FROM_EXTENDED_PATH_OPTS_TS: &'static str = r#"
+export interface DeriveKeyFromSeedWithExtendedPathOptions {
+  mnemonic: string;
+  passphrase?: string | null;
+  path: string;
+  network: string;
+}
+"#;
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(typescript_type = "DeriveKeyFromSeedWithExtendedPathOptions")]
+    pub type DeriveKeyFromSeedWithExtendedPathOptionsJs;
+}
+
+// Inputs parsed from options (module scope)
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DeriveFromExtendedPathInput {
+    mnemonic: String,
+    #[serde(default)]
+    passphrase: Option<String>,
+    path: String,
+    network: String,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DeriveDashpayContactKeyInput {
+    mnemonic: String,
+    #[serde(default)]
+    passphrase: Option<String>,
+    #[serde(rename = "senderIdentityId")]
+    sender_identity_id: String,
+    #[serde(rename = "receiverIdentityId")]
+    receiver_identity_id: String,
+    account: u32,
+    #[serde(rename = "addressIndex")]
+    address_index: u32,
+    network: String,
+}
+
+#[wasm_bindgen(typescript_custom_section)]
+const DERIVE_DASHPAY_CONTACT_KEY_OPTS_TS: &'static str = r#"
+export interface DeriveDashpayContactKeyOptions {
+  mnemonic: string;
+  passphrase?: string | null;
+  senderIdentityId: string;
+  receiverIdentityId: string;
+  account: number;
+  addressIndex: number;
+  network: string;
+}
+"#;
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(typescript_type = "DeriveDashpayContactKeyOptions")]
+    pub type DeriveDashpayContactKeyOptionsJs;
+}
 #[wasm_bindgen]
 impl WasmSdk {
     /// Derive a key from seed phrase with extended path supporting 256-bit indices
     /// This supports DIP14/DIP15 paths with identity IDs
     #[wasm_bindgen(js_name = "deriveKeyFromSeedWithExtendedPath")]
     pub fn derive_key_from_seed_with_extended_path(
-        mnemonic: &str,
-        passphrase: Option<String>,
-        path: &str,
-        network: &str,
+        #[wasm_bindgen(unchecked_param_type = "DeriveKeyFromSeedWithExtendedPathOptions")] opts: JsValue,
     ) -> Result<JsValue, WasmSdkError> {
+        let DeriveFromExtendedPathInput { mnemonic, passphrase, path, network } = deserialize_required_query(
+            opts,
+            "Options object is required",
+            "deriveKeyFromSeedWithExtendedPath options",
+        )?;
         debug!(target : "wasm_sdk", path, "Processing extended path");
-        let seed = Self::mnemonic_to_seed(mnemonic, passphrase)?;
-        let net = match network {
+        let seed = Self::mnemonic_to_seed(&mnemonic, passphrase)?;
+        let net = match network.as_str() {
             "mainnet" => dashcore::Network::Dash,
             "testnet" => dashcore::Network::Testnet,
             _ => return Err(WasmSdkError::invalid_argument("Invalid network")),
         };
         let master_key = ExtendedPrivKey::new_master(net, &seed)
             .map_err(|e| WasmSdkError::generic(format!("Failed to create master key: {}", e)))?;
-        let derivation_path = DerivationPath::from_str(path).map_err(|e| {
+        let derivation_path = DerivationPath::from_str(&path).map_err(|e| {
             WasmSdkError::invalid_argument(format!("Invalid derivation path: {}", e))
         })?;
         let secp = Secp256k1::new();
@@ -41,7 +105,7 @@ impl WasmSdk {
         let public_key = private_key.public_key(&secp);
         let address = dashcore::Address::p2pkh(&public_key, net);
         let obj = js_sys::Object::new();
-        js_sys::Reflect::set(&obj, &JsValue::from_str("path"), &JsValue::from_str(path))
+        js_sys::Reflect::set(&obj, &JsValue::from_str("path"), &JsValue::from_str(&path))
             .map_err(|_| WasmSdkError::generic("Failed to set path property"))?;
         js_sys::Reflect::set(
             &obj,
@@ -70,7 +134,7 @@ impl WasmSdk {
         js_sys::Reflect::set(
             &obj,
             &JsValue::from_str("network"),
-            &JsValue::from_str(network),
+            &JsValue::from_str(&network),
         )
         .map_err(|_| WasmSdkError::generic("Failed to set network property"))?;
         js_sys::Reflect::set(
@@ -88,34 +152,34 @@ impl WasmSdk {
         Ok(obj.into())
     }
     /// Derive a DashPay contact key using DIP15 with full identity IDs
+    // Types decoded in parse step are defined at module scope
     #[wasm_bindgen(js_name = "deriveDashpayContactKey")]
     pub fn derive_dashpay_contact_key(
-        mnemonic: &str,
-        passphrase: Option<String>,
-        #[wasm_bindgen(js_name = "senderIdentityId")] sender_identity_id: &str,
-        #[wasm_bindgen(js_name = "receiverIdentityId")] receiver_identity_id: &str,
-        account: u32,
-        #[wasm_bindgen(js_name = "addressIndex")] address_index: u32,
-        network: &str,
+        #[wasm_bindgen(unchecked_param_type = "DeriveDashpayContactKeyOptions")] opts: JsValue,
     ) -> Result<JsValue, WasmSdkError> {
+        let DeriveDashpayContactKeyInput { mnemonic, passphrase, sender_identity_id, receiver_identity_id, account, address_index, network } = deserialize_required_query(
+            opts,
+            "Options object is required",
+            "deriveDashpayContactKey options",
+        )?;
         use bs58;
         let sender_id_formatted = if sender_identity_id.starts_with("0x") {
             sender_identity_id.to_string()
         } else {
-            let bytes = bs58::decode(sender_identity_id).into_vec().map_err(|e| {
+            let bytes = bs58::decode(&sender_identity_id).into_vec().map_err(|e| {
                 WasmSdkError::invalid_argument(format!("Invalid sender identity ID: {}", e))
             })?;
             format!("0x{}", hex::encode(bytes))
         };
         let receiver_id_formatted = if receiver_identity_id.starts_with("0x") {
             receiver_identity_id.to_string()
         } else {
-            let bytes = bs58::decode(receiver_identity_id).into_vec().map_err(|e| {
+            let bytes = bs58::decode(&receiver_identity_id).into_vec().map_err(|e| {
                 WasmSdkError::invalid_argument(format!("Invalid receiver identity ID: {}", e))
             })?;
             format!("0x{}", hex::encode(bytes))
         };
-        let coin_type = match network {
+        let coin_type = match network.as_str() {
             "mainnet" => 5,
             "testnet" => 1,
             _ => return Err(WasmSdkError::invalid_argument("Invalid network")),
@@ -125,8 +189,15 @@ impl WasmSdk {
             coin_type, 15, account, sender_id_formatted, receiver_id_formatted, address_index
         );
         debug!(target : "wasm_sdk", path = % path, "DashPay contact path");
-        let result =
-            Self::derive_key_from_seed_with_extended_path(mnemonic, passphrase, &path, network)?;
+        let opts = serde_json::json!({
+            "mnemonic": mnemonic,
+            "passphrase": passphrase,
+            "path": path,
+            "network": network,
+        });
+        let js_opts = serde_wasm_bindgen::to_value(&opts)
+            .map_err(|e| WasmSdkError::serialization(format!("Failed to serialize options: {}", e)))?;
+        let result = Self::derive_key_from_seed_with_extended_path(js_opts)?;
         let obj = result
             .dyn_into::<js_sys::Object>()
             .map_err(|_| WasmSdkError::generic("Failed to cast result to object"))?;
@@ -145,13 +216,13 @@ impl WasmSdk {
         js_sys::Reflect::set(
             &obj,
             &JsValue::from_str("senderIdentity"),
-            &JsValue::from_str(sender_identity_id),
+            &JsValue::from_str(&sender_identity_id),
         )
         .map_err(|_| WasmSdkError::generic("Failed to set senderIdentity property"))?;
         js_sys::Reflect::set(
             &obj,
             &JsValue::from_str("receiverIdentity"),
-            &JsValue::from_str(receiver_identity_id),
+            &JsValue::from_str(&receiver_identity_id),
         )
         .map_err(|_| WasmSdkError::generic("Failed to set receiverIdentity property"))?;
         js_sys::Reflect::set(
diff --git a/packages/wasm-sdk/src/wallet/key_derivation.rs b/packages/wasm-sdk/src/wallet/key_derivation.rs

Original file line number	Diff line number	Diff line change
`@@ -7,15 +7,13 @@ export class ProtocolFacade {`
`7`	`7`	`async versionUpgradeState(): Promise<any> { const w = await this.sdk.getWasmSdkConnected(); return w.getProtocolVersionUpgradeState(); }`
`8`	`8`	`async versionUpgradeStateWithProof(): Promise<any> { const w = await this.sdk.getWasmSdkConnected(); return w.getProtocolVersionUpgradeStateWithProofInfo(); }`
`9`	`9`
`10`		`- async versionUpgradeVoteStatus(params: { startProTxHash: string; count: number }): Promise<any> {`
`11`		`- const { startProTxHash, count } = params;`
	`10`	`+ async versionUpgradeVoteStatus(startProTxHash: string \| Uint8Array, count: number): Promise<any> {`
`12`	`11`	`const w = await this.sdk.getWasmSdkConnected();`
`13`		`- return w.getProtocolVersionUpgradeVoteStatus(startProTxHash, count);`
	`12`	`+ return w.getProtocolVersionUpgradeVoteStatus(startProTxHash as any, count);`
`14`	`13`	`}`
`15`	`14`
`16`		`- async versionUpgradeVoteStatusWithProof(params: { startProTxHash: string; count: number }): Promise<any> {`
`17`		`- const { startProTxHash, count } = params;`
	`15`	`+ async versionUpgradeVoteStatusWithProof(startProTxHash: string \| Uint8Array, count: number): Promise<any> {`
`18`	`16`	`const w = await this.sdk.getWasmSdkConnected();`
`19`		`- return w.getProtocolVersionUpgradeVoteStatusWithProofInfo(startProTxHash, count);`
	`17`	`+ return w.getProtocolVersionUpgradeVoteStatusWithProofInfo(startProTxHash as any, count);`
`20`	`18`	`}`
`21`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ export class TokensFacade {`
`60`	`60`	`return w.getIdentityTokenBalancesWithProofInfo(identityId, tokenIds);`
`61`	`61`	`}`
`62`	`62`
`63`		`- async identityTokenInfos(identityId: wasm.IdentifierLike, tokenIds: wasm.IdentifierLike[], _opts: { limit?: number; offset?: number } = {}): Promise<any> {`
	`63`	`+ async identityTokenInfos(identityId: wasm.IdentifierLike, tokenIds: wasm.IdentifierLike[]): Promise<any> {`
`64`	`64`	`const w = await this.sdk.getWasmSdkConnected();`
`65`	`65`	`return w.getIdentityTokenInfos(identityId, tokenIds);`
`66`	`66`	`}`