X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-invoice%2Fsrc%2Futils.rs;h=d9e1847f1a735442a751e35cda6b34cc6d8c1fca;hb=31807bc2f656aa4996b701d39eca12f0cc912f57;hp=4f421b9ecc0af095f8d45b95f9ac87c63ad7518c;hpb=2cae6f0ccb0e6b9e3d1c94359a906ddb4421be10;p=rust-lightning diff --git a/lightning-invoice/src/utils.rs b/lightning-invoice/src/utils.rs index 4f421b9e..d9e1847f 100644 --- a/lightning-invoice/src/utils.rs +++ b/lightning-invoice/src/utils.rs @@ -7,7 +7,7 @@ use bech32::ToBase32; use bitcoin_hashes::Hash; use lightning::chain; use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator}; -use lightning::chain::keysinterface::{Recipient, NodeSigner, SignerProvider, EntropySource}; +use lightning::sign::{Recipient, NodeSigner, SignerProvider, EntropySource}; use lightning::ln::{PaymentHash, PaymentSecret}; use lightning::ln::channelmanager::{ChannelDetails, ChannelManager, MIN_FINAL_CLTV_EXPIRY_DELTA}; use lightning::ln::channelmanager::{PhantomRouteHints, MIN_CLTV_EXPIRY_DELTA}; @@ -18,6 +18,7 @@ use lightning::util::logger::Logger; use secp256k1::PublicKey; use core::ops::Deref; use core::time::Duration; +use core::iter::Iterator; /// Utility to create an invoice that can be paid to one of multiple nodes, or a "phantom invoice." /// See [`PhantomKeysManager`] for more information on phantom node payments. @@ -50,7 +51,7 @@ use core::time::Duration; /// invoices in its `sign_invoice` implementation ([`PhantomKeysManager`] satisfies this /// requirement). /// -/// [`PhantomKeysManager`]: lightning::chain::keysinterface::PhantomKeysManager +/// [`PhantomKeysManager`]: lightning::sign::PhantomKeysManager /// [`ChannelManager::get_phantom_route_hints`]: lightning::ln::channelmanager::ChannelManager::get_phantom_route_hints /// [`ChannelManager::create_inbound_payment`]: lightning::ln::channelmanager::ChannelManager::create_inbound_payment /// [`ChannelManager::create_inbound_payment_for_hash`]: lightning::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash @@ -107,7 +108,7 @@ where /// invoices in its `sign_invoice` implementation ([`PhantomKeysManager`] satisfies this /// requirement). /// -/// [`PhantomKeysManager`]: lightning::chain::keysinterface::PhantomKeysManager +/// [`PhantomKeysManager`]: lightning::sign::PhantomKeysManager /// [`ChannelManager::get_phantom_route_hints`]: lightning::ln::channelmanager::ChannelManager::get_phantom_route_hints /// [`ChannelManager::create_inbound_payment`]: lightning::ln::channelmanager::ChannelManager::create_inbound_payment /// [`ChannelManager::create_inbound_payment_for_hash`]: lightning::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash @@ -227,7 +228,7 @@ where /// * Select up to three channels per node. /// * Select one hint from each node, up to three hints or until we run out of hints. /// -/// [`PhantomKeysManager`]: lightning::chain::keysinterface::PhantomKeysManager +/// [`PhantomKeysManager`]: lightning::sign::PhantomKeysManager fn select_phantom_hints(amt_msat: Option, phantom_route_hints: Vec, logger: L) -> Vec where @@ -292,6 +293,33 @@ where } } +/// Draw items iteratively from multiple iterators. The items are retrieved by index and +/// rotates through the iterators - first the zero index then the first index then second index, etc. +fn rotate_through_iterators>(mut vecs: Vec) -> impl Iterator { + let mut iterations = 0; + + core::iter::from_fn(move || { + let mut exhausted_iterators = 0; + loop { + if vecs.is_empty() { + return None; + } + let next_idx = iterations % vecs.len(); + iterations += 1; + if let Some(item) = vecs[next_idx].next() { + return Some(item); + } + // exhausted_vectors increase when the "next_idx" vector is exhausted + exhausted_iterators += 1; + // The check for exhausted iterators gets reset to 0 after each yield of `Some()` + // The loop will return None when all of the nested iterators are exhausted + if exhausted_iterators == vecs.len() { + return None; + } + } + }) +} + #[cfg(feature = "std")] /// Utility to construct an invoice. Generally, unless you want to do something like a custom /// cltv_expiry, this is what you should be using to create an invoice. The reason being, this @@ -629,7 +657,7 @@ fn sort_and_filter_channels( // previous channel to avoid announcing non-public channels. let new_now_public = channel.is_public && !entry.get().is_public; // Decide whether we prefer the currently selected channel with the node to the new one, - // based on their inbound capacity. + // based on their inbound capacity. let prefer_current = prefer_current_channel(min_inbound_capacity_msat, current_max_capacity, channel.inbound_capacity_msat); // If the public-ness of the channel has not changed (in which case simply defer to @@ -768,7 +796,7 @@ mod test { use crate::{Currency, Description, InvoiceDescription, SignOrCreationError, CreationError}; use bitcoin_hashes::{Hash, sha256}; use bitcoin_hashes::sha256::Hash as Sha256; - use lightning::chain::keysinterface::PhantomKeysManager; + use lightning::sign::PhantomKeysManager; use lightning::events::{MessageSendEvent, MessageSendEventsProvider, Event}; use lightning::ln::{PaymentPreimage, PaymentHash}; use lightning::ln::channelmanager::{PhantomRouteHints, MIN_FINAL_CLTV_EXPIRY_DELTA, PaymentId, RecipientOnionFields, Retry}; @@ -777,7 +805,7 @@ mod test { use lightning::routing::router::{PaymentParameters, RouteParameters}; use lightning::util::test_utils; use lightning::util::config::UserConfig; - use crate::utils::create_invoice_from_channelmanager_and_duration_since_epoch; + use crate::utils::{create_invoice_from_channelmanager_and_duration_since_epoch, rotate_through_iterators}; use std::collections::HashSet; #[test] @@ -793,10 +821,10 @@ mod test { // Minimum set, prefer candidate channel over minimum + buffer. assert_eq!(crate::utils::prefer_current_channel(Some(100), 105, 125), false); - + // Minimum set, both channels sufficient, prefer smaller current channel. assert_eq!(crate::utils::prefer_current_channel(Some(100), 115, 125), true); - + // Minimum set, both channels sufficient, prefer smaller candidate channel. assert_eq!(crate::utils::prefer_current_channel(Some(100), 200, 160), false); @@ -838,8 +866,8 @@ mod test { let payment_params = PaymentParameters::from_node_id(invoice.recover_payee_pub_key(), invoice.min_final_cltv_expiry_delta() as u32) - .with_features(invoice.features().unwrap().clone()) - .with_route_hints(invoice.route_hints()); + .with_bolt11_features(invoice.features().unwrap().clone()).unwrap() + .with_route_hints(invoice.route_hints()).unwrap(); let route_params = RouteParameters { payment_params, final_value_msat: invoice.amount_milli_satoshis().unwrap(), @@ -1294,8 +1322,8 @@ mod test { let payment_params = PaymentParameters::from_node_id(invoice.recover_payee_pub_key(), invoice.min_final_cltv_expiry_delta() as u32) - .with_features(invoice.features().unwrap().clone()) - .with_route_hints(invoice.route_hints()); + .with_bolt11_features(invoice.features().unwrap().clone()).unwrap() + .with_route_hints(invoice.route_hints()).unwrap(); let params = RouteParameters { payment_params, final_value_msat: invoice.amount_milli_satoshis().unwrap(), @@ -1886,4 +1914,111 @@ mod test { _ => panic!(), } } + + #[test] + fn test_rotate_through_iterators() { + // two nested vectors + let a = vec![vec!["a0", "b0", "c0"].into_iter(), vec!["a1", "b1"].into_iter()]; + let result = rotate_through_iterators(a).collect::>(); + + let expected = vec!["a0", "a1", "b0", "b1", "c0"]; + assert_eq!(expected, result); + + // test single nested vector + let a = vec![vec!["a0", "b0", "c0"].into_iter()]; + let result = rotate_through_iterators(a).collect::>(); + + let expected = vec!["a0", "b0", "c0"]; + assert_eq!(expected, result); + + // test second vector with only one element + let a = vec![vec!["a0", "b0", "c0"].into_iter(), vec!["a1"].into_iter()]; + let result = rotate_through_iterators(a).collect::>(); + + let expected = vec!["a0", "a1", "b0", "c0"]; + assert_eq!(expected, result); + + // test three nestend vectors + let a = vec![vec!["a0"].into_iter(), vec!["a1", "b1", "c1"].into_iter(), vec!["a2"].into_iter()]; + let result = rotate_through_iterators(a).collect::>(); + + let expected = vec!["a0", "a1", "a2", "b1", "c1"]; + assert_eq!(expected, result); + + // test single nested vector with a single value + let a = vec![vec!["a0"].into_iter()]; + let result = rotate_through_iterators(a).collect::>(); + + let expected = vec!["a0"]; + assert_eq!(expected, result); + + // test single empty nested vector + let a:Vec> = vec![vec![].into_iter()]; + let result = rotate_through_iterators(a).collect::>(); + let expected:Vec<&str> = vec![]; + + assert_eq!(expected, result); + + // test first nested vector is empty + let a:Vec>= vec![vec![].into_iter(), vec!["a1", "b1", "c1"].into_iter()]; + let result = rotate_through_iterators(a).collect::>(); + + let expected = vec!["a1", "b1", "c1"]; + assert_eq!(expected, result); + + // test two empty vectors + let a:Vec> = vec![vec![].into_iter(), vec![].into_iter()]; + let result = rotate_through_iterators(a).collect::>(); + + let expected:Vec<&str> = vec![]; + assert_eq!(expected, result); + + // test an empty vector amongst other filled vectors + let a = vec![ + vec!["a0", "b0", "c0"].into_iter(), + vec![].into_iter(), + vec!["a1", "b1", "c1"].into_iter(), + vec!["a2", "b2", "c2"].into_iter(), + ]; + let result = rotate_through_iterators(a).collect::>(); + + let expected = vec!["a0", "a1", "a2", "b0", "b1", "b2", "c0", "c1", "c2"]; + assert_eq!(expected, result); + + // test a filled vector between two empty vectors + let a = vec![vec![].into_iter(), vec!["a1", "b1", "c1"].into_iter(), vec![].into_iter()]; + let result = rotate_through_iterators(a).collect::>(); + + let expected = vec!["a1", "b1", "c1"]; + assert_eq!(expected, result); + + // test an empty vector at the end of the vectors + let a = vec![vec!["a0", "b0", "c0"].into_iter(), vec![].into_iter()]; + let result = rotate_through_iterators(a).collect::>(); + + let expected = vec!["a0", "b0", "c0"]; + assert_eq!(expected, result); + + // test multiple empty vectors amongst multiple filled vectors + let a = vec![ + vec![].into_iter(), + vec!["a1", "b1", "c1"].into_iter(), + vec![].into_iter(), + vec!["a3", "b3"].into_iter(), + vec![].into_iter(), + ]; + + let result = rotate_through_iterators(a).collect::>(); + + let expected = vec!["a1", "a3", "b1", "b3", "c1"]; + assert_eq!(expected, result); + + // test one element in the first nested vectore and two elements in the second nested + // vector + let a = vec![vec!["a0"].into_iter(), vec!["a1", "b1"].into_iter()]; + let result = rotate_through_iterators(a).collect::>(); + + let expected = vec!["a0", "a1", "b1"]; + assert_eq!(expected, result); + } }