Add utility to create an invoice using the ChannelManager

This also allows the ChannelManager to track information for inbound payments
to check the PaymentSecret on receive.

Author: valentinewallace

lightning-invoice/Cargo.toml

@@ -10,11 +10,15 @@ readme = "README.md"
 
 [dependencies]
 bech32 = "0.7"
+bitcoin = "0.26"
 lightning = { version = "0.0.13", path = "../lightning" }
 secp256k1 = { version = "0.20", features = ["recovery"] }
 num-traits = "0.2.8"
 bitcoin_hashes = "0.9.4"
 
+[dev-dependencies]
+lightning = { version = "0.0.13", path = "../lightning", features = ["_test_utils"] }
+
 [lib]
 crate-type = ["cdylib", "rlib"]
 

lightning-invoice/src/lib.rs

@@ -16,19 +16,24 @@
 //!   * For serializing invoices use the `Display`/`ToString` traits
 
 extern crate bech32;
+extern crate bitcoin;
 extern crate bitcoin_hashes;
 extern crate lightning;
 extern crate num_traits;
 extern crate secp256k1;
 
 use bech32::u5;
+use bitcoin::network::constants::Network;
 use bitcoin_hashes::Hash;
 use bitcoin_hashes::sha256;
+use lightning::chain;
+use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator};
+use lightning::chain::keysinterface::{Sign, KeysInterface};
+use lightning::ln::channelmanager::{ChannelManager, PaymentSecret};
 use lightning::ln::features::InvoiceFeatures;
-use lightning::ln::channelmanager::PaymentSecret;
-#[cfg(any(doc, test))]
 use lightning::routing::network_graph::RoutingFees;
 use lightning::routing::router::RouteHintHop;
+use lightning::util::logger::Logger;
 
 use secp256k1::key::PublicKey;
 use secp256k1::{Message, Secp256k1};
