Update to latest spark-sdk release

Author: benthecarman

orange-sdk/Cargo.toml

@@ -28,7 +28,7 @@ bitcoin-payment-instructions = { workspace = true }
 chrono = { version = "0.4", default-features = false }
 rand = { version = "0.8.5", optional = true }
 reqwest = { version = "0.12.23", default-features = false, features = ["rustls-tls"] }
-breez-sdk-spark = { git = "https://github.com/breez/spark-sdk.git", rev = "1c3dd78a40ae50a88d743110a79fa4a95d93d932", default-features = false, features = ["rustls-tls"], optional = true }
+breez-sdk-spark = { git = "https://github.com/breez/spark-sdk.git", rev = "1f2e9995230cd582d6b4aa7d06d76b99defb635e", default-features = false, features = ["rustls-tls"], optional = true }
 tokio = { version = "1.0", default-features = false, features = ["rt-multi-thread", "sync"] }
 uuid = { version = "1.0", default-features = false, optional = true }
 cdk = { git = "https://github.com/benthecarman/cdk.git", rev = "39c1206a4a1dda2adc1f3e23628136ef645f6c6b", default-features = false, features = ["wallet"], optional = true }

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

@@ -70,9 +70,13 @@ impl SparkWalletConfig {
 			network,
 			sync_interval_secs: self.sync_interval_secs,
 			prefer_spark_over_lightning: self.prefer_spark_over_lightning,
+			external_input_parsers: None,
+			use_default_external_input_parsers: false,
+			real_time_sync_server_url: None,
 			api_key: Some(BREEZ_API_KEY.to_string()),
 			max_deposit_claim_fee: None,
 			lnurl_domain: None,
+			private_enabled_default: true,
 		})
 	}
 }
@@ -91,7 +95,7 @@ impl TrustedWalletInterface for Spark {
 		&self,
 	) -> Pin<Box<dyn Future<Output = Result<Amount, TrustedError>> + Send + '_>> {
 		Box::pin(async move {
-			let info = self.spark_wallet.get_info(GetInfoRequest {}).await?;
+			let info = self.spark_wallet.get_info(GetInfoRequest { ensure_synced: None }).await?;
 			Amount::from_sats(info.balance_sats).map_err(|_| TrustedError::AmountError)
 		})
 	}
