Reject silent payment addresses with clear error

Pasting a BIP352 silent payment address (sp1... / tsp1...) surfaces
a generic "Invalid Address" error today, which is confusing because
the string looks like a valid bech32m address. Match the SP prefixes
up front in both AddressWithNetwork::try_new and Address::from_string
and raise a dedicated SilentPaymentNotSupported variant so users
learn the format is understood but blocked, not malformed.

Refs #617

Author: guptapratykshh

android/app/src/main/java/org/bitcoinppl/cove/flows/SendFlow/SendFlowPresenter.kt

@@ -80,6 +80,7 @@ class SendFlowPresenter(
             is SendFlowException.EmptyAddress,
             is SendFlowException.InvalidAddress,
             is SendFlowException.WrongNetwork,
+            is SendFlowException.SilentPaymentNotSupported,
             -> "Invalid Address"
 
             is SendFlowException.InvalidNumber,
@@ -152,6 +153,9 @@ class SendFlowPresenter(
 
             is SendFlowException.UnableToSaveUnsignedTransaction ->
                 error.v1
+
+            is SendFlowException.SilentPaymentNotSupported ->
+                "Sending to silent payment addresses (sp1...) is not yet supported. Support is coming soon."
         }
 
     /**
@@ -171,6 +175,7 @@ class SendFlowPresenter(
             is SendFlowException.EmptyAddress,
             is SendFlowException.WrongNetwork,
             is SendFlowException.InvalidAddress,
+            is SendFlowException.SilentPaymentNotSupported,
             -> {
                 {
                     alertState = null

ios/Cove/Flows/SendFlow/SendFlowPresenter.swift

@@ -71,7 +71,7 @@ import SwiftUI
 
     private func errorAlertTitle(_ error: SendFlowError) -> String {
         switch error {
-        case .EmptyAddress, .InvalidAddress, .WrongNetwork:
+        case .EmptyAddress, .InvalidAddress, .WrongNetwork, .SilentPaymentNotSupported:
             "Invalid Address"
         case .InvalidNumber, .ZeroAmount: "Invalid Amount"
         case .InsufficientFunds, .NoBalance: "Insufficient Funds"
@@ -129,6 +129,8 @@ import SwiftUI
             msg
         case let .UnableToSaveUnsignedTransaction(msg):
             msg
+        case .SilentPaymentNotSupported:
+            "Sending to silent payment addresses (sp1...) is not yet supported. Support is coming soon."
         }
     }
 
@@ -145,7 +147,7 @@ import SwiftUI
     @ViewBuilder
     private func errorAlertButtons(_ error: SendFlowError) -> some View {
         switch error {
-        case .EmptyAddress, .WrongNetwork, .InvalidAddress:
+        case .EmptyAddress, .WrongNetwork, .InvalidAddress, .SilentPaymentNotSupported:
             Button("OK") {
                 self.alertState = .none
                 self.focusField = .address

rust/crates/cove-types/src/address.rs

@@ -84,6 +84,9 @@ pub enum AddressError {
 
     #[error("empty address")]
     EmptyAddress,
+
+    #[error("silent payment addresses (sp1...) are not yet supported for sending")]
+    SilentPaymentNotSupported,
 }
 
 impl Clone for AddressInfo {
@@ -169,6 +172,10 @@ impl AddressWithNetwork {
     pub fn try_new(str: &str) -> Result<Self, Error> {
         let (address_str, amount) = parse_bitcoin_uri(str)?;
 
+        if is_silent_payment_address(&address_str) {
+            return Err(Error::SilentPaymentNotSupported);
+        }
+
         let address: BdkAddress<NetworkUnchecked> =
             address_str.parse().map_err(|_| Error::InvalidAddress)?;
 
@@ -198,6 +205,12 @@ impl AddressWithNetwork {
     }
 }
 
+fn is_silent_payment_address(s: &str) -> bool {
+    let lower = s.trim().to_lowercase();
+    // BIP352: mainnet SP addresses start with "sp1q", testnet/signet with "tsp1q"
+    lower.starts_with("sp1q") || lower.starts_with("tsp1q")
+}
+
 fn parse_bitcoin_uri(input: &str) -> Result<(String, Option<Amount>), Error> {
     let input = input.trim();
     if input.is_empty() {
@@ -275,6 +288,11 @@ impl Address {
     #[uniffi::constructor]
     pub fn from_string(address: &str, network: Network) -> Result<Self> {
         let address = address.trim();
+
+        if is_silent_payment_address(address) {
+            return Err(Error::SilentPaymentNotSupported);
+        }
+
         let bdk_address = BdkAddress::from_str(address).map_err(|_| Error::InvalidAddress)?;
 
         let bitcoin_network: bitcoin::Network = network.into();
@@ -492,6 +510,27 @@ mod tests {
         assert_eq!(amount, None);
     }
 
+    #[test]
+    fn test_silent_payment_address_detection() {
+        // mainnet SP address returns SilentPaymentNotSupported instead of InvalidAddress
+        let result = AddressWithNetwork::try_new(
+            "sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtsgpc7kytsk9w66xa3p4",
+        );
+        assert_eq!(result, Err(AddressError::SilentPaymentNotSupported));
+
+        // testnet SP address
+        let result = AddressWithNetwork::try_new(
+            "tsp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtsgpc7kytsk9w66xa3p4",
+        );
+        assert_eq!(result, Err(AddressError::SilentPaymentNotSupported));
+
+        // bitcoin: URI with SP address
+        let result = AddressWithNetwork::try_new(
+            "bitcoin:sp1qqgste7k9hx0qftg6qmwlkqtwuy6cycyavzmzj85c6qdfhjdpdjtsgpc7kytsk9w66xa3p4",
+        );
+        assert_eq!(result, Err(AddressError::SilentPaymentNotSupported));
+    }
+
     #[test]
     fn test_address_string_spaced_out() {
         let address = "bc1pkdj04w4lxsv570j5nsd249lqe4w4j608r2nq9997ruh0wv96cnksy5jeny";

rust/src/manager/send_flow_manager.rs

@@ -419,8 +419,14 @@ impl RustSendFlowManager {
     pub fn validate_address(self: &Arc<Self>, display_alert: bool) -> bool {
         if self.state.lock().address.is_none() {
             if display_alert {
-                let error =
-                    SendFlowError::InvalidAddress(self.state.lock().entering_address.clone());
+                let (entering, network) = {
+                    let state = self.state.lock();
+                    (state.entering_address.clone(), state.metadata.network)
+                };
+                let error = match Address::from_string(&entering, network) {
+                    Err(e) => SendFlowError::from_address_error(e, entering),
+                    Ok(_) => SendFlowError::InvalidAddress(entering),
+                };
                 self.reconciler.send(Message::SetAlert(error.into()));
             }
 

rust/src/manager/send_flow_manager/error.rs

@@ -46,6 +46,9 @@ pub enum SendFlowError {
 
     #[error("unable to get fee details: {0}")]
     UnableToGetFeeDetails(String),
+
+    #[error("sending to silent payment addresses is not yet supported")]
+    SilentPaymentNotSupported,
 }
 
 impl SendFlowError {
@@ -57,6 +60,7 @@ impl SendFlowError {
                 Self::WrongNetwork { address, valid_for, current }
             }
 
+            AddressError::SilentPaymentNotSupported => Self::SilentPaymentNotSupported,
             _ => Self::InvalidAddress(address),
         }
     }