fix(sdk): masternodeVote takes the ProTxHash as an Identifier and returns the vote (#5138)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: QuantumExplorer

packages/js-evo-sdk/src/voting/facade.ts

@@ -53,7 +53,7 @@ export class VotingFacade {
     return w.getVotePollsByEndDateWithProofInfo(query);
   }
 
-  async masternodeVote(options: wasm.MasternodeVoteOptions): Promise<void> {
+  async masternodeVote(options: wasm.MasternodeVoteOptions): Promise<wasm.Vote> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.masternodeVote(options);
   }

packages/js-evo-sdk/tests/unit/facades/voting.spec.ts

@@ -21,6 +21,7 @@ describe('VotingFacade', () => {
   let getVotePollsByEndDateStub: SinonStub;
   let getVotePollsByEndDateWithProofInfoStub: SinonStub;
   let masternodeVoteStub: SinonStub;
+  let recordedVote: wasmSDKPackage.Vote;
 
   beforeEach(async function setup() {
     await init();
@@ -60,9 +61,8 @@ describe('VotingFacade', () => {
     });
 
     // Stub transition method
-    masternodeVoteStub = this.sinon.stub(wasmSdk, 'masternodeVote').resolves({
-      success: true,
-    });
+    recordedVote = Object.create(wasmSDKPackage.Vote.prototype);
+    masternodeVoteStub = this.sinon.stub(wasmSdk, 'masternodeVote').resolves(recordedVote);
   });
 
   describe('contestedResourceVoteState()', () => {
@@ -167,7 +167,7 @@ describe('VotingFacade', () => {
   });
 
   describe('masternodeVote()', () => {
-    it('should cast a vote on a contested resource', async () => {
+    it('should cast a vote on a contested resource and return the recorded vote', async () => {
       const options = {
         masternodeProTxHash,
         contractId: dataContractId,
@@ -178,9 +178,10 @@ describe('VotingFacade', () => {
         signer,
       };
 
-      await client.voting.masternodeVote(options);
+      const vote = await client.voting.masternodeVote(options);
 
       expect(masternodeVoteStub).to.be.calledOnceWithExactly(options);
+      expect(vote).to.equal(recordedVote);
     });
 
     it('should support abstain vote choice', async () => {

packages/wasm-sdk/src/state_transitions/identity.rs

@@ -12,12 +12,18 @@ use dash_sdk::dpp::identity::identity_public_key::accessors::v0::IdentityPublicK
 use dash_sdk::dpp::identity::signer::Signer;
 use dash_sdk::dpp::identity::{Identity, IdentityPublicKey, KeyType, Purpose, SecurityLevel};
 use dash_sdk::dpp::platform_value::Identifier;
+use dash_sdk::dpp::voting::vote_choices::resource_vote_choice::ResourceVoteChoice;
+use dash_sdk::dpp::voting::vote_polls::VotePoll;
+use dash_sdk::dpp::voting::votes::resource_vote::v0::ResourceVoteV0;
+use dash_sdk::dpp::voting::votes::resource_vote::ResourceVote;
+use dash_sdk::dpp::voting::votes::Vote;
 use dash_sdk::platform::transition::broadcast::BroadcastStateTransition;
 use dash_sdk::platform::transition::put_identity::PutIdentity;
 use dash_sdk::platform::transition::top_up_identity::TopUpIdentity;
 use dash_sdk::platform::transition::update_identity_key_limits::{
     raised_key_limits, UpdateIdentityKeyLimits,
 };
+use dash_sdk::platform::transition::vote::PutVote;
 use js_sys::BigInt;
 use serde::Deserialize;
 use wasm_bindgen::prelude::*;
@@ -28,6 +34,9 @@ use wasm_dpp2::utils::{
     try_from_options_optional, try_from_options_optional_with, try_from_options_with, try_to_array,
     try_to_u64, IntoWasm,
 };
+use wasm_dpp2::voting::resource_vote_choice::ResourceVoteChoiceWasm;
+use wasm_dpp2::voting::vote::VoteWasm;
+use wasm_dpp2::voting::vote_poll::VotePollWasm;
 use wasm_dpp2::PrivateKeyWasm;
 use wasm_dpp2::{IdentityPublicKeyInCreationWasm, IdentitySignerWasm, IdentityWasm};
 
@@ -714,9 +723,10 @@ const MASTERNODE_VOTE_OPTIONS_TS: &'static str = r#"
  */
 export interface MasternodeVoteOptions {
   /**
-   * The ProTxHash of the masternode.
+   * The ProTxHash of the masternode: an Identifier, its 32 bytes, the hex Core's RPC shows,
+   * or base58.
    */
-  masternodeProTxHash: Identifier;
+  masternodeProTxHash: IdentifierLike;
 
   /**
    * The vote poll to vote on.
@@ -756,84 +766,49 @@ extern "C" {
     pub type MasternodeVoteOptionsJs;
 }
 
-/// Main input struct for masternode vote options.
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct MasternodeVoteOptionsInput {
-    masternode_pro_tx_hash: IdentifierWasm,
-}
-
-fn deserialize_masternode_vote_options(
-    options: JsValue,
-) -> Result<MasternodeVoteOptionsInput, WasmSdkError> {
-    deserialize_required_query(
-        options,
-        "Options object is required",
-        "masternode vote options",
-    )
-}
-
 #[wasm_bindgen]
 impl WasmSdk {
     /// Submit a masternode vote for a contested resource.
     ///
     /// This method handles the complete voting flow:
-    /// 1. Creates the voting public key from the signer
-    /// 2. Builds and signs the vote transition
-    /// 3. Broadcasts and waits for confirmation
+    /// 1. Builds and signs the vote transition with the voting key
+    /// 2. Broadcasts it and waits for the block that records it
+    /// 3. Verifies the proof of the recorded vote
     ///
-    /// @param options - Vote options including masternode ID, vote poll, choice, and signer
-    /// @returns Promise that resolves when the vote is submitted
+    /// @param options - Vote options including masternode ProTxHash, vote poll, choice, and signer
+    /// @returns The vote as Platform recorded it
     #[wasm_bindgen(js_name = "masternodeVote")]
     pub async fn masternode_vote(
         &self,
         options: MasternodeVoteOptionsJs,
-    ) -> Result<(), WasmSdkError> {
-        use wasm_dpp2::voting::resource_vote_choice::ResourceVoteChoiceWasm;
-        use wasm_dpp2::voting::vote_poll::VotePollWasm;
-
-        // Extract complex types first (borrows &options)
-        let vote_poll: dash_sdk::dpp::voting::vote_polls::VotePoll =
-            VotePollWasm::try_from_options(&options, "votePoll")?.into();
-        let resource_vote_choice: dash_sdk::dpp::voting::vote_choices::resource_vote_choice::ResourceVoteChoice =
+    ) -> Result<VoteWasm, WasmSdkError> {
+        let pro_tx_hash: Identifier =
+            IdentifierWasm::try_from_options(&options, "masternodeProTxHash")?.into();
+        let vote_poll: VotePoll = VotePollWasm::try_from_options(&options, "votePoll")?.into();
+        let resource_vote_choice: ResourceVoteChoice =
             ResourceVoteChoiceWasm::try_from_options(&options, "voteChoice")?.into();
         let voting_public_key: IdentityPublicKey =
             IdentityPublicKeyWasm::try_from_options(&options, "votingKey")?.into();
         let signer = IdentitySignerWasm::try_from_options(&options, "signer")?;
         let settings =
             try_from_options_optional::<PutSettingsInput>(&options, "settings")?.map(Into::into);
 
-        // Deserialize simple fields last (consumes options)
-        let parsed = deserialize_masternode_vote_options(options.into())?;
-
-        // Convert ProTxHash
-        let pro_tx_hash: Identifier = parsed.masternode_pro_tx_hash.into();
-
-        // Create the resource vote
-        use dash_sdk::dpp::voting::votes::resource_vote::v0::ResourceVoteV0;
-        use dash_sdk::dpp::voting::votes::resource_vote::ResourceVote;
-        let resource_vote = ResourceVote::V0(ResourceVoteV0 {
+        let vote = Vote::ResourceVote(ResourceVote::V0(ResourceVoteV0 {
             vote_poll,
             resource_vote_choice,
-        });
+        }));
 
-        // Create the vote
-        use dash_sdk::dpp::voting::votes::Vote;
-        let vote = Vote::ResourceVote(resource_vote);
-
-        // Submit the vote using PutVote trait
-        use dash_sdk::platform::transition::vote::PutVote;
-
-        vote.put_to_platform(
-            pro_tx_hash,
-            &voting_public_key,
-            self.inner_sdk(),
-            &signer,
-            settings,
-        )
-        .await?;
+        let recorded_vote = vote
+            .put_to_platform_and_wait_for_response(
+                pro_tx_hash,
+                &voting_public_key,
+                self.inner_sdk(),
+                &signer,
+                settings,
+            )
+            .await?;
 
-        Ok(())
+        Ok(recorded_vote.into())
     }
 }
 

packages/wasm-sdk/tests/unit/masternode-vote.spec.ts

@@ -0,0 +1,50 @@
+/**
+ * `masternodeVote` takes the masternode's ProTxHash as an `IdentifierLike` and reads it before
+ * the other options, so a call whose only fault is its missing vote poll fails on the vote poll:
+ * its ProTxHash was accepted, and nothing reached the network.
+ */
+import { expect } from './helpers/chai.ts';
+import init, * as sdk from '../../dist/sdk.compressed.js';
+
+const proTxHashHex = 'a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2';
+
+async function rejectionOf(promise: Promise<unknown>): Promise<Error> {
+  try {
+    await promise;
+  } catch (e) {
+    return e as Error;
+  }
+  throw new Error('expected the vote to be refused');
+}
+
+describe('masternodeVote()', () => {
+  let client: sdk.WasmSdk;
+
+  before(async () => {
+    await init();
+    client = await sdk.WasmSdkBuilder.testnet().build();
+  });
+
+  const accepted: Array<[string, () => unknown]> = [
+    ['an Identifier', () => new sdk.Identifier(proTxHashHex)],
+    ['its 32 bytes', () => new sdk.Identifier(proTxHashHex).toBytes()],
+    ['the hex Core shows', () => proTxHashHex],
+    ['base58', () => new sdk.Identifier(proTxHashHex).toBase58()],
+  ];
+
+  accepted.forEach(([form, proTxHash]) => {
+    it(`should accept the ProTxHash as ${form}`, async () => {
+      const error = await rejectionOf(client.masternodeVote({
+        masternodeProTxHash: proTxHash(),
+      } as never));
+      expect(error.message).to.match(/'votePoll' is required/);
+    });
+  });
+
+  it('should refuse a ProTxHash that is not an identifier before the vote poll', async () => {
+    const error = await rejectionOf(client.masternodeVote({
+      masternodeProTxHash: 42,
+    } as never));
+    expect(error.message).to.not.match(/votePoll/);
+  });
+});