@@ -138,10 +142,7 @@ impl TrustedWalletInterface for Spark {
 		&self,
 	) -> Pin<Box<dyn Future<Output = Result<Vec<Payment>, TrustedError>> + Send + '_>> {
 		Box::pin(async move {
-			let resp = self
-				.spark_wallet
-				.list_payments(ListPaymentsRequest { limit: None, offset: None })
-				.await?;
+			let resp = self.spark_wallet.list_payments(ListPaymentsRequest::default()).await?;
 
 			let payments =
 				resp.payments.into_iter().map(|p| p.try_into()).collect::<Result<_, _>>()?;
@@ -163,7 +164,8 @@ impl TrustedWalletInterface for Spark {
 
 				let params = PrepareSendPaymentRequest {
 					payment_request: invoice.to_string(),
-					amount_sats: Some(sats),
+					amount: Some(sats.into()),
+					token_identifier: None,
 				};
 				let prepare = self.spark_wallet.prepare_send_payment(params).await?;
 				match prepare.payment_method {
@@ -194,7 +196,8 @@ impl TrustedWalletInterface for Spark {
 
 				let params = PrepareSendPaymentRequest {
 					payment_request: invoice.to_string(),
-					amount_sats: Some(sats),
+					amount: Some(sats.into()),
+					token_identifier: None,
 				};
 				let prepare = self.spark_wallet.prepare_send_payment(params).await?;
 
@@ -218,11 +221,8 @@ impl TrustedWalletInterface for Spark {
 	) -> Pin<Box<dyn Future<Output = Option<ReceivedLightningPayment>> + Send + '_>> {
 		Box::pin(async move {
 			loop {
-				let res = self
-					.spark_wallet
-					.list_payments(ListPaymentsRequest { offset: None, limit: None })
-					.await
-					.ok()?;
+				let res =
+					self.spark_wallet.list_payments(ListPaymentsRequest::default()).await.ok()?;
 
 				let tx = res.payments.into_iter().find(|p| {
 					if let Some(PaymentDetails::Lightning { payment_hash: ph, .. }) = &p.details {
@@ -236,7 +236,7 @@ impl TrustedWalletInterface for Spark {
 				if tx.status == PaymentStatus::Completed {
 					return Some(ReceivedLightningPayment {
 						id: payment_hash,
-						fee_paid_msat: Some(tx.fees * 1_000),
+						fee_paid_msat: Some((tx.fees * 1_000) as u64),
 					});
 				}
 
@@ -270,8 +270,8 @@ impl Spark {
 			},
 		};
 
-		let spark_store = spark_store::SparkStore(store);
-		let builder = SdkBuilder::new(spark_config, seed, Arc::new(spark_store));
+		let spark_store = Arc::new(spark_store::SparkStore(store));
+		let builder = SdkBuilder::new(spark_config, seed).with_storage(spark_store);
 
 		let spark_wallet = Arc::new(builder.build().await.map_err(|e| {
 			log_error!(logger, "Failed to initialize Spark wallet: {e:?}");
@@ -290,13 +290,13 @@ impl Spark {
 			logger: Arc::clone(&logger),
 		};
 
-		let listener_id = spark_wallet.add_event_listener(Box::new(listener));
-		log_info!(logger, "Added Spark event listener with ID: {}", listener_id);
+		let listener_id = spark_wallet.add_event_listener(Box::new(listener)).await;
+		log_info!(logger, "Added Spark event listener with ID: {listener_id}");
 		let w = Arc::clone(&spark_wallet);
 		let mut shutdown_recv = shutdown_receiver.clone();
 		runtime.spawn(async move {
 			let _ = shutdown_recv.changed().await;
-			w.remove_event_listener(&listener_id);
+			w.remove_event_listener(&listener_id).await;
 		});
 
 		log_info!(logger, "Spark wallet initialized");
@@ -318,19 +318,26 @@ struct SparkEventHandler {
 	logger: Arc<Logger>,
 }
 
+#[async_trait::async_trait]
 impl EventListener for SparkEventHandler {
-	fn on_event(&self, event: SdkEvent) {
+	async fn on_event(&self, event: SdkEvent) {
 		match event {
 			SdkEvent::Synced => {
 				log_debug!(self.logger, "Spark wallet synced");
 			},
-			SdkEvent::ClaimDepositsFailed { unclaimed_deposits } => {
+			SdkEvent::DataSynced { did_pull_new_records } => {
+				log_debug!(
+					self.logger,
+					"Spark wallet data synced, did_pull_new_records: {did_pull_new_records}"
+				);
+			},
+			SdkEvent::UnclaimedDeposits { unclaimed_deposits } => {
 				log_warn!(
 					self.logger,
 					"Spark wallet failed to claim deposits! {unclaimed_deposits:?}"
 				);
 			},
-			SdkEvent::ClaimDepositsSucceeded { claimed_deposits } => {
+			SdkEvent::ClaimedDeposits { claimed_deposits } => {
 				log_info!(self.logger, "Spark wallet claimed deposits! {claimed_deposits:?}");
 			},
 			SdkEvent::PaymentSucceeded { payment } => {
@@ -343,6 +350,12 @@ impl EventListener for SparkEventHandler {
 					log_error!(self.logger, "Failed to handle payment succeeded: {e:?}");
 				}
 			},
+			SdkEvent::PaymentPending { payment } => {
+				log_debug!(
+					self.logger,
+					"Spark payment pending event received for payment: {payment:?}"
+				);
+			},
 		}
 	}
 }
@@ -400,7 +413,7 @@ impl SparkEventHandler {
 							payment_id,
 							payment_hash: PaymentHash(payment_hash),
 							payment_preimage: PaymentPreimage(preimage),
-							fee_paid_msat: Some(payment.fees * 1_000), // convert to msats
+							fee_paid_msat: Some((payment.fees * 1_000) as u64), // convert to msats
 						})?;
 
 						self.payment_success_sender.send(()).unwrap();
@@ -421,13 +434,13 @@ impl SparkEventHandler {
 						let lsp_fee_msats = if payment.fees == 0 {
 							None
 						} else {
-							Some(payment.fees * 1_000) // convert to msats
+							Some((payment.fees * 1_000) as u64) // convert to msats
 						};
 
 						self.event_queue.add_event(Event::PaymentReceived {
 							payment_id: PaymentId::Trusted(id),
 							payment_hash: PaymentHash(payment_hash),
-							amount_msat: payment.amount * 1_000, // convert to msats
+							amount_msat: (payment.amount * 1_000) as u64, // convert to msats
 							custom_records: vec![],
 							lsp_fee_msats,
 						})?;
@@ -537,8 +550,9 @@ impl TryFrom<breez_sdk_spark::Payment> for Payment {
 
 		Ok(Payment {
 			id,
-			amount: Amount::from_sats(value.amount).map_err(|_| TrustedError::AmountError)?,
-			fee: Amount::from_sats(value.fees).map_err(|_| TrustedError::AmountError)?,
+			amount: Amount::from_sats(value.amount as u64)
+				.map_err(|_| TrustedError::AmountError)?,
+			fee: Amount::from_sats(value.fees as u64).map_err(|_| TrustedError::AmountError)?,
 			status: value.status.into(),
 			outbound: value.payment_type == PaymentType::Send,
 			time_since_epoch: Duration::from_secs(value.timestamp),

orange-sdk/src/trusted_wallet/spark/spark_store.rs

@@ -4,7 +4,11 @@ use std::sync::Arc;
 
 use crate::{KVStore, io};
 
-use breez_sdk_spark::{DepositInfo, PaymentMetadata, StorageError, UpdateDepositPayload};
+use breez_sdk_spark::{
+	DepositInfo, ListPaymentsRequest, Payment, PaymentDetails, PaymentMetadata, StorageError,
+	UpdateDepositPayload,
+};
+use ldk_node::lightning::util::persist::KVSTORE_NAMESPACE_KEY_MAX_LEN;
 
 const SPARK_PRIMARY_NAMESPACE: &str = "spark";
 const SPARK_CACHE_NAMESPACE: &str = "cache";
@@ -14,16 +18,27 @@ const SPARK_DEPOSITS_NAMESPACE: &str = "deposit";
 #[derive(Clone)]
 pub(crate) struct SparkStore(pub(crate) Arc<dyn KVStore + Send + Sync>);
 
+/// The Spark sdk can produce keys that are too long, we just truncate them here
+fn sanitize_key(key: String) -> String {
+	if key.len() > KVSTORE_NAMESPACE_KEY_MAX_LEN {
+		key[..KVSTORE_NAMESPACE_KEY_MAX_LEN].to_string()
+	} else {
+		key
+	}
+}
+
 #[async_trait::async_trait]
 impl breez_sdk_spark::Storage for SparkStore {
 	async fn delete_cached_item(&self, key: String) -> Result<(), StorageError> {
+		let key = sanitize_key(key);
 		self.0
 			.remove(SPARK_PRIMARY_NAMESPACE, SPARK_CACHE_NAMESPACE, &key, false)
 			.map_err(|e| StorageError::Implementation(format!("{e:?}")))?;
 		Ok(())
 	}
 
 	async fn get_cached_item(&self, key: String) -> Result<Option<String>, StorageError> {
+		let key = sanitize_key(key);
 		match self.0.read(SPARK_PRIMARY_NAMESPACE, SPARK_CACHE_NAMESPACE, &key) {
 			Ok(bytes) => Ok(Some(String::from_utf8(bytes).map_err(|e| {
 				StorageError::Serialization(format!("Invalid UTF-8 in cached item: {e:?}"))
@@ -39,14 +54,15 @@ impl breez_sdk_spark::Storage for SparkStore {
 	}
 
 	async fn set_cached_item(&self, key: String, value: String) -> Result<(), StorageError> {
+		let key = sanitize_key(key);
 		self.0
 			.write(SPARK_PRIMARY_NAMESPACE, SPARK_CACHE_NAMESPACE, &key, value.as_bytes())
 			.map_err(|e| StorageError::Implementation(format!("{e:?}")))?;
 		Ok(())
 	}
 
 	async fn list_payments(
-		&self, offset: Option<u32>, limit: Option<u32>,
+		&self, request: ListPaymentsRequest,
 	) -> Result<Vec<breez_sdk_spark::Payment>, StorageError> {
 		let keys = self
 			.0
@@ -64,12 +80,17 @@ impl breez_sdk_spark::Storage for SparkStore {
 				.map_err(|e| StorageError::Serialization(format!("{e:?}")))?;
 			payments.push(payment);
 		}
-		// sort
-		payments.sort_by_key(|p| p.timestamp);
+
+		let sort_ascending = request.sort_ascending.unwrap_or(false);
+		if sort_ascending {
+			payments.sort_by_key(|p| p.timestamp);
+		} else {
+			payments.sort_by_key(|p| std::cmp::Reverse(p.timestamp));
+		}
 
 		// apply offset and limit
-		let start = offset.unwrap_or(0) as usize;
-		let end = if let Some(l) = limit {
+		let start = request.offset.unwrap_or(0) as usize;
+		let end = if let Some(l) = request.limit {
 			(start + l as usize).min(payments.len())
 		} else {
 			payments.len()
@@ -110,6 +131,35 @@ impl breez_sdk_spark::Storage for SparkStore {
 		Ok(payment)
 	}
 
+	async fn get_payment_by_invoice(
+		&self, invoice: String,
+	) -> Result<Option<Payment>, StorageError> {
+		let payments = self.list_payments(ListPaymentsRequest::default()).await?;
+
+		let p = payments.into_iter().find(|p| {
+			if let Some(details) = p.details.as_ref() {
+				match details {
+					PaymentDetails::Spark { invoice_details } => {
+						if invoice_details.as_ref().is_some_and(|i| i.invoice == invoice) {
+							return true;
+						}
+					},
+					PaymentDetails::Token { .. } => {},
+					PaymentDetails::Lightning { invoice: inv, .. } => {
+						if *inv == invoice {
+							return true;
+						}
+					},
+					PaymentDetails::Withdraw { .. } => {},
+					PaymentDetails::Deposit { .. } => {},
+				}
+			}
+			false
+		});
+
+		Ok(p)
+	}
+
 	async fn add_deposit(
 		&self, txid: String, vout: u32, amount_sats: u64,
 	) -> Result<(), StorageError> {