kvstore static invoices

Author: joostjager

src/event.rs

@@ -1505,9 +1505,16 @@ where
 				recipient_id,
 				invoice_persisted_path,
 			} => {
-				self.static_invoice_store
+				match self
+					.static_invoice_store
 					.handle_persist_static_invoice(invoice, invoice_slot, recipient_id)
-					.await;
+					.await
+				{
+					Ok(_) => {},
+					Err(e) => {
+						log_error!(self.logger, "Failed to persist static invoice: {}", e);
+					},
+				};
 
 				self.channel_manager.static_invoice_persisted(invoice_persisted_path);
 			},
@@ -1517,13 +1524,18 @@ where
 					.handle_static_invoice_requested(recipient_id, invoice_slot)
 					.await;
 
-				if let Some(invoice) = invoice {
-					match self.channel_manager.send_static_invoice(invoice, reply_path) {
-						Ok(()) => {},
-						Err(_) => {
+				match invoice {
+					Ok(Some(invoice)) => {
+						if let Err(_) =
+							self.channel_manager.send_static_invoice(invoice, reply_path)
+						{
 							log_error!(self.logger, "Failed to send static invoice");
-						},
-					}
+						}
+					},
+					Ok(None) => {},
+					Err(e) => {
+						log_error!(self.logger, "Failed to retrieve static invoice: {}", e);
+					},
 				}
 			},
 			LdkEvent::FundingTransactionReadyForSigning { .. } => {

src/lib.rs

@@ -501,7 +501,7 @@ impl Node {
 			Arc::clone(&self.logger),
 		));
 
-		let static_invoice_store = StaticInvoiceStore::new();
+		let static_invoice_store = StaticInvoiceStore::new(Arc::clone(&self.kv_store));
 
 		let event_handler = Arc::new(EventHandler::new(
 			Arc::clone(&self.event_queue),

src/static_invoice_store.rs

@@ -1,28 +1,54 @@
-use std::{collections::HashMap, sync::Mutex};
-
-use lightning::offers::static_invoice::StaticInvoice;
+use crate::{hex_utils, types::DynStore};
+use bitcoin::hashes::{sha256, Hash};
+use lightning::{offers::static_invoice::StaticInvoice, util::ser::Writeable};
+use std::sync::Arc;
 
 pub(crate) struct StaticInvoiceStore {
-	pub static_invoices: Mutex<HashMap<(Vec<u8>, u16), StaticInvoice>>,
+	kv_store: Arc<DynStore>,
 }
 
 impl StaticInvoiceStore {
-	pub(crate) fn new() -> Self {
-		Self { static_invoices: Mutex::new(HashMap::new()) }
+	// Static invoices are stored at "static_invoices/<sha256(recipient_id)>/<invoice_slot>".
+	//
+	// Example:
+	// static_invoices/039058c6f2c0cb492c533b0a4d14ef77cc0f78abccced5287d84a1a2011cfb81/0000
+	const PRIMARY_NAMESPACE: &str = "static_invoices";
+
+	pub(crate) fn new(kv_store: Arc<DynStore>) -> Self {
+		Self { kv_store }
 	}
 
 	pub(crate) async fn handle_static_invoice_requested(
 		&self, recipient_id: Vec<u8>, invoice_slot: u16,
-	) -> Option<StaticInvoice> {
-		let map = self.static_invoices.lock().unwrap();
+	) -> Result<Option<StaticInvoice>, lightning::io::Error> {
+		let (secondary_namespace, key) = Self::get_storage_location(invoice_slot, recipient_id);
 
-		map.get(&(recipient_id.clone(), invoice_slot)).cloned()
+		self.kv_store.read(Self::PRIMARY_NAMESPACE, &secondary_namespace, &key).and_then(|data| {
+			data.try_into().map(Some).map_err(|e| {
+				lightning::io::Error::new(
+					lightning::io::ErrorKind::InvalidData,
+					format!("Failed to parse static invoice: {:?}", e),
+				)
+			})
+		})
 	}
 
 	pub(crate) async fn handle_persist_static_invoice(
 		&self, invoice: StaticInvoice, invoice_slot: u16, recipient_id: Vec<u8>,
-	) {
-		let mut map = self.static_invoices.lock().unwrap();
-		map.insert((recipient_id, invoice_slot), invoice);
+	) -> Result<(), lightning::io::Error> {
+		let (secondary_namespace, key) = Self::get_storage_location(invoice_slot, recipient_id);
+
+		let mut buf = Vec::new();
+		invoice.write(&mut buf)?;
+
+		self.kv_store.write(Self::PRIMARY_NAMESPACE, &secondary_namespace, &key, buf)
+	}
+
+	fn get_storage_location(invoice_slot: u16, recipient_id: Vec<u8>) -> (String, String) {
+		let hash = sha256::Hash::hash(&recipient_id).to_byte_array();
+		let secondary_namespace = hex_utils::to_string(&hash);
+
+		let key = hex_utils::to_string(&invoice_slot.to_be_bytes());
+		(secondary_namespace, key)
 	}
 }