Update spark-sdk to latest release

Author: benthecarman

orange-sdk/Cargo.toml

@@ -28,7 +28,7 @@ lightning-macros = "0.2.0"
 bitcoin-payment-instructions = { workspace = true, features = ["http"] }
 chrono = { version = "0.4", default-features = false }
 rand = { version = "0.8.5", optional = true }
-breez-sdk-spark = { git = "https://github.com/breez/spark-sdk.git", rev = "ef76a0bc517bea38fafaff8f657e82b5b52569b9", default-features = false, features = ["rustls-tls"], optional = true }
+breez-sdk-spark = { git = "https://github.com/breez/spark-sdk.git", rev = "1000f276d2f16592b5f6eb8fce29228f34ff88bf", default-features = false, optional = true }
 tokio = { version = "1.0", default-features = false, features = ["rt-multi-thread", "sync", "macros"] }
 uuid = { version = "1.0", default-features = false, optional = true }
 cdk = { version = "0.15.1", default-features = false, features = ["wallet"], optional = true }

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

@@ -85,6 +85,9 @@ impl SparkWalletConfig {
 			lnurl_domain: self.lnurl_domain,
 			private_enabled_default: true,
 			optimization_config: OptimizationConfig { auto_enabled: true, multiplicity: 1 },
+			stable_balance_config: None,
+			max_concurrent_claims: 4,
+			support_lnurl_verify: false,
 		})
 	}
 }
@@ -138,6 +141,7 @@ impl TrustedWalletInterface for Spark {
 					description: "".to_string(), // empty description for smaller QRs and better privacy
 					amount_sats,
 					expiry_secs: None,
+					payment_hash: None,
 				},
 			};
 			let res = self.spark_wallet.receive_payment(params).await?;
