Add lightning address support for Cashu via npub.cash

Implement get_lightning_address and register_lightning_address for the
Cashu wallet using CDK's built-in npub.cash integration. When configured
with a npubcash_url, the wallet enables npub.cash during init, starts
background polling for incoming quotes, and returns deterministic
lightning addresses derived from the wallet's Nostr keys.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: benthecarman

orange-sdk/Cargo.toml

@@ -16,7 +16,7 @@ name = "orange_sdk"
 default = ["spark"]
 uniffi = ["dep:uniffi", "spark", "cashu", "rand", "pin-project-lite"]
 spark = ["breez-sdk-spark", "uuid", "serde_json"]
-cashu = ["cdk", "serde_json"]
+cashu = ["cdk", "cdk/npubcash", "serde_json"]
 _test-utils = ["corepc-node", 'electrsd', "cashu", "uuid/v7", "rand"]
 _cashu-tests = ["_test-utils", "cdk-ldk-node", "cdk/mint", "cdk-sqlite", "cdk-axum", "axum"]
 

orange-sdk/src/ffi/cashu.rs

@@ -45,24 +45,34 @@ pub struct CashuConfig {
 	pub mint_url: String,
 	/// The currency unit to use (typically Sat)
 	pub unit: CurrencyUnit,
+	/// Optional npub.cash URL for lightning address support
+	pub npubcash_url: Option<String>,
 }
 
 #[uniffi::export]
 impl CashuConfig {
 	#[uniffi::constructor]
-	pub fn new(mint_url: String, unit: CurrencyUnit) -> Self {
-		CashuConfig { mint_url, unit }
+	pub fn new(mint_url: String, unit: CurrencyUnit, npubcash_url: Option<String>) -> Self {
+		CashuConfig { mint_url, unit, npubcash_url }
 	}
 }
 
 impl From<CashuConfig> for OrangeCashuConfig {
 	fn from(config: CashuConfig) -> Self {
-		OrangeCashuConfig { mint_url: config.mint_url, unit: config.unit.into() }
+		OrangeCashuConfig {
+			mint_url: config.mint_url,
+			unit: config.unit.into(),
+			npubcash_url: config.npubcash_url,
+		}
 	}
 }
 
 impl From<OrangeCashuConfig> for CashuConfig {
 	fn from(config: OrangeCashuConfig) -> Self {
-		CashuConfig { mint_url: config.mint_url, unit: config.unit.into() }
+		CashuConfig {
+			mint_url: config.mint_url,
+			unit: config.unit.into(),
+			npubcash_url: config.npubcash_url,
+		}
 	}
 }

orange-sdk/src/trusted_wallet/cashu/mod.rs

@@ -52,6 +52,8 @@ pub struct CashuConfig {
 	pub mint_url: String,
 	/// The currency unit to use (typically Sat)
 	pub unit: CurrencyUnit,
+	/// Optional npub.cash URL for lightning address support (e.g., `https://npub.cash`)
+	pub npubcash_url: Option<String>,
 }
 
 /// A wallet implementation using the Cashu (CDK) SDK.
@@ -68,6 +70,8 @@ pub struct Cashu {
 	event_queue: Arc<EventQueue>,
 	tx_metadata: TxMetadataStore,
 	runtime: Arc<Runtime>,
+	npubcash_url: Option<String>,
+	npub: Option<String>,
 }
 
 impl TrustedWalletInterface for Cashu {
@@ -497,16 +501,30 @@ impl TrustedWalletInterface for Cashu {
 	fn get_lightning_address(
 		&self,
 	) -> Pin<Box<dyn Future<Output = Result<Option<String>, TrustedError>> + Send + '_>> {
-		Box::pin(async { Ok(None) })
+		Box::pin(async {
+			match (&self.npubcash_url, &self.npub) {
+				(Some(url), Some(npub)) => {
+					let domain =
+						url.trim_start_matches("https://").trim_start_matches("http://");
+					Ok(Some(format!("{npub}@{domain}")))
+				},
+				_ => Ok(None),
+			}
+		})
 	}
 
 	fn register_lightning_address(
 		&self, _name: String,
 	) -> Pin<Box<dyn Future<Output = Result<(), TrustedError>> + Send + '_>> {
 		Box::pin(async {
-			Err(TrustedError::UnsupportedOperation(
-				"register_lightning_address is not supported in Cashu Wallet".to_string(),
-			))
+			if self.npubcash_url.is_none() {
+				return Err(TrustedError::UnsupportedOperation(
+					"npubcash_url is not configured".to_string(),
+				));
+			}
+			// npub.cash addresses are deterministic from the Nostr keys,
+			// and set_mint_url is called during init. Nothing to do here.
+			Ok(())
 		})
 	}
 
@@ -652,6 +670,65 @@ impl Cashu {
 			});
 		}
 
