wire up async receive offer fetch

Author: joostjager

src/builder.rs

@@ -1458,7 +1458,7 @@ fn build_with_store_internal(
 		Arc::clone(&channel_manager),
 		message_router,
 		Arc::clone(&channel_manager),
-		IgnoringMessageHandler {},
+		Arc::clone(&channel_manager),
 		IgnoringMessageHandler {},
 		IgnoringMessageHandler {},
 	));

src/event.rs

@@ -37,6 +37,8 @@ use lightning::events::{Event as LdkEvent, PaymentFailureReason};
 use lightning::impl_writeable_tlv_based_enum;
 use lightning::ln::channelmanager::PaymentId;
 use lightning::ln::types::ChannelId;
+use lightning::offers::static_invoice::StaticInvoice;
+use lightning::onion_message::messenger::Responder;
 use lightning::routing::gossip::NodeId;
 use lightning::util::config::{
 	ChannelConfigOverrides, ChannelConfigUpdate, ChannelHandshakeConfigUpdate,
@@ -56,7 +58,7 @@ use rand::{thread_rng, Rng};
 
 use core::future::Future;
 use core::task::{Poll, Waker};
-use std::collections::VecDeque;
+use std::collections::{HashMap, VecDeque};
 use std::ops::Deref;
 use std::sync::{Arc, Condvar, Mutex};
 
@@ -458,6 +460,32 @@ where
 	runtime: Arc<Runtime>,
 	logger: L,
 	config: Arc<Config>,
+	static_invoice_store: StaticInvoiceStore,
+}
+
+struct StaticInvoiceStore {
+	pub static_invoices: Mutex<HashMap<(Vec<u8>, u16), StaticInvoice>>,
+}
+
+impl StaticInvoiceStore {
+	fn new() -> Self {
+		Self { static_invoices: Mutex::new(HashMap::new()) }
+	}
+
+	fn handle_static_invoice_requested(
+		&self, recipient_id: Vec<u8>, invoice_slot: u16,
+	) -> Option<StaticInvoice> {
+		let map = self.static_invoices.lock().unwrap();
+
+		map.get(&(recipient_id.clone(), invoice_slot)).cloned()
+	}
+
+	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);
+	}
 }
 
 impl<L: Deref + Clone + Sync + Send + 'static> EventHandler<L>
@@ -487,6 +515,7 @@ where
 			logger,
 			runtime,
 			config,
+			static_invoice_store: StaticInvoiceStore::new(),
 		}
 	}
 
@@ -1494,11 +1523,34 @@ where
 			LdkEvent::OnionMessagePeerConnected { .. } => {
 				debug_assert!(false, "We currently don't support onion message interception, so this event should never be emitted.");
 			},
-			LdkEvent::PersistStaticInvoice { .. } => {
-				debug_assert!(false, "We currently don't support static invoice persistence, so this event should never be emitted.");
+
+			LdkEvent::PersistStaticInvoice {
+				invoice,
+				invoice_slot,
+				recipient_id,
+				invoice_persisted_path,
+			} => {
+				self.static_invoice_store.handle_persist_static_invoice(
+					invoice,
+					invoice_slot,
+					recipient_id,
+				);
+
+				self.channel_manager.static_invoice_persisted(invoice_persisted_path);
 			},
-			LdkEvent::StaticInvoiceRequested { .. } => {
-				debug_assert!(false, "We currently don't support static invoice persistence, so this event should never be emitted.");
+			LdkEvent::StaticInvoiceRequested { recipient_id, invoice_slot, reply_path } => {
+				let invoice = self
+					.static_invoice_store
+					.handle_static_invoice_requested(recipient_id, invoice_slot);
+
+				if let Some(invoice) = invoice {
+					match self.channel_manager.send_static_invoice(invoice, reply_path) {
+						Ok(()) => {},
+						Err(_) => {
+							log_error!(self.logger, "Failed to send static invoice");
+						},
+					}
+				}
 			},
 			LdkEvent::FundingTransactionReadyForSigning { .. } => {
 				debug_assert!(false, "We currently don't support interactive-tx, so this event should never be emitted.");

src/types.rs

@@ -123,7 +123,7 @@ pub(crate) type OnionMessenger = lightning::onion_message::messenger::OnionMesse
 	Arc<ChannelManager>,
 	Arc<MessageRouter>,
 	Arc<ChannelManager>,
-	IgnoringMessageHandler,
+	Arc<ChannelManager>,
 	IgnoringMessageHandler,
 	IgnoringMessageHandler,
 >;

tests/integration_tests_rust.rs

@@ -1171,15 +1171,9 @@ fn static_invoice_server() {
 	// Sleep to get the cache filled.
 	std::thread::sleep(std::time::Duration::from_secs(1));
 
-	let mut iter = 0;
-	while node_b.bolt12_payment().get_async_receive_offer().is_err() {
-		std::thread::sleep(std::time::Duration::from_millis(1000));
+	let offer = node_b.bolt12_payment().get_async_receive_offer().unwrap();
 
-		iter += 1;
-		if iter > 10 {
-			assert!(false, "Failed to fetch static invoice offer");
-		}
-	}
+	println!("Offer: {}", offer);
 }
 
 #[test]