feat(wasm-sdk): add shielded pool WASM bindings and query methods

packages/js-dash-sdk/src/SDK/Client/Platform/Platform.ts

@@ -2,16 +2,16 @@
 import type { DPPModule } from '@dashevo/wasm-dpp';
 import crypto from 'crypto';
 
 import Client from '../Client';
 import { IStateTransitionResult } from './IStateTransitionResult';
 
 import createAssetLockTransaction from './createAssetLockTransaction';
 
 import broadcastDocument from './methods/documents/broadcast';
 import createDocument from './methods/documents/create';
 import getDocument from './methods/documents/get';
 
 import publishContract from './methods/contracts/publish';
 import updateContract from './methods/contracts/update';
 import createContract from './methods/contracts/create';
 import getContract from './methods/contracts/get';
@@ -34,6 +34,12 @@
 import searchName from './methods/names/search';
 import broadcastStateTransition from './broadcastStateTransition';
 
+import shieldMethod from './methods/shielded/shield';
+import shieldedTransferMethod from './methods/shielded/shieldedTransfer';
+import unshieldMethod from './methods/shielded/unshield';
+import shieldFromAssetLockMethod from './methods/shielded/shieldFromAssetLock';
+import shieldedWithdrawalMethod from './methods/shielded/shieldedWithdrawal';
+
 import logger, { ConfigurableLogger } from '../../../logger';
 import Fetcher from './Fetcher';
 import NonceManager from './NonceManager/NonceManager';
@@ -98,6 +104,14 @@
   history: Function,
 }
 
+interface Shielded {
+  shield: Function,
+  shieldedTransfer: Function,
+  unshield: Function,
+  shieldFromAssetLock: Function,
+  shieldedWithdrawal: Function,
+}
+
 /**
  * Class for Dash Platform
  *
@@ -117,6 +131,11 @@
 
   public documents: Records;
 
+  /**
+     * Shielded pool operations (shield, transfer, unshield)
+     */
+  public shielded: Shielded;
+
   /**
      * @param {Function} get - get identities from the platform
      * @param {Function} register - register identities on the platform
@@ -180,6 +199,13 @@
       resolveByRecord: resolveNameByRecord.bind(this),
       search: searchName.bind(this),
     };
+    this.shielded = {
+      shield: shieldMethod.bind(this),
+      shieldedTransfer: shieldedTransferMethod.bind(this),
+      unshield: unshieldMethod.bind(this),
+      shieldFromAssetLock: shieldFromAssetLockMethod.bind(this),
+      shieldedWithdrawal: shieldedWithdrawalMethod.bind(this),
+    };
     this.identities = {
       register: registerIdentity.bind(this),
       get: getIdentity.bind(this),

packages/js-dash-sdk/src/SDK/Client/Platform/methods/shielded/shield.ts

@@ -0,0 +1,38 @@
+import broadcastStateTransition from '../../broadcastStateTransition';
+import { Platform } from '../../Platform';
+import { IStateTransitionResult } from '../../IStateTransitionResult';
+
+/**
+ * Broadcast a shield transition (transparent platform addresses -> shielded pool).
+ *
+ * The Orchard bundle, platform address witnesses, and full state transition
+ * must be built externally (e.g., via rs-sdk's `shield_funds()` or a native
+ * wallet library) and serialized to platform binary format.
+ *
+ * @param serializedTransition - Platform-serialized ShieldTransition bytes
+ * @returns Broadcast result
+ */
+export async function shield(
+  this: Platform,
+  serializedTransition: Uint8Array,
+): Promise<IStateTransitionResult> {
+  this.logger.debug('[Shielded#shield] Broadcasting shield transition');
+  await this.initialize();
+
+  const { dpp } = this;
+
+  const transition = dpp.stateTransition.createFromBuffer(
+    serializedTransition,
+    {},
+  );
+
+  const result = await broadcastStateTransition(this, await transition, {
+    skipValidation: true,
+  });
+
+  this.logger.silly('[Shielded#shield] Broadcasted ShieldTransition');
+
+  return result;
+}
+
+export default shield;

