f Account for Invoice being renamed to Bolt11Invoice

Author: tnull

bindings/ldk_node.udl

@@ -66,19 +66,19 @@ interface LDKNode {
 	[Throws=NodeError]
 	void sync_wallets();
 	[Throws=NodeError]
-	PaymentHash send_payment([ByRef]Invoice invoice);
+	PaymentHash send_payment([ByRef]Bolt11Invoice invoice);
 	[Throws=NodeError]
-	PaymentHash send_payment_using_amount([ByRef]Invoice invoice, u64 amount_msat);
+	PaymentHash send_payment_using_amount([ByRef]Bolt11Invoice invoice, u64 amount_msat);
 	[Throws=NodeError]
 	PaymentHash send_spontaneous_payment(u64 amount_msat, PublicKey node_id);
 	[Throws=NodeError]
-	void send_payment_probe([ByRef]Invoice invoice);
+	void send_payment_probe([ByRef]Bolt11Invoice invoice);
 	[Throws=NodeError]
 	void send_spontaneous_payment_probe(u64 amount_msat, PublicKey node_id);
 	[Throws=NodeError]
-	Invoice receive_payment(u64 amount_msat, [ByRef]string description, u32 expiry_secs);
+	Bolt11Invoice receive_payment(u64 amount_msat, [ByRef]string description, u32 expiry_secs);
 	[Throws=NodeError]
-	Invoice receive_variable_amount_payment([ByRef]string description, u32 expiry_secs);
+	Bolt11Invoice receive_variable_amount_payment([ByRef]string description, u32 expiry_secs);
 	PaymentDetails? payment([ByRef]PaymentHash payment_hash);
 	[Throws=NodeError]
 	boolean remove_payment([ByRef]PaymentHash payment_hash);
@@ -235,7 +235,7 @@ typedef string PublicKey;
 typedef string Address;
 
 [Custom]
-typedef string Invoice;
+typedef string Bolt11Invoice;
 
 [Custom]
 typedef string PaymentHash;

src/lib.rs

@@ -27,7 +27,7 @@
 //!
 //! ```no_run
 //! use ldk_node::{Builder, NetAddress};
-//! use ldk_node::lightning_invoice::Invoice;
+//! use ldk_node::lightning_invoice::Bolt11Invoice;
 //! use ldk_node::bitcoin::secp256k1::PublicKey;
 //! use ldk_node::bitcoin::Network;
 //! use std::str::FromStr;
@@ -54,7 +54,7 @@
 //! 	println!("EVENT: {:?}", event);
 //! 	node.event_handled();
 //!
-//! 	let invoice = Invoice::from_str("INVOICE_STR").unwrap();
+//! 	let invoice = Bolt11Invoice::from_str("INVOICE_STR").unwrap();
 //! 	node.send_payment(&invoice).unwrap();
 //!
 //! 	node.stop().unwrap();
@@ -137,7 +137,7 @@ use lightning_background_processor::process_events_async;
 use lightning_transaction_sync::EsploraSyncClient;
 
 use lightning::routing::router::{PaymentParameters, RouteParameters, Router as LdkRouter};
-use lightning_invoice::{payment, Currency, Invoice};
+use lightning_invoice::{payment, Bolt11Invoice, Currency};
 
 use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::hashes::Hash;
@@ -1037,7 +1037,7 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 	}
 
 	/// Send a payment given an invoice.
-	pub fn send_payment(&self, invoice: &Invoice) -> Result<PaymentHash, Error> {
+	pub fn send_payment(&self, invoice: &Bolt11Invoice) -> Result<PaymentHash, Error> {
 		let rt_lock = self.runtime.read().unwrap();
 		if rt_lock.is_none() {
 			return Err(Error::NotRunning);
@@ -1113,7 +1113,7 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 	/// This can be used to pay a so-called "zero-amount" invoice, i.e., an invoice that leaves the
 	/// amount paid to be determined by the user.
 	pub fn send_payment_using_amount(
-		&self, invoice: &Invoice, amount_msat: u64,
+		&self, invoice: &Bolt11Invoice, amount_msat: u64,
 	) -> Result<PaymentHash, Error> {
 		let rt_lock = self.runtime.read().unwrap();
 		if rt_lock.is_none() {
@@ -1297,7 +1297,7 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 	/// the actual payment. Note this is only useful if there likely is sufficient time for the
 	/// probe to settle before sending out the actual payment, e.g., when waiting for user
 	/// confirmation in a wallet UI.
-	pub fn send_payment_probe(&self, invoice: &Invoice) -> Result<(), Error> {
+	pub fn send_payment_probe(&self, invoice: &Bolt11Invoice) -> Result<(), Error> {
 		let rt_lock = self.runtime.read().unwrap();
 		if rt_lock.is_none() {
 			return Err(Error::NotRunning);
@@ -1391,21 +1391,21 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 	/// given.
 	pub fn receive_payment(
 		&self, amount_msat: u64, description: &str, expiry_secs: u32,
-	) -> Result<Invoice, Error> {
+	) -> Result<Bolt11Invoice, Error> {
 		self.receive_payment_inner(Some(amount_msat), description, expiry_secs)
 	}
 
 	/// Returns a payable invoice that can be used to request and receive a payment for which the
 	/// amount is to be determined by the user, also known as a "zero-amount" invoice.
 	pub fn receive_variable_amount_payment(
 		&self, description: &str, expiry_secs: u32,
-	) -> Result<Invoice, Error> {
+	) -> Result<Bolt11Invoice, Error> {
 		self.receive_payment_inner(None, description, expiry_secs)
 	}
 
 	fn receive_payment_inner(
 		&self, amount_msat: Option<u64>, description: &str, expiry_secs: u32,
-	) -> Result<Invoice, Error> {
+	) -> Result<Bolt11Invoice, Error> {
 		let currency = Currency::from(self.config.network);
 		let keys_manager = Arc::clone(&self.keys_manager);
 		let invoice = match lightning_invoice::utils::create_invoice_from_channelmanager(

src/uniffi_types.rs

@@ -10,7 +10,7 @@ use bitcoin::hashes::Hash;
 use bitcoin::secp256k1::PublicKey;
 use bitcoin::{Address, Txid};
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
-use lightning_invoice::{Invoice, SignedRawInvoice};
+use lightning_invoice::{Bolt11Invoice, SignedRawBolt11Invoice};
 
 use bip39::Mnemonic;
 
@@ -53,12 +53,12 @@ impl UniffiCustomTypeConverter for Address {
 	}
 }
 
-impl UniffiCustomTypeConverter for Invoice {
+impl UniffiCustomTypeConverter for Bolt11Invoice {
 	type Builtin = String;
 
 	fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
-		if let Ok(signed) = val.parse::<SignedRawInvoice>() {
-			if let Ok(invoice) = Invoice::from_signed(signed) {
+		if let Ok(signed) = val.parse::<SignedRawBolt11Invoice>() {
+			if let Ok(invoice) = Bolt11Invoice::from_signed(signed) {
 				return Ok(invoice);
 			}
 		}