f Allow overpayment, improve "zero-amount" invoicing

Author: tnull

src/error.rs

@@ -13,6 +13,8 @@ pub enum Error {
 	ConnectionFailed,
 	/// Payment of the given invoice has already been intiated.
 	NonUniquePaymentHash,
+	/// The given amount is invalid.
+	InvalidAmount,
 	/// The given invoice is invalid.
 	InvalidInvoice,
 	/// Invoice creation failed.
@@ -47,6 +49,7 @@ impl fmt::Display for Error {
 			}
 			Self::ConnectionFailed => write!(f, "Network connection closed."),
 			Self::NonUniquePaymentHash => write!(f, "An invoice must not get payed twice."),
+			Self::InvalidAmount => write!(f, "The given amount is invalid."),
 			Self::InvalidInvoice => write!(f, "The given invoice is invalid."),
 			Self::InvoiceCreationFailed => write!(f, "Failed to create invoice."),
 			Self::InsufficientFunds => {

src/lib.rs

@@ -887,7 +887,7 @@ impl Node {
 			Ok(_payment_id) => {
 				let payee_pubkey = invoice.recover_payee_pub_key();
 				let amt_msat = invoice.amount_milli_satoshis().unwrap();
-				log_info!(self.logger, "Initiated sending {} msats to {}", amt_msat, payee_pubkey);
+				log_info!(self.logger, "Initiated sending {}msat to {}", amt_msat, payee_pubkey);
 
 				outbound_payments_lock.insert(
 					payment_hash,
@@ -922,9 +922,13 @@ impl Node {
 		}
 	}
 
-	/// Send a payement given a so-called "zero amount" invoice, i.e., an invoice that leaves the
+	/// Send a payment given an invoice and an amount in millisatoshi.
+	///
+	/// This will fail if the amount given is less than the value required by the given invoice.
+	///
+	/// 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_adjustable_value_payment(
+	pub fn send_payment_using_amount(
 		&self, invoice: Invoice, amount_msat: u64,
 	) -> Result<PaymentHash, Error> {
 		if self.running.read().unwrap().is_none() {
@@ -933,27 +937,58 @@ impl Node {
 
 		let mut outbound_payments_lock = self.outbound_payments.lock().unwrap();
 
+		if let Some(invoice_amount_msat) = invoice.amount_milli_satoshis() {
+			if amount_msat < invoice_amount_msat {
+				log_error!(
+					self.logger,
+					"Failed to pay as the given amount needs to be larger or equal to the invoice amount: required {}msat, gave {}msat.", invoice_amount_msat, amount_msat);
+				return Err(Error::InvalidAmount);
+			}
+		}
+
+		let payment_id = PaymentId(invoice.payment_hash().into_inner());
 		let payment_hash = PaymentHash((*invoice.payment_hash()).into_inner());
 		let payment_secret = Some(*invoice.payment_secret());
-
-		if invoice.amount_milli_satoshis().is_some() {
-			log_error!(
-				self.logger,
-				"Failed to pay the given invoice: expected \"zero-amount\" invoice, please use send_payment."
-			);
-			return Err(Error::InvalidInvoice);
+		let expiry_time = invoice
+			.clone()
+			.into_signed_raw()
+			.raw_invoice()
+			.data
+			.timestamp
+			.as_duration_since_epoch()
+			+ invoice.expiry_time();
+		let mut payment_params = PaymentParameters::from_node_id(
+			invoice.recover_payee_pub_key(),
+			invoice.min_final_cltv_expiry_delta() as u32,
+		)
+		.with_expiry_time(expiry_time.as_secs())
+		.with_route_hints(invoice.route_hints());
+		if let Some(features) = invoice.features() {
+			payment_params = payment_params.with_features(features.clone());
 		}
-
-		match lightning_invoice::payment::pay_zero_value_invoice(
-			&invoice,
-			amount_msat,
-			Retry::Timeout(LDK_PAYMENT_RETRY_TIMEOUT),
-			self.channel_manager.as_ref(),
-		) {
+		let route_params = RouteParameters { payment_params, final_value_msat: amount_msat };
+
+		let retry_strategy = Retry::Timeout(LDK_PAYMENT_RETRY_TIMEOUT);
+
+		match self
+			.channel_manager
+			.send_payment_with_retry(
+				payment_hash,
+				&payment_secret,
+				payment_id,
+				route_params,
+				retry_strategy,
+			)
+			.map_err(payment::PaymentError::Sending)
+		{
 			Ok(_payment_id) => {
 				let payee_pubkey = invoice.recover_payee_pub_key();
-				let amt_msat = invoice.amount_milli_satoshis().unwrap();
-				log_info!(self.logger, "Initiated sending {} msats to {}", amt_msat, payee_pubkey);
+				log_info!(
+					self.logger,
+					"Initiated sending {} msat to {}",
+					amount_msat,
+					payee_pubkey
+				);
 
 				outbound_payments_lock.insert(
 					payment_hash,
@@ -1018,7 +1053,7 @@ impl Node {
 			Retry::Timeout(LDK_PAYMENT_RETRY_TIMEOUT),
 		) {
 			Ok(_payment_id) => {
-				log_info!(self.logger, "Initiated sending {} msats to {}.", amount_msat, node_id);
+				log_info!(self.logger, "Initiated sending {}msat to {}.", amount_msat, node_id);
 				outbound_payments_lock.insert(
 					payment_hash,
 					PaymentInfo {
@@ -1046,8 +1081,23 @@ impl Node {
 		}
 	}
 
-	/// Returns a payable invoice that can be used to request and receive a payment.
+	/// Returns a payable invoice that can be used to request and receive a payment of the amount
+	/// given.
 	pub fn receive_payment(
+		&self, amount_msat: u64, description: &str, expiry_secs: u32,
+	) -> Result<Invoice, 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> {
+		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> {
 		let mut inbound_payments_lock = self.inbound_payments.lock().unwrap();

src/tests/functional_tests.rs

@@ -197,14 +197,59 @@ fn channel_full_cycle() {
 	};
 
 	println!("\nB receive_payment");
-	let invoice = node_b.receive_payment(Some(1000000), &"asdf", 9217).unwrap();
+	let invoice = node_b.receive_payment(1000000, &"asdf", 9217).unwrap();
 
 	println!("\nA send_payment");
 	node_a.send_payment(invoice).unwrap();
 
 	expect_event!(node_a, PaymentSuccessful);
 	expect_event!(node_b, PaymentReceived);
 
+	// Test under-/overpayment
+	let invoice_amount = 1000000;
+	let invoice = node_b.receive_payment(invoice_amount, &"asdf", 9217).unwrap();
+
+	let underpaid_amount = invoice_amount - 1;
+	assert_eq!(
+		Err(Error::InvalidAmount),
+		node_a.send_payment_using_amount(invoice, underpaid_amount)
+	);
+
+	let invoice = node_b.receive_payment(invoice_amount, &"asdf", 9217).unwrap();
+	let overpaid_amount = invoice_amount + 100;
+	node_a.send_payment_using_amount(invoice, overpaid_amount).unwrap();
+	expect_event!(node_a, PaymentSuccessful);
+	let received_amount = match node_b.next_event() {
+		ref e @ Event::PaymentReceived { amount_msat, .. } => {
+			println!("{} got event {:?}", std::stringify!(node_b), e);
+			node_b.event_handled();
+			amount_msat
+		}
+		ref e => {
+			panic!("{} got unexpected event!: {:?}", std::stringify!(node_b), e);
+		}
+	};
+	assert_eq!(received_amount, overpaid_amount);
+
+	// Test "zero-amount" invoice payment
+	let variable_amount_invoice = node_b.receive_variable_amount_payment(&"asdf", 9217).unwrap();
+	let determined_amount = 1234567;
+	assert_eq!(Err(Error::InvalidInvoice), node_a.send_payment(variable_amount_invoice.clone()));
+	node_a.send_payment_using_amount(variable_amount_invoice, determined_amount).unwrap();
+
+	expect_event!(node_a, PaymentSuccessful);
+	let received_amount = match node_b.next_event() {
+		ref e @ Event::PaymentReceived { amount_msat, .. } => {
+			println!("{} got event {:?}", std::stringify!(node_b), e);
+			node_b.event_handled();
+			amount_msat
+		}
+		ref e => {
+			panic!("{} got unexpected event!: {:?}", std::stringify!(node_b), e);
+		}
+	};
+	assert_eq!(received_amount, determined_amount);
+
 	node_b.close_channel(&channel_id, &node_a.node_id()).unwrap();
 	expect_event!(node_a, ChannelClosed);
 	expect_event!(node_b, ChannelClosed);
@@ -217,7 +262,7 @@ fn channel_full_cycle() {
 	node_b.sync_wallets().unwrap();
 
 	assert!(node_a.on_chain_balance().unwrap().get_spendable() > 90000);
-	assert_eq!(node_b.on_chain_balance().unwrap().get_spendable(), 101000);
+	assert_eq!(node_b.on_chain_balance().unwrap().get_spendable(), 103234);
 
 	node_a.stop().unwrap();
 	println!("\nA stopped");