packages/js-dash-sdk/src/SDK/Client/Platform/methods/shielded/shieldFromAssetLock.ts

@@ -0,0 +1,39 @@
+import broadcastStateTransition from '../../broadcastStateTransition';
+import { Platform } from '../../Platform';
+import { IStateTransitionResult } from '../../IStateTransitionResult';
+
+/**
+ * Broadcast a shield-from-asset-lock transition (core asset lock -> shielded pool).
+ *
+ * The Orchard bundle, asset lock proof, ECDSA signature, and full state
+ * transition must be built externally (e.g., via rs-sdk's
+ * `shield_from_asset_lock()` or a native wallet library) and serialized
+ * to platform binary format.
+ *
+ * @param serializedTransition - Platform-serialized ShieldFromAssetLockTransition bytes
+ * @returns Broadcast result
+ */
+export async function shieldFromAssetLock(
+  this: Platform,
+  serializedTransition: Uint8Array,
+): Promise<IStateTransitionResult> {
+  this.logger.debug('[Shielded#shieldFromAssetLock] Broadcasting shield from asset lock');
+  await this.initialize();
+
+  const { dpp } = this;
+
+  const transition = dpp.stateTransition.createFromBuffer(
+    serializedTransition,
+    {},
+  );
+
+  const result = await broadcastStateTransition(this, await transition, {
+    skipValidation: true,
+  });
+
+  this.logger.silly('[Shielded#shieldFromAssetLock] Broadcasted ShieldFromAssetLockTransition');
+
+  return result;
+}
+
+export default shieldFromAssetLock;

packages/js-dash-sdk/src/SDK/Client/Platform/methods/shielded/shieldedTransfer.ts

@@ -0,0 +1,41 @@
+import broadcastStateTransition from '../../broadcastStateTransition';
+import { Platform } from '../../Platform';
+import { IStateTransitionResult } from '../../IStateTransitionResult';
+
+/**
+ * Broadcast a shielded transfer (shielded-to-shielded) transition.
+ *
+ * The Orchard bundle and full state transition must be built externally
+ * (e.g., via rs-sdk's `transfer_shielded()` or a native wallet library)
+ * and serialized to platform binary format before passing here.
+ *
+ * Authentication is provided entirely by Orchard spend authorization
+ * signatures within the bundle — no identity signing needed.
+ *
+ * @param serializedTransition - Platform-serialized ShieldedTransferTransition bytes
+ * @returns Broadcast result
+ */
+export async function shieldedTransfer(
+  this: Platform,
+  serializedTransition: Uint8Array,
+): Promise<IStateTransitionResult> {
+  this.logger.debug('[Shielded#shieldedTransfer] Broadcasting shielded transfer');
+  await this.initialize();
+
+  const { dpp } = this;
+
+  const transition = dpp.stateTransition.createFromBuffer(
+    serializedTransition,
+    {},
+  );
+
+  const result = await broadcastStateTransition(this, await transition, {
+    skipValidation: true,
+  });
+
+  this.logger.silly('[Shielded#shieldedTransfer] Broadcasted ShieldedTransferTransition');
+
+  return result;
+}
+
+export default shieldedTransfer;

packages/js-dash-sdk/src/SDK/Client/Platform/methods/shielded/shieldedWithdrawal.ts

@@ -0,0 +1,41 @@
+import broadcastStateTransition from '../../broadcastStateTransition';
+import { Platform } from '../../Platform';
+import { IStateTransitionResult } from '../../IStateTransitionResult';
+
+/**
+ * Broadcast a shielded withdrawal transition (shielded pool -> core L1 address).
+ *
+ * The Orchard bundle and full state transition must be built externally
+ * (e.g., via rs-sdk's `withdraw_shielded()` or a native wallet library)
+ * and serialized to platform binary format.
+ *
+ * The platform sighash binds `outputScript || amount` to prevent
+ * an attacker from substituting a different L1 destination or amount.
+ *
+ * @param serializedTransition - Platform-serialized ShieldedWithdrawalTransition bytes
+ * @returns Broadcast result
+ */
+export async function shieldedWithdrawal(
+  this: Platform,
+  serializedTransition: Uint8Array,
+): Promise<IStateTransitionResult> {
+  this.logger.debug('[Shielded#shieldedWithdrawal] Broadcasting shielded withdrawal');
+  await this.initialize();
+
+  const { dpp } = this;
+
+  const transition = dpp.stateTransition.createFromBuffer(
+    serializedTransition,
+    {},
+  );
+
+  const result = await broadcastStateTransition(this, await transition, {
+    skipValidation: true,
+  });
+
+  this.logger.silly('[Shielded#shieldedWithdrawal] Broadcasted ShieldedWithdrawalTransition');
+
+  return result;
+}
+
+export default shieldedWithdrawal;