@@ -901,6 +906,79 @@ impl Deref for PositiveTimestamp {
 }
 
 impl Invoice {
+	/// Utility to construct an invoice.
+	pub fn from_channelmanager<Signer: Sign, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>(
+		channelmanager: &ChannelManager<Signer, M, T, K, F, L>, amt_msat: Option<u64>, description: String,
+		network: Network,
+	) -> Result<Invoice, CreationError>
+	where
+		M::Target: chain::Watch<Signer>,
+		T::Target: BroadcasterInterface,
+		K::Target: KeysInterface<Signer = Signer>,
+		F::Target: FeeEstimator,
+		L::Target: Logger,
+	{
+		// Marshall route hints.
+		let our_channels = channelmanager.list_usable_channels();
+		let mut route_hints = vec![];
+		let mut min_final_cltv_expiry = 18;
+		for channel in our_channels {
+			let short_channel_id = match channel.short_channel_id {
+				Some(id) => id,
+				None => continue,
+			};
+			let forwarding_info = match channel.counterparty_forwarding_info {
+				Some(info) => info,
+				None => continue,
+			};
+			if forwarding_info.cltv_expiry_delta > min_final_cltv_expiry {
+				min_final_cltv_expiry = forwarding_info.cltv_expiry_delta;
+			}
+			route_hints.push(vec![RouteHintHop {
+				src_node_id: channel.remote_network_id,
+				short_channel_id,
+				fees: RoutingFees {
+					base_msat: forwarding_info.fee_base_msat,
+					proportional_millionths: forwarding_info.fee_proportional_millionths,
+				},
+				cltv_expiry_delta: forwarding_info.cltv_expiry_delta,
+				htlc_minimum_msat: None,
+				htlc_maximum_msat: None,
+			}]);
+		}
+
+		let (payment_hash, payment_secret) = channelmanager.create_inbound_payment(
+			amt_msat,
+			min_final_cltv_expiry as u32 * 10 * 60, // num blocks * 10 minutes per block
+			0,
+		);
+		let secp_ctx = Secp256k1::new();
+		let our_node_pubkey = channelmanager.get_our_node_id();
+		let mut invoice = InvoiceBuilder::new(match network {
+			Network::Bitcoin => Currency::Bitcoin,
+			Network::Testnet => Currency::BitcoinTestnet,
+			Network::Regtest => Currency::Regtest,
+			Network::Signet => panic!("Signet invoices not supported"),
+		})
+		.description(description)
+		.current_timestamp()
+		.payee_pub_key(our_node_pubkey)
+		.payment_hash(Hash::from_slice(&payment_hash.0).unwrap())
+		.payment_secret(payment_secret)
+		.features(InvoiceFeatures::known())
+		.min_final_cltv_expiry(min_final_cltv_expiry.into());
+		if let Some(amt) = amt_msat {
+			invoice = invoice.amount_pico_btc(amt * 10);
+		}
+		for hint in route_hints.drain(..) {
+			invoice = invoice.route(hint);
+		}
+
+		invoice.build_signed(|msg_hash| {
+			secp_ctx.sign_recoverable(msg_hash, &channelmanager.get_our_node_secret())
+		})
+	}
+
 	/// Transform the `Invoice` into it's unchecked version
 	pub fn into_signed_raw(self) -> SignedRawInvoice {
 		self.signed_invoice
@@ -1294,8 +1372,17 @@ impl<S> Display for SignOrCreationError<S> {
 
 #[cfg(test)]
 mod test {
+	use bitcoin::network::constants::Network;
 	use bitcoin_hashes::hex::FromHex;
 	use bitcoin_hashes::sha256;
+	use {Description, Invoice, InvoiceDescription};
+	use lightning::ln::channelmanager::PaymentHash;
+	use lightning::ln::functional_test_utils::*;
+	use lightning::ln::features::InitFeatures;
+	use lightning::ln::msgs::ChannelMessageHandler;
+	use lightning::routing::router;
+	use lightning::util::events::MessageSendEventsProvider;
+	use lightning::util::test_utils;
 
 	#[test]
 	fn test_system_time_bounds_assumptions() {
@@ -1600,4 +1687,60 @@ mod test {
 		let raw_invoice = builder.build_raw().unwrap();
 		assert_eq!(raw_invoice, *invoice.into_signed_raw().raw_invoice())
 	}
+
+	#[test]
+	fn test_from_channelmanager() {
+		let chanmon_cfgs = create_chanmon_cfgs(2);
+		let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+		let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
+		let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+		let _chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
+		let invoice = Invoice::from_channelmanager(&nodes[1].node, Some(10_000), "test".to_string(), Network::Testnet).unwrap();
+		assert_eq!(invoice.amount_pico_btc(), Some(100_000));
+		assert_eq!(invoice.min_final_cltv_expiry(), Some(&18));
+		assert_eq!(invoice.description(), InvoiceDescription::Direct(&Description("test".to_string())));
+
+		let mut route_hints = invoice.routes().clone();
+		let mut last_hops = Vec::new();
+		for hint in route_hints.drain(..) {
+			last_hops.push(hint[hint.len() - 1].clone());
+		}
+		let amt_msat = invoice.amount_pico_btc().unwrap() / 10;
+
+		let first_hops = nodes[0].node.list_usable_channels();
+		let network_graph = nodes[0].net_graph_msg_handler.network_graph.read().unwrap();
+		let logger = test_utils::TestLogger::new();
+		let route = router::get_route(
+			&nodes[0].node.get_our_node_id(),
+			&network_graph,
+			&invoice.recover_payee_pub_key(),
+			Some(invoice.features().unwrap().clone()),
+			Some(&first_hops.iter().collect::<Vec<_>>()),
+			&last_hops.iter().collect::<Vec<_>>(),
+			amt_msat,
+			*invoice.min_final_cltv_expiry().unwrap() as u32,
+			&logger,
+		).unwrap();
+
+		let payment_event = {
+			let mut payment_hash = PaymentHash([0; 32]);
+			payment_hash.0.copy_from_slice(&invoice.payment_hash().as_ref()[0..32]);
+			nodes[0].node.send_payment(&route, payment_hash, &Some(invoice.payment_secret().unwrap().clone())).unwrap();
+			let mut added_monitors = nodes[0].chain_monitor.added_monitors.lock().unwrap();
+			assert_eq!(added_monitors.len(), 1);
+			added_monitors.clear();
+
+			let mut events = nodes[0].node.get_and_clear_pending_msg_events();
+			assert_eq!(events.len(), 1);
+			SendEvent::from_event(events.remove(0))
+
+		};
+		nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
+		nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg);
+		let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap();
+		assert_eq!(added_monitors.len(), 1);
+		added_monitors.clear();
+		let events = nodes[1].node.get_and_clear_pending_msg_events();
+		assert_eq!(events.len(), 2);
+	}
 }