fix(platform-wallet): map NoUtxosAvailable to the typed asset-lock insufficient-funds error

Addresses carried review finding prior-no-utxos-846 on dashpay#4074.

The union-funding coin selector returns SelectionError::NoUtxosAvailable when
filtering leaves zero spendable candidates — the most extreme shortfall — but
map_builder_error only promoted the two InsufficientFunds variants to the typed
PlatformWalletError::AssetLockInsufficientFunds, so the empty candidate set fell
through to the generic AssetLockTransaction(String) while partial shortfalls
stayed typed. Hosts then had to string-match to recognize the zero-funds case.

NoUtxosAvailable carries no amounts, so map_builder_error now takes the caller's
requested target and maps this case to AssetLockInsufficientFunds { available: 0,
required: requested }, keeping the empty set on the same structured shortfall
contract dashpay#4073 introduced. Carried InsufficientFunds amounts still win over the
requested arg. No third_party changes. Unit test covers both mappings.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: bfoss765

packages/rs-platform-wallet/src/wallet/asset_lock/build.rs

@@ -358,7 +358,7 @@ impl<B: TransactionBroadcaster + ?Sized> AssetLockManager<B> {
         let (transaction, fee) = builder
             .build_signed(signer, move |addr| path_map.get(&addr).cloned())
             .await
-            .map_err(map_builder_error)?;
+            .map_err(|e| map_builder_error(e, target_duffs))?;
         tracing::debug!(
             selected_inputs = transaction.input.len(),
             fee,
@@ -1000,13 +1000,20 @@ impl<B: TransactionBroadcaster + ?Sized> AssetLockManager<B> {
 }
 
 /// Map a key-wallet [`BuilderError`] to a [`PlatformWalletError`], promoting
-/// the two shortfall shapes (`BuilderError::InsufficientFunds` and a
-/// coin-selection `SelectionError::InsufficientFunds`) to the typed
-/// [`PlatformWalletError::AssetLockInsufficientFunds`] so the exact
-/// `available`/`required` duff amounts survive instead of being flattened into
-/// a string (dashpay/platform#4073's typed-error ask). Every other builder
-/// error keeps the generic `AssetLockTransaction` string form.
-fn map_builder_error(e: BuilderError) -> PlatformWalletError {
+/// every shortfall shape to the typed
+/// [`PlatformWalletError::AssetLockInsufficientFunds`] so callers get one
+/// structured shortfall contract (dashpay/platform#4073's typed-error ask)
+/// instead of a string they must pattern-match:
+///   - `BuilderError::InsufficientFunds` / `SelectionError::InsufficientFunds`
+///     carry their own exact `available`/`required` duff amounts — preserved.
+///   - `SelectionError::NoUtxosAvailable` — the zero-spendable-candidate case,
+///     the MOST extreme shortfall — carries no amounts, so it previously fell
+///     through to the generic string form while partial shortfalls stayed typed
+///     (dashpay/platform#4074 prior-no-utxos-846). It now maps to `available: 0`
+///     with the caller's `requested` target as `required`, keeping the empty
+///     candidate set on the same structured path.
+/// Every other builder error keeps the generic `AssetLockTransaction` string.
+fn map_builder_error(e: BuilderError, requested: u64) -> PlatformWalletError {
     match e {
         BuilderError::InsufficientFunds {
             available,
@@ -1019,6 +1026,12 @@ fn map_builder_error(e: BuilderError) -> PlatformWalletError {
             available,
             required,
         },
+        BuilderError::CoinSelection(SelectionError::NoUtxosAvailable) => {
+            PlatformWalletError::AssetLockInsufficientFunds {
+                available: 0,
+                required: requested,
+            }
+        }
         other => {
             PlatformWalletError::AssetLockTransaction(format!("Asset lock builder failed: {other}"))
         }
@@ -1052,6 +1065,49 @@ mod tests {
     use crate::wallet::platform_wallet::WalletId;
     use crate::{AssetLockFundingType, PlatformWalletError};
 
+    /// prior-no-utxos-846 (dashpay/platform#4074): the zero-spendable-candidate
+    /// selection error must surface the SAME typed shortfall as a partial
+    /// shortfall (not the generic string), so hosts stay on one structured path;
+    /// and a partial shortfall must still carry its own exact amounts.
+    #[test]
+    fn no_utxos_available_maps_to_typed_insufficient_funds() {
+        use super::{map_builder_error, BuilderError, SelectionError};
+
+        // Zero spendable candidates -> typed, available: 0, required = requested.
+        match map_builder_error(
+            BuilderError::CoinSelection(SelectionError::NoUtxosAvailable),
+            12_345,
+        ) {
+            PlatformWalletError::AssetLockInsufficientFunds {
+                available,
+                required,
+            } => {
+                assert_eq!(available, 0, "empty candidate set means nothing available");
+                assert_eq!(required, 12_345, "requested target threaded through as required");
+            }
+            other => panic!("expected typed AssetLockInsufficientFunds, got {other:?}"),
+        }
+
+        // A partial shortfall keeps its own exact amounts; the requested arg is
+        // NOT substituted for the builder's carried values.
+        match map_builder_error(
+            BuilderError::CoinSelection(SelectionError::InsufficientFunds {
+                available: 100,
+                required: 500,
+            }),
+            999,
+        ) {
+            PlatformWalletError::AssetLockInsufficientFunds {
+                available,
+                required,
+            } => {
+                assert_eq!(available, 100);
+                assert_eq!(required, 500, "carried amounts win over the requested arg");
+            }
+            other => panic!("expected typed AssetLockInsufficientFunds, got {other:?}"),
+        }
+    }
+
     /// Persistence stub that records every stored changeset so tests can
     /// assert what the asset-lock flow queued.
     #[derive(Default)]