packages/js-dash-sdk/src/SDK/Client/Platform/methods/shielded/unshield.ts

@@ -0,0 +1,41 @@
+import broadcastStateTransition from '../../broadcastStateTransition';
+import { Platform } from '../../Platform';
+import { IStateTransitionResult } from '../../IStateTransitionResult';
+
+/**
+ * Broadcast an unshield transition (shielded pool -> platform address).
+ *
+ * The Orchard bundle and full state transition must be built externally
+ * (e.g., via rs-sdk's `unshield_funds()` or a native wallet library)
+ * and serialized to platform binary format.
+ *
+ * The platform sighash binds `outputAddress || amount` to prevent
+ * an attacker from substituting a different destination or amount.
+ *
+ * @param serializedTransition - Platform-serialized UnshieldTransition bytes
+ * @returns Broadcast result
+ */
+export async function unshield(
+  this: Platform,
+  serializedTransition: Uint8Array,
+): Promise<IStateTransitionResult> {
+  this.logger.debug('[Shielded#unshield] Broadcasting unshield transition');
+  await this.initialize();
+
+  const { dpp } = this;
+
+  const transition = dpp.stateTransition.createFromBuffer(
+    serializedTransition,
+    {},
+  );
+
+  const result = await broadcastStateTransition(this, await transition, {
+    skipValidation: true,
+  });
+
+  this.logger.silly('[Shielded#unshield] Broadcasted UnshieldTransition');
+
+  return result;
+}
+
+export default unshield;

packages/wasm-dpp/src/identity/state_transition/transition_types.rs

@@ -19,6 +19,11 @@ pub enum StateTransitionTypeWasm {
     AddressFundsTransfer = 12,
     AddressFundingFromAssetLock = 13,
     AddressCreditWithdrawal = 14,
+    Shield = 15,
+    ShieldedTransfer = 16,
+    Unshield = 17,
+    ShieldFromAssetLock = 18,
+    ShieldedWithdrawal = 19,
 }
 
 impl From<StateTransitionType> for StateTransitionTypeWasm {
@@ -55,7 +60,13 @@ impl From<StateTransitionType> for StateTransitionTypeWasm {
             StateTransitionType::AddressCreditWithdrawal => {
                 StateTransitionTypeWasm::AddressCreditWithdrawal
             }
-            _ => todo!("shielded state transition types not yet implemented in wasm"),
+            StateTransitionType::Shield => StateTransitionTypeWasm::Shield,
+            StateTransitionType::ShieldedTransfer => StateTransitionTypeWasm::ShieldedTransfer,
+            StateTransitionType::Unshield => StateTransitionTypeWasm::Unshield,
+            StateTransitionType::ShieldFromAssetLock => {
+                StateTransitionTypeWasm::ShieldFromAssetLock
+            }
+            StateTransitionType::ShieldedWithdrawal => StateTransitionTypeWasm::ShieldedWithdrawal,
         }
     }
 }

packages/wasm-dpp/src/state_transition/state_transition_factory.rs