+		// Initialize npub.cash if configured
+		let npubcash_url = cashu_config.npubcash_url.clone();
+		let mut npub: Option<String> = None;
+
+		if let Some(ref url) = npubcash_url {
+			npub = Some(Self::derive_npub(&seed).map_err(|e| {
+				InitFailure::TrustedFailure(TrustedError::WalletOperationFailed(format!(
+					"Failed to derive npub: {e}"
+				)))
+			})?);
+
+			if let Err(e) = cashu_wallet.enable_npubcash(url.clone()).await {
+				log_error!(logger, "Failed to enable npub.cash: {e}");
+			} else {
+				log_info!(logger, "npub.cash enabled with URL: {url}");
+
+				// Start background polling for npub.cash quotes
+				let wallet_for_npubcash = Arc::clone(&cashu_wallet);
+				let sender_for_npubcash = mint_quote_sender.clone();
+				let logger_for_npubcash = Arc::clone(&logger);
+				let mut shutdown_for_npubcash = shutdown_sender.subscribe();
+				runtime.spawn_cancellable_background_task(async move {
+					let poll_interval = Duration::from_secs(30);
+					let mut interval = tokio::time::interval(poll_interval);
+					loop {
+						tokio::select! {
+							_ = shutdown_for_npubcash.changed() => {
+								log_info!(logger_for_npubcash, "npub.cash polling shutdown");
+								return;
+							}
+							_ = interval.tick() => {
+								match wallet_for_npubcash.sync_npubcash_quotes().await {
+									Ok(quotes) => {
+										for quote in quotes {
+											if matches!(quote.state, cdk::nuts::MintQuoteState::Paid) {
+												let id = quote.id.clone();
+												if let Err(e) = sender_for_npubcash.send(quote).await {
+													log_error!(
+														logger_for_npubcash,
+														"Failed to send npub.cash quote {id} for monitoring: {e}"
+													);
+												}
+											}
+										}
+									},
+									Err(e) => {
+										log_error!(
+											logger_for_npubcash,
+											"Failed to sync npub.cash quotes: {e}"
+										);
+									},
+								}
+							}
+						}
+					}
+				});
+			}
+		}
+
 		Ok(Cashu {
 			cashu_wallet,
 			unit: cashu_config.unit,
@@ -664,9 +741,27 @@ impl Cashu {
 			event_queue,
 			tx_metadata,
 			runtime,
+			npubcash_url,
+			npub,
 		})
 	}
 
+	/// Derive the npub (bech32-encoded Nostr public key) from the wallet seed.
+	///
+	/// Uses the same derivation as CDK's `derive_npubcash_keys`: the first 32 bytes
+	/// of the seed as a secp256k1 secret key, then bech32-encodes the x-only public key.
+	fn derive_npub(seed: &[u8; 64]) -> Result<String, String> {
+		use ldk_node::bitcoin::bech32::{Bech32, Hrp, encode};
+		use ldk_node::bitcoin::secp256k1::{Secp256k1, SecretKey};
+
+		let sk = SecretKey::from_slice(&seed[..32])
+			.map_err(|e| format!("Invalid secret key: {e}"))?;
+		let secp = Secp256k1::new();
+		let (xonly, _) = sk.public_key(&secp).x_only_public_key();
+		let hrp = Hrp::parse("npub").expect("valid hrp");
+		encode::<Bech32>(hrp, &xonly.serialize()).map_err(|e| format!("bech32 encode: {e}"))
+	}
+
 	/// Convert an ID string to a 32-byte array
 	///
 	/// This is a helper function to avoid code duplication when converting various ID types

orange-sdk/tests/test_utils.rs

@@ -498,6 +498,7 @@ async fn build_test_nodes() -> TestParams {
 			extra_config: ExtraConfig::Cashu(orange_sdk::CashuConfig {
 				mint_url: format!("http://127.0.0.1:{}", mint_addr.port()),
 				unit: orange_sdk::CurrencyUnit::Sat,
+				npubcash_url: None,
 			}),
 		};
 		let wallet = Arc::new(Wallet::new(wallet_config).await.unwrap());