dashpay · lklimek · May 22, 2026 · May 22, 2026 · May 22, 2026 · May 22, 2026
@@ -155,7 +155,13 @@ shielded = ["dep:grovedb-commitment-tree", "dep:rusqlite", "dep:zip32", "dep:fut
 # runs the network-dependent harness. Pulls in `shielded` so an e2e run
 # exercises the shielded-pool cases too. Run with:
 # `cargo test -p platform-wallet --test e2e --features e2e`.
-e2e = ["shielded"]
+e2e = ["shielded", "test-utils"]
+# Test-only seams that expose internal shielded spend-assembly
+# (extract-spends, note reservation, build-against-a-chosen-note, and an
+# asset-lock one-time-key derivation helper) for the adversarial e2e
+# cases. NOT in `default`; pulled in by `e2e`. Never enable in production
+# builds — these bypass the wallet's spend guards by design.
+test-utils = ["shielded"]
 # Opt-in serde derives on the changeset types. Activates `key-wallet/serde`,
 # `key-wallet-manager/serde`, and `dash-sdk/serde`. `dpp` derives serde unconditionally.
 serde = [

@@ -224,7 +224,7 @@ async fn run_wallet_balance_test(wallet: WalletIndex) {
     let manager = Arc::new(PlatformWalletManager::new(
         Arc::clone(&sdk),
         persister,
-        event_handler,
+        vec![event_handler],
     ));
 
     // --- 3. Configure shielded support (creates the SQLite store) ---

@@ -205,7 +205,7 @@ async fn main() {
     let manager = Arc::new(PlatformWalletManager::new(
         Arc::clone(&sdk),
         persister,
-        event_handler,
+        vec![event_handler],
     ));
 
     let shielded_db_dir = std::env::temp_dir().join(format!(

@@ -632,7 +632,17 @@ impl PlatformWallet {
                         "invalid platform address: {e}"
                     ))
                 })?;
-        if addr_network != self.sdk.network {
+        // Interim unblock: the bech32m decoder lossily maps `tdash` → Testnet,
+        // so a devnet recipient decodes as Testnet. Accept a Testnet-decoded
+        // address on a Devnet/Regtest wallet. Superseded by #3781 (a
+        // network-agnostic decoder + HRP-class guard).
+        let networks_match = addr_network == self.sdk.network
+            || (addr_network == dashcore::Network::Testnet
+                && matches!(
+                    self.sdk.network,
+                    dashcore::Network::Devnet | dashcore::Network::Regtest
+                ));
+        if !networks_match {
             return Err(PlatformWalletError::ShieldedBuildError(format!(
                 "platform address network mismatch: address {addr_network:?}, wallet {:?}",
                 self.sdk.network
@@ -844,6 +854,55 @@ impl PlatformWallet {
         )
         .await
     }
+
+    /// Shield credits from a Core L1 asset lock into the wallet's
+    /// shielded pool (Type 18), with the resulting note assigned to
+    /// `shielded_account`'s default Orchard address.
+    ///
+    /// `asset_lock_proof` is the single-use proof of the locked L1
+    /// outpoint and `private_key` the one-time key authorizing it (the
+    /// caller derives both via the asset-lock builder). `amount` is the
+    /// shielded value. Uses `broadcast_and_wait` for proven inclusion —
+    /// important because the proof is single-use, so a false-positive on
+    /// a later-rejected transition would strand the L1 outpoint.
+    ///
+    /// Mirrors the other four spend wrappers
+    /// ([`shielded_shield_from_account`](Self::shielded_shield_from_account),
+    /// [`shielded_transfer_to`](Self::shielded_transfer_to),
+    /// [`shielded_unshield_to`](Self::shielded_unshield_to),
+    /// [`shielded_withdraw_to`](Self::shielded_withdraw_to)) and delegates
+    /// to `operations::shield_from_asset_lock`. Returns `ShieldedNotBound`
+    /// if no shielded sub-wallet is bound, or `ShieldedKeyDerivation` if
+    /// `shielded_account` isn't bound on it.
+    #[cfg(feature = "shielded")]
+    pub async fn shielded_shield_from_asset_lock<P: dpp::shielded::builder::OrchardProver>(
+        &self,
+        shielded_account: u32,
+        asset_lock_proof: dpp::prelude::AssetLockProof,
+        private_key: &[u8],
+        amount: u64,
+        prover: P,
+    ) -> Result<(), PlatformWalletError> {
+        let guard = self.shielded_keys.read().await;
+        let keys = guard
+            .as_ref()
+            .ok_or(PlatformWalletError::ShieldedNotBound)?;
+        let keyset = keys.get(&shielded_account).ok_or_else(|| {
+            PlatformWalletError::ShieldedKeyDerivation(format!(
+                "shielded account {shielded_account} not bound"
+            ))
+        })?;
+        super::shielded::operations::shield_from_asset_lock(
+            &self.sdk,
+            keyset,
+            shielded_account,
+            asset_lock_proof,
+            private_key,
+            amount,
+            &prover,
+        )
+        .await
+    }
 }
 
 impl PlatformWallet {