@@ -79,12 +79,20 @@ impl StateTransitionFactoryWasm {
                 StateTransition::AddressCreditWithdrawal(st) => {
                     serde_wasm_bindgen::to_value(&st).map_err(|e| JsValue::from(e.to_string()))
                 }
-                StateTransition::Shield(_)
-                | StateTransition::ShieldedTransfer(_)
-                | StateTransition::Unshield(_)
-                | StateTransition::ShieldFromAssetLock(_)
-                | StateTransition::ShieldedWithdrawal(_) => {
-                    todo!("shielded transitions not yet implemented in state_transition_factory")
+                StateTransition::Shield(st) => {
+                    serde_wasm_bindgen::to_value(&st).map_err(|e| JsValue::from(e.to_string()))
+                }
+                StateTransition::ShieldedTransfer(st) => {
+                    serde_wasm_bindgen::to_value(&st).map_err(|e| JsValue::from(e.to_string()))
+                }
+                StateTransition::Unshield(st) => {
+                    serde_wasm_bindgen::to_value(&st).map_err(|e| JsValue::from(e.to_string()))
+                }
+                StateTransition::ShieldFromAssetLock(st) => {
+                    serde_wasm_bindgen::to_value(&st).map_err(|e| JsValue::from(e.to_string()))
+                }
+                StateTransition::ShieldedWithdrawal(st) => {
+                    serde_wasm_bindgen::to_value(&st).map_err(|e| JsValue::from(e.to_string()))
                 }
             },
             Err(dpp::ProtocolError::StateTransitionError(e)) => match e {

packages/wasm-dpp2/src/lib.rs

@@ -24,6 +24,7 @@ pub mod mock_bls;
 pub mod platform_address;
 pub mod public_key;
 pub mod serialization;
+pub mod shielded;
 pub mod state_transitions;
 pub mod tokens;
 pub mod utils;
@@ -66,6 +67,10 @@ pub use platform_address::{
     PlatformAddressWasm, default_fee_strategy, fee_strategy_from_steps,
     fee_strategy_from_steps_or_default, outputs_to_btree_map, outputs_to_optional_btree_map,
 };
+pub use shielded::{
+    ShieldFromAssetLockTransitionWasm, ShieldTransitionWasm, ShieldedTransferTransitionWasm,
+    ShieldedWithdrawalTransitionWasm, UnshieldTransitionWasm,
+};
 pub use state_transitions::base::{GroupStateTransitionInfoWasm, StateTransitionWasm};
 pub use state_transitions::proof_result::{StateTransitionProofResultTypeJs, convert_proof_result};
 pub use tokens::*;

packages/wasm-dpp2/src/shielded/mod.rs

@@ -0,0 +1,37 @@
+pub mod shield_from_asset_lock_transition;
+pub mod shield_transition;
+pub mod shielded_transfer_transition;
+pub mod shielded_withdrawal_transition;
+pub mod unshield_transition;
+
+pub use shield_from_asset_lock_transition::ShieldFromAssetLockTransitionWasm;
+pub use shield_transition::ShieldTransitionWasm;
+pub use shielded_transfer_transition::ShieldedTransferTransitionWasm;
+pub use shielded_withdrawal_transition::ShieldedWithdrawalTransitionWasm;
+pub use unshield_transition::UnshieldTransitionWasm;
+
+use crate::error::WasmDppResult;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+/// Compute the platform sighash from an Orchard bundle commitment and extra data.
+///
+/// `sighash = SHA-256("DashPlatformSighash" || bundleCommitment || extraData)`
+///
+/// - For shield and shielded_transfer transitions, `extraData` should be empty.
+/// - For unshield transitions, `extraData` = `outputAddress || amount (LE u64)`.
+/// - For shielded withdrawal transitions, `extraData` = `outputScript || amount (LE u64)`.
+#[wasm_bindgen(js_name = computePlatformSighash)]
+pub fn compute_platform_sighash_wasm(
+    bundle_commitment: &[u8],
+    extra_data: &[u8],
+) -> WasmDppResult<Vec<u8>> {
+    if bundle_commitment.len() != 32 {
+        return Err(crate::error::WasmDppError::invalid_argument(&format!(
+            "bundleCommitment must be exactly 32 bytes, got {}",
+            bundle_commitment.len()
+        )));
+    }
+    let commitment: &[u8; 32] = bundle_commitment.try_into().expect("checked length above");
+    let result = dpp::shielded::compute_platform_sighash(commitment, extra_data);
+    Ok(result.to_vec())
+}