@@ -176,6 +180,7 @@ impl TrustedWalletInterface for Spark {
 					amount: Some(sats.into()),
 					token_identifier: None,
 					conversion_options: None,
+					fee_policy: None,
 				};
 				let prepare = self.spark_wallet.prepare_send_payment(params).await?;
 				match prepare.payment_method {
@@ -209,6 +214,7 @@ impl TrustedWalletInterface for Spark {
 					amount: Some(sats.into()),
 					token_identifier: None,
 					conversion_options: None,
+					fee_policy: None,
 				};
 				let prepare = self.spark_wallet.prepare_send_payment(params).await?;
 
@@ -240,8 +246,9 @@ impl TrustedWalletInterface for Spark {
 					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 {
-						let hash: Option<[u8; 32]> = FromHex::from_hex(ph).ok();
+					if let Some(PaymentDetails::Lightning { htlc_details, .. }) = &p.details {
+						let hash: Option<[u8; 32]> =
+							FromHex::from_hex(&htlc_details.payment_hash).ok();
 						hash == Some(payment_hash)
 					} else {
 						false
@@ -412,7 +419,7 @@ impl SparkEventHandler {
 		match payment.payment_type {
 			PaymentType::Send => {
 				match payment.details {
-					Some(PaymentDetails::Lightning { preimage, payment_hash, .. }) => {
+					Some(PaymentDetails::Lightning { htlc_details, .. }) => {
 						let payment_id = PaymentId::Trusted(id);
 						let is_rebalance = {
 							let map = self.tx_metadata.read();
@@ -429,17 +436,17 @@ impl SparkEventHandler {
 							return Ok(());
 						}
 
-						let preimage = preimage.ok_or_else(|| {
+						let preimage_hex = htlc_details.preimage.ok_or_else(|| {
 							TrustedError::Other(
 								"Payment succeeded but preimage is missing".to_string(),
 							)
 						})?;
 
-						let preimage: [u8; 32] = FromHex::from_hex(&preimage).map_err(|e| {
+						let preimage: [u8; 32] = FromHex::from_hex(&preimage_hex).map_err(|e| {
 							TrustedError::Other(format!("Invalid preimage hex: {e:?}"))
 						})?;
-						let payment_hash: [u8; 32] =
-							FromHex::from_hex(&payment_hash).map_err(|e| {
+						let payment_hash: [u8; 32] = FromHex::from_hex(&htlc_details.payment_hash)
+							.map_err(|e| {
 								TrustedError::Other(format!("Invalid payment_hash hex: {e:?}"))
 							})?;
 
@@ -468,9 +475,9 @@ impl SparkEventHandler {
 			},
 			PaymentType::Receive => {
 				match payment.details {
-					Some(PaymentDetails::Lightning { payment_hash, .. }) => {
-						let payment_hash: [u8; 32] =
-							FromHex::from_hex(&payment_hash).map_err(|e| {
+					Some(PaymentDetails::Lightning { htlc_details, .. }) => {
+						let payment_hash: [u8; 32] = FromHex::from_hex(&htlc_details.payment_hash)
+							.map_err(|e| {
 								TrustedError::Other(format!("Invalid payment_hash hex: {e:?}"))
 							})?;
 
@@ -512,7 +519,7 @@ impl SparkEventHandler {
 
 		match payment.payment_type {
 			PaymentType::Send => match payment.details {
-				Some(PaymentDetails::Lightning { payment_hash, .. }) => {
+				Some(PaymentDetails::Lightning { htlc_details, .. }) => {
 					let payment_id = PaymentId::Trusted(id);
 					let is_rebalance = {
 						let map = self.tx_metadata.read();
@@ -527,9 +534,10 @@ impl SparkEventHandler {
 						return Ok(());
 					}
 
-					let payment_hash: [u8; 32] = FromHex::from_hex(&payment_hash).map_err(|e| {
-						TrustedError::Other(format!("Invalid payment_hash hex: {e:?}"))
-					})?;
+					let payment_hash: [u8; 32] = FromHex::from_hex(&htlc_details.payment_hash)
+						.map_err(|e| {
+							TrustedError::Other(format!("Invalid payment_hash hex: {e:?}"))
+						})?;
 
 					self.event_queue
 						.add_event(Event::PaymentFailed {

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

@@ -4,9 +4,12 @@ use std::sync::Arc;
 
 use crate::io;
 
+use breez_sdk_spark::sync_storage::{
+	IncomingChange, OutgoingChange, Record, UnversionedRecordChange,
+};
 use breez_sdk_spark::{
-	DepositInfo, ListPaymentsRequest, Payment, PaymentDetails, PaymentMetadata,
-	SetLnurlMetadataItem, StorageError, UpdateDepositPayload,
+	DepositInfo, Payment, PaymentDetails, PaymentMetadata, SetLnurlMetadataItem, StorageError,
+	StorageListPaymentsRequest, UpdateDepositPayload,
 };
 use ldk_node::DynStore;
 use ldk_node::lightning::util::persist::KVSTORE_NAMESPACE_KEY_MAX_LEN;
@@ -78,7 +81,7 @@ impl breez_sdk_spark::Storage for SparkStore {
 	}
 
 	async fn list_payments(
-		&self, request: ListPaymentsRequest,
+		&self, request: StorageListPaymentsRequest,
 	) -> Result<Vec<breez_sdk_spark::Payment>, StorageError> {
 		let keys =
 			KVStore::list(self.0.as_ref(), SPARK_PRIMARY_NAMESPACE, SPARK_PAYMENTS_NAMESPACE)
@@ -137,7 +140,7 @@ impl breez_sdk_spark::Storage for SparkStore {
 		Ok(())
 	}
 
-	async fn set_payment_metadata(
+	async fn insert_payment_metadata(
 		&self, _: String, _: PaymentMetadata,
 	) -> Result<(), StorageError> {
 		// we don't use this
@@ -160,7 +163,7 @@ impl breez_sdk_spark::Storage for SparkStore {
 	async fn get_payment_by_invoice(
 		&self, invoice: String,
 	) -> Result<Option<Payment>, StorageError> {
-		let payments = self.list_payments(ListPaymentsRequest::default()).await?;
+		let payments = self.list_payments(StorageListPaymentsRequest::default()).await?;
 
 		let p = payments.into_iter().find(|p| {
 			if let Some(details) = p.details.as_ref() {
@@ -313,4 +316,52 @@ impl breez_sdk_spark::Storage for SparkStore {
 		// we don't use this
 		Ok(())
 	}
+
+	async fn get_payments_by_parent_ids(
+		&self, _parent_ids: Vec<String>,
+	) -> Result<std::collections::HashMap<String, Vec<Payment>>, StorageError> {
+		Ok(std::collections::HashMap::new())
+	}
+
+	async fn add_outgoing_change(
+		&self, _change: UnversionedRecordChange,
+	) -> Result<u64, StorageError> {
+		Ok(0)
+	}
+
+	async fn complete_outgoing_sync(
+		&self, _record: Record, _change_id: u64,
+	) -> Result<(), StorageError> {
+		Ok(())
+	}
+
+	async fn get_pending_outgoing_changes(
+		&self, _limit: u32,
+	) -> Result<Vec<OutgoingChange>, StorageError> {
+		Ok(Vec::new())
+	}
+
+	async fn get_last_revision(&self) -> Result<u64, StorageError> {
+		Ok(0)
+	}
+
+	async fn insert_incoming_records(&self, _records: Vec<Record>) -> Result<(), StorageError> {
+		Ok(())
+	}
+
+	async fn delete_incoming_record(&self, _record: Record) -> Result<(), StorageError> {
+		Ok(())
+	}
+
+	async fn get_incoming_records(&self, _limit: u32) -> Result<Vec<IncomingChange>, StorageError> {
+		Ok(Vec::new())
+	}
+
+	async fn get_latest_outgoing_change(&self) -> Result<Option<OutgoingChange>, StorageError> {
+		Ok(None)
+	}
+
+	async fn update_record_from_incoming(&self, _record: Record) -> Result<(), StorageError> {
+		Ok(())
+	}
 }