Merge pull request #1219 from TheBlueMatt/2021-12-0.0.104-bindings

[rust-lightning] / lightning-invoice / src / utils.rs

diff --git a/lightning-invoice/src/utils.rs b/lightning-invoice/src/utils.rs
index 35a74b6a5ac6a3bf6a41984babc8619551a19622..53fdc13f2fc2255f7102a3225252f4139e887efc 100644 (file)
--- a/lightning-invoice/src/utils.rs
+++ b/lightning-invoice/src/utils.rs
@@ -1,6 +1,6 @@
 //! Convenient utilities to create an invoice.
 
-use {Currency, DEFAULT_EXPIRY_TIME, Invoice, InvoiceBuilder, SignOrCreationError, RawInvoice};
+use {CreationError, Currency, DEFAULT_EXPIRY_TIME, Invoice, InvoiceBuilder, SignOrCreationError, RawInvoice};
 use payment::{Payer, Router};
 
 use bech32::ToBase32;
@@ -8,10 +8,10 @@ use bitcoin_hashes::Hash;
 use lightning::chain;
 use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator};
 use lightning::chain::keysinterface::{Sign, KeysInterface};
-use lightning::ln::{PaymentHash, PaymentSecret};
+use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use lightning::ln::channelmanager::{ChannelDetails, ChannelManager, PaymentId, PaymentSendFailure, MIN_FINAL_CLTV_EXPIRY};
 use lightning::ln::msgs::LightningError;
-use lightning::routing;
+use lightning::routing::scoring::Score;
 use lightning::routing::network_graph::{NetworkGraph, RoutingFees};
 use lightning::routing::router::{Route, RouteHint, RouteHintHop, RouteParameters, find_route};
 use lightning::util::logger::Logger;
@@ -60,11 +60,11 @@ where
                }]));
        }
 
+       // `create_inbound_payment` only returns an error if the amount is greater than the total bitcoin
+       // supply.
        let (payment_hash, payment_secret) = channelmanager.create_inbound_payment(
-               amt_msat,
-               DEFAULT_EXPIRY_TIME.try_into().unwrap(),
-               0,
-       );
+               amt_msat, DEFAULT_EXPIRY_TIME.try_into().unwrap())
+               .map_err(|()| SignOrCreationError::CreationError(CreationError::InvalidAmount))?;
        let our_node_pubkey = channelmanager.get_our_node_id();
        let mut invoice = InvoiceBuilder::new(network)
                .description(description)
@@ -97,23 +97,23 @@ where
 }
 
 /// A [`Router`] implemented using [`find_route`].
-pub struct DefaultRouter<G, L: Deref> where G: Deref<Target = NetworkGraph>, L::Target: Logger {
+pub struct DefaultRouter<G: Deref<Target = NetworkGraph>, L: Deref> where L::Target: Logger {
        network_graph: G,
        logger: L,
 }
 
-impl<G, L: Deref> DefaultRouter<G, L> where G: Deref<Target = NetworkGraph>, L::Target: Logger {
+impl<G: Deref<Target = NetworkGraph>, L: Deref> DefaultRouter<G, L> where L::Target: Logger {
        /// Creates a new router using the given [`NetworkGraph`] and  [`Logger`].
        pub fn new(network_graph: G, logger: L) -> Self {
                Self { network_graph, logger }
        }
 }
 
-impl<G, L: Deref, S: routing::Score> Router<S> for DefaultRouter<G, L>
-where G: Deref<Target = NetworkGraph>, L::Target: Logger {
+impl<G: Deref<Target = NetworkGraph>, L: Deref, S: Score> Router<S> for DefaultRouter<G, L>
+where L::Target: Logger {
        fn find_route(
-               &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>,
-               scorer: &S
+               &self, payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash,
+               first_hops: Option<&[&ChannelDetails]>, scorer: &S
        ) -> Result<Route, LightningError> {
                find_route(payer, params, &*self.network_graph, first_hops, &*self.logger, scorer)
        }
@@ -141,11 +141,22 @@ where
                self.send_payment(route, payment_hash, payment_secret)
        }
 
+       fn send_spontaneous_payment(
+               &self, route: &Route, payment_preimage: PaymentPreimage,
+       ) -> Result<PaymentId, PaymentSendFailure> {
+               self.send_spontaneous_payment(route, Some(payment_preimage))
+                       .map(|(_, payment_id)| payment_id)
+       }
+
        fn retry_payment(
                &self, route: &Route, payment_id: PaymentId
        ) -> Result<(), PaymentSendFailure> {
                self.retry_payment(route, payment_id)
        }
+
+       fn abandon_payment(&self, payment_id: PaymentId) {
+               self.abandon_payment(payment_id)
+       }
 }
 
 #[cfg(test)]