mirrors/rust-lightning
1
0
Fork 0
mirror of https://github.com/lightningdevkit/rust-lightning.git synced 2025-02-24 15:02:20 +01:00
Code Issues Projects Releases Packages Wiki Activity

Parameterize ChannelManager by a Router trait

Browse source 
This will be used in upcoming work to fetch routes on-the-fly for payment
retries, which will no longer be the responsibility of InvoicePayer.
This commit is contained in:
Valentine Wallace 2022-10-28 11:31:24 -04:00
parent 7d84a45ae8
commit 2e06efe2ff
No known key found for this signature in database
GPG key ID: FD3E106A2CE099B4
17 changed files with 271 additions and 151 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
fuzz/src/chanmon_consistency.rs
View file

@ -38,9 +38,9 @@ use lightning::chain::transaction::OutPoint;
use lightning::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget, FeeEstimator}; use lightning::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget, FeeEstimator};
use lightning::chain::keysinterface::{KeyMaterial, KeysInterface, InMemorySigner, Recipient, EntropySource, NodeSigner, SignerProvider}; use lightning::chain::keysinterface::{KeyMaterial, KeysInterface, InMemorySigner, Recipient, EntropySource, NodeSigner, SignerProvider};
use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret}; use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
use lightning::ln::channelmanager::{self, ChainParameters, ChannelManager, PaymentSendFailure, ChannelManagerReadArgs, PaymentId}; use lightning::ln::channelmanager::{self, ChainParameters, ChannelDetails, ChannelManager, PaymentSendFailure, ChannelManagerReadArgs, PaymentId};
use lightning::ln::channel::FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE; use lightning::ln::channel::FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE;
use lightning::ln::msgs::{CommitmentUpdate, ChannelMessageHandler, DecodeError, UpdateAddHTLC, Init}; use lightning::ln::msgs::{self, CommitmentUpdate, ChannelMessageHandler, DecodeError, UpdateAddHTLC, Init};
use lightning::ln::script::ShutdownScript; use lightning::ln::script::ShutdownScript;
use lightning::util::enforcing_trait_impls::{EnforcingSigner, EnforcementState}; use lightning::util::enforcing_trait_impls::{EnforcingSigner, EnforcementState};
use lightning::util::errors::APIError; use lightning::util::errors::APIError;
@ -49,7 +49,7 @@ use lightning::util::logger::Logger;
use lightning::util::config::UserConfig; use lightning::util::config::UserConfig;
use lightning::util::events::MessageSendEventsProvider; use lightning::util::events::MessageSendEventsProvider;
use lightning::util::ser::{Readable, ReadableArgs, Writeable, Writer}; use lightning::util::ser::{Readable, ReadableArgs, Writeable, Writer};
use lightning::routing::router::{Route, RouteHop}; use lightning::routing::router::{InFlightHtlcs, Route, RouteHop, RouteParameters, Router};
use crate::utils::test_logger::{self, Output}; use crate::utils::test_logger::{self, Output};
use crate::utils::test_persister::TestPersister; use crate::utils::test_persister::TestPersister;
@ -85,6 +85,24 @@ impl FeeEstimator for FuzzEstimator {
} }
} }
struct FuzzRouter {}
impl Router for FuzzRouter {
fn find_route(
&self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
_inflight_htlcs: InFlightHtlcs
) -> Result<Route, msgs::LightningError> {
Err(msgs::LightningError {
err: String::from("Not implemented"),
action: msgs::ErrorAction::IgnoreError
})
}
fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}
fn notify_payment_probe_successful(&self, _path: &[&RouteHop]) {}
fn notify_payment_probe_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
}
pub struct TestBroadcaster {} pub struct TestBroadcaster {}
impl BroadcasterInterface for TestBroadcaster { impl BroadcasterInterface for TestBroadcaster {
fn broadcast_transaction(&self, _tx: &Transaction) { } fn broadcast_transaction(&self, _tx: &Transaction) { }
@ -310,7 +328,7 @@ fn check_payment_err(send_err: PaymentSendFailure) {
} }
} }
type ChanMan = ChannelManager<Arc<TestChainMonitor>, Arc<TestBroadcaster>, Arc<KeyProvider>, Arc<FuzzEstimator>, Arc<dyn Logger>>; type ChanMan<'a> = ChannelManager<Arc<TestChainMonitor>, Arc<TestBroadcaster>, Arc<KeyProvider>, Arc<FuzzEstimator>, &'a FuzzRouter, Arc<dyn Logger>>;
#[inline] #[inline]
fn get_payment_secret_hash(dest: &ChanMan, payment_id: &mut u8) -> Option<(PaymentSecret, PaymentHash)> { fn get_payment_secret_hash(dest: &ChanMan, payment_id: &mut u8) -> Option<(PaymentSecret, PaymentHash)> {
@ -381,6 +399,7 @@ fn send_hop_payment(source: &ChanMan, middle: &ChanMan, middle_chan_id: u64, des
pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out) { pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out) {
let out = SearchingOutput::new(underlying_out); let out = SearchingOutput::new(underlying_out);
let broadcast = Arc::new(TestBroadcaster{}); let broadcast = Arc::new(TestBroadcaster{});
let router = FuzzRouter {};
macro_rules! make_node { macro_rules! make_node {
($node_id: expr, $fee_estimator: expr) => { { ($node_id: expr, $fee_estimator: expr) => { {
@ -399,7 +418,7 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out) {
network, network,
best_block: BestBlock::from_genesis(network), best_block: BestBlock::from_genesis(network),
}; };
(ChannelManager::new($fee_estimator.clone(), monitor.clone(), broadcast.clone(), Arc::clone(&logger), keys_manager.clone(), config, params), (ChannelManager::new($fee_estimator.clone(), monitor.clone(), broadcast.clone(), &router, Arc::clone(&logger), keys_manager.clone(), config, params),
monitor, keys_manager) monitor, keys_manager)
} } } }
} }
@ -433,6 +452,7 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out) {
fee_estimator: $fee_estimator.clone(), fee_estimator: $fee_estimator.clone(),
chain_monitor: chain_monitor.clone(), chain_monitor: chain_monitor.clone(),
tx_broadcaster: broadcast.clone(), tx_broadcaster: broadcast.clone(),
router: &router,
logger, logger,
default_config: config, default_config: config,
channel_monitors: monitor_refs, channel_monitors: monitor_refs,

37
fuzz/src/full_stack.rs
View file

@ -35,12 +35,12 @@ use lightning::chain::chainmonitor;
use lightning::chain::transaction::OutPoint; use lightning::chain::transaction::OutPoint;
use lightning::chain::keysinterface::{InMemorySigner, Recipient, KeyMaterial, KeysInterface, EntropySource, NodeSigner, SignerProvider}; use lightning::chain::keysinterface::{InMemorySigner, Recipient, KeyMaterial, KeysInterface, EntropySource, NodeSigner, SignerProvider};
use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret}; use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
use lightning::ln::channelmanager::{ChainParameters, ChannelManager, PaymentId}; use lightning::ln::channelmanager::{ChainParameters, ChannelDetails, ChannelManager, PaymentId};
use lightning::ln::peer_handler::{MessageHandler,PeerManager,SocketDescriptor,IgnoringMessageHandler}; use lightning::ln::peer_handler::{MessageHandler,PeerManager,SocketDescriptor,IgnoringMessageHandler};
use lightning::ln::msgs::DecodeError; use lightning::ln::msgs::{self, DecodeError};
use lightning::ln::script::ShutdownScript; use lightning::ln::script::ShutdownScript;
use lightning::routing::gossip::{P2PGossipSync, NetworkGraph}; use lightning::routing::gossip::{P2PGossipSync, NetworkGraph};
use lightning::routing::router::{find_route, PaymentParameters, RouteParameters}; use lightning::routing::router::{find_route, InFlightHtlcs, PaymentParameters, Route, RouteHop, RouteParameters, Router};
use lightning::routing::scoring::FixedPenaltyScorer; use lightning::routing::scoring::FixedPenaltyScorer;
use lightning::util::config::UserConfig; use lightning::util::config::UserConfig;
use lightning::util::errors::APIError; use lightning::util::errors::APIError;
@ -127,6 +127,24 @@ impl FeeEstimator for FuzzEstimator {
} }
} }
struct FuzzRouter {}
impl Router for FuzzRouter {
fn find_route(
&self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
_inflight_htlcs: InFlightHtlcs
) -> Result<Route, msgs::LightningError> {
Err(msgs::LightningError {
err: String::from("Not implemented"),
action: msgs::ErrorAction::IgnoreError
})
}
fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}
fn notify_payment_probe_successful(&self, _path: &[&RouteHop]) {}
fn notify_payment_probe_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
}
struct TestBroadcaster { struct TestBroadcaster {
txn_broadcasted: Mutex<Vec<Transaction>>, txn_broadcasted: Mutex<Vec<Transaction>>,
} }
@ -162,13 +180,13 @@ impl<'a> std::hash::Hash for Peer<'a> {
} }
} }
type ChannelMan = ChannelManager< type ChannelMan<'a> = ChannelManager<
Arc<chainmonitor::ChainMonitor<EnforcingSigner, Arc<dyn chain::Filter>, Arc<TestBroadcaster>, Arc<FuzzEstimator>, Arc<dyn Logger>, Arc<TestPersister>>>, Arc<chainmonitor::ChainMonitor<EnforcingSigner, Arc<dyn chain::Filter>, Arc<TestBroadcaster>, Arc<FuzzEstimator>, Arc<dyn Logger>, Arc<TestPersister>>>,
Arc<TestBroadcaster>, Arc<KeyProvider>, Arc<FuzzEstimator>, Arc<dyn Logger>>; Arc<TestBroadcaster>, Arc<KeyProvider>, Arc<FuzzEstimator>, &'a FuzzRouter, Arc<dyn Logger>>;
type PeerMan<'a> = PeerManager<Peer<'a>, Arc<ChannelMan>, Arc<P2PGossipSync<Arc<NetworkGraph<Arc<dyn Logger>>>, Arc<dyn chain::Access>, Arc<dyn Logger>>>, IgnoringMessageHandler, Arc<dyn Logger>, IgnoringMessageHandler>; type PeerMan<'a> = PeerManager<Peer<'a>, Arc<ChannelMan<'a>>, Arc<P2PGossipSync<Arc<NetworkGraph<Arc<dyn Logger>>>, Arc<dyn chain::Access>, Arc<dyn Logger>>>, IgnoringMessageHandler, Arc<dyn Logger>, IgnoringMessageHandler>;
struct MoneyLossDetector<'a> { struct MoneyLossDetector<'a> {
manager: Arc<ChannelMan>, manager: Arc<ChannelMan<'a>>,
monitor: Arc<chainmonitor::ChainMonitor<EnforcingSigner, Arc<dyn chain::Filter>, Arc<TestBroadcaster>, Arc<FuzzEstimator>, Arc<dyn Logger>, Arc<TestPersister>>>, monitor: Arc<chainmonitor::ChainMonitor<EnforcingSigner, Arc<dyn chain::Filter>, Arc<TestBroadcaster>, Arc<FuzzEstimator>, Arc<dyn Logger>, Arc<TestPersister>>>,
handler: PeerMan<'a>, handler: PeerMan<'a>,
@ -182,7 +200,7 @@ struct MoneyLossDetector<'a> {
} }
impl<'a> MoneyLossDetector<'a> { impl<'a> MoneyLossDetector<'a> {
pub fn new(peers: &'a RefCell<[bool; 256]>, pub fn new(peers: &'a RefCell<[bool; 256]>,
manager: Arc<ChannelMan>, manager: Arc<ChannelMan<'a>>,
monitor: Arc<chainmonitor::ChainMonitor<EnforcingSigner, Arc<dyn chain::Filter>, Arc<TestBroadcaster>, Arc<FuzzEstimator>, Arc<dyn Logger>, Arc<TestPersister>>>, monitor: Arc<chainmonitor::ChainMonitor<EnforcingSigner, Arc<dyn chain::Filter>, Arc<TestBroadcaster>, Arc<FuzzEstimator>, Arc<dyn Logger>, Arc<TestPersister>>>,
handler: PeerMan<'a>) -> Self { handler: PeerMan<'a>) -> Self {
MoneyLossDetector { MoneyLossDetector {
@ -380,6 +398,7 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
let fee_est = Arc::new(FuzzEstimator { let fee_est = Arc::new(FuzzEstimator {
input: input.clone(), input: input.clone(),
}); });
let router = FuzzRouter {};
macro_rules! get_slice { macro_rules! get_slice {
($len: expr) => { ($len: expr) => {
@ -424,7 +443,7 @@ pub fn do_test(data: &[u8], logger: &Arc<dyn Logger>) {
network, network,
best_block: BestBlock::from_genesis(network), best_block: BestBlock::from_genesis(network),
}; };
let channelmanager = Arc::new(ChannelManager::new(fee_est.clone(), monitor.clone(), broadcast.clone(), Arc::clone(&logger), keys_manager.clone(), config, params)); let channelmanager = Arc::new(ChannelManager::new(fee_est.clone(), monitor.clone(), broadcast.clone(), &router, Arc::clone(&logger), keys_manager.clone(), config, params));
// Adding new calls to `KeysInterface::get_secure_random_bytes` during startup can change all the // Adding new calls to `KeysInterface::get_secure_random_bytes` during startup can change all the
// keys subsequently generated in this test. Rather than regenerating all the messages manually, // keys subsequently generated in this test. Rather than regenerating all the messages manually,
// it's easier to just increment the counter here so the keys don't change. // it's easier to just increment the counter here so the keys don't change.

18
lightning-background-processor/src/lib.rs
View file

@ -22,6 +22,7 @@ use lightning::ln::channelmanager::ChannelManager;
use lightning::ln::msgs::{ChannelMessageHandler, OnionMessageHandler, RoutingMessageHandler}; use lightning::ln::msgs::{ChannelMessageHandler, OnionMessageHandler, RoutingMessageHandler};
use lightning::ln::peer_handler::{CustomMessageHandler, PeerManager, SocketDescriptor}; use lightning::ln::peer_handler::{CustomMessageHandler, PeerManager, SocketDescriptor};
use lightning::routing::gossip::{NetworkGraph, P2PGossipSync}; use lightning::routing::gossip::{NetworkGraph, P2PGossipSync};
use lightning::routing::router::Router;
use lightning::routing::scoring::WriteableScore; use lightning::routing::scoring::WriteableScore;
use lightning::util::events::{Event, EventHandler, EventsProvider}; use lightning::util::events::{Event, EventHandler, EventsProvider};
use lightning::util::logger::Logger; use lightning::util::logger::Logger;
@ -342,6 +343,7 @@ pub async fn process_events_async<
T: 'static + Deref + Send + Sync, T: 'static + Deref + Send + Sync,
K: 'static + Deref + Send + Sync, K: 'static + Deref + Send + Sync,
F: 'static + Deref + Send + Sync, F: 'static + Deref + Send + Sync,
R: 'static + Deref + Send + Sync,
G: 'static + Deref<Target = NetworkGraph<L>> + Send + Sync, G: 'static + Deref<Target = NetworkGraph<L>> + Send + Sync,
L: 'static + Deref + Send + Sync, L: 'static + Deref + Send + Sync,
P: 'static + Deref + Send + Sync, P: 'static + Deref + Send + Sync,
@ -353,7 +355,7 @@ pub async fn process_events_async<
EventHandler: Fn(Event) -> EventHandlerFuture, EventHandler: Fn(Event) -> EventHandlerFuture,
PS: 'static + Deref + Send, PS: 'static + Deref + Send,
M: 'static + Deref<Target = ChainMonitor<<K::Target as SignerProvider>::Signer, CF, T, F, L, P>> + Send + Sync, M: 'static + Deref<Target = ChainMonitor<<K::Target as SignerProvider>::Signer, CF, T, F, L, P>> + Send + Sync,
CM: 'static + Deref<Target = ChannelManager<CW, T, K, F, L>> + Send + Sync, CM: 'static + Deref<Target = ChannelManager<CW, T, K, F, R, L>> + Send + Sync,
PGS: 'static + Deref<Target = P2PGossipSync<G, CA, L>> + Send + Sync, PGS: 'static + Deref<Target = P2PGossipSync<G, CA, L>> + Send + Sync,
RGS: 'static + Deref<Target = RapidGossipSync<G, L>> + Send, RGS: 'static + Deref<Target = RapidGossipSync<G, L>> + Send,
UMH: 'static + Deref + Send + Sync, UMH: 'static + Deref + Send + Sync,
@ -374,13 +376,14 @@ where
T::Target: 'static + BroadcasterInterface, T::Target: 'static + BroadcasterInterface,
K::Target: 'static + KeysInterface, K::Target: 'static + KeysInterface,
F::Target: 'static + FeeEstimator, F::Target: 'static + FeeEstimator,
R::Target: 'static + Router,
L::Target: 'static + Logger, L::Target: 'static + Logger,
P::Target: 'static + Persist<<K::Target as SignerProvider>::Signer>, P::Target: 'static + Persist<<K::Target as SignerProvider>::Signer>,
CMH::Target: 'static + ChannelMessageHandler, CMH::Target: 'static + ChannelMessageHandler,
OMH::Target: 'static + OnionMessageHandler, OMH::Target: 'static + OnionMessageHandler,
RMH::Target: 'static + RoutingMessageHandler, RMH::Target: 'static + RoutingMessageHandler,
UMH::Target: 'static + CustomMessageHandler, UMH::Target: 'static + CustomMessageHandler,
PS::Target: 'static + Persister<'a, CW, T, K, F, L, SC>, PS::Target: 'static + Persister<'a, CW, T, K, F, R, L, SC>,
{ {
let mut should_break = true; let mut should_break = true;
let async_event_handler = |event| { let async_event_handler = |event| {
@ -460,6 +463,7 @@ impl BackgroundProcessor {
T: 'static + Deref + Send + Sync, T: 'static + Deref + Send + Sync,
K: 'static + Deref + Send + Sync, K: 'static + Deref + Send + Sync,
F: 'static + Deref + Send + Sync, F: 'static + Deref + Send + Sync,
R: 'static + Deref + Send + Sync,
G: 'static + Deref<Target = NetworkGraph<L>> + Send + Sync, G: 'static + Deref<Target = NetworkGraph<L>> + Send + Sync,
L: 'static + Deref + Send + Sync, L: 'static + Deref + Send + Sync,
P: 'static + Deref + Send + Sync, P: 'static + Deref + Send + Sync,
@ -470,7 +474,7 @@ impl BackgroundProcessor {
EH: 'static + EventHandler + Send, EH: 'static + EventHandler + Send,
PS: 'static + Deref + Send, PS: 'static + Deref + Send,
M: 'static + Deref<Target = ChainMonitor<<K::Target as SignerProvider>::Signer, CF, T, F, L, P>> + Send + Sync, M: 'static + Deref<Target = ChainMonitor<<K::Target as SignerProvider>::Signer, CF, T, F, L, P>> + Send + Sync,
CM: 'static + Deref<Target = ChannelManager<CW, T, K, F, L>> + Send + Sync, CM: 'static + Deref<Target = ChannelManager<CW, T, K, F, R, L>> + Send + Sync,
PGS: 'static + Deref<Target = P2PGossipSync<G, CA, L>> + Send + Sync, PGS: 'static + Deref<Target = P2PGossipSync<G, CA, L>> + Send + Sync,
RGS: 'static + Deref<Target = RapidGossipSync<G, L>> + Send, RGS: 'static + Deref<Target = RapidGossipSync<G, L>> + Send,
UMH: 'static + Deref + Send + Sync, UMH: 'static + Deref + Send + Sync,
@ -488,13 +492,14 @@ impl BackgroundProcessor {
T::Target: 'static + BroadcasterInterface, T::Target: 'static + BroadcasterInterface,
K::Target: 'static + KeysInterface, K::Target: 'static + KeysInterface,
F::Target: 'static + FeeEstimator, F::Target: 'static + FeeEstimator,
R::Target: 'static + Router,
L::Target: 'static + Logger, L::Target: 'static + Logger,
P::Target: 'static + Persist<<K::Target as SignerProvider>::Signer>, P::Target: 'static + Persist<<K::Target as SignerProvider>::Signer>,
CMH::Target: 'static + ChannelMessageHandler, CMH::Target: 'static + ChannelMessageHandler,
OMH::Target: 'static + OnionMessageHandler, OMH::Target: 'static + OnionMessageHandler,
RMH::Target: 'static + RoutingMessageHandler, RMH::Target: 'static + RoutingMessageHandler,
UMH::Target: 'static + CustomMessageHandler, UMH::Target: 'static + CustomMessageHandler,
PS::Target: 'static + Persister<'a, CW, T, K, F, L, SC>, PS::Target: 'static + Persister<'a, CW, T, K, F, R, L, SC>,
{ {
let stop_thread = Arc::new(AtomicBool::new(false)); let stop_thread = Arc::new(AtomicBool::new(false));
let stop_thread_clone = stop_thread.clone(); let stop_thread_clone = stop_thread.clone();
@ -615,7 +620,7 @@ mod tests {
type RGS = Arc<RapidGossipSync<Arc<NetworkGraph<Arc<test_utils::TestLogger>>>, Arc<test_utils::TestLogger>>>; type RGS = Arc<RapidGossipSync<Arc<NetworkGraph<Arc<test_utils::TestLogger>>>, Arc<test_utils::TestLogger>>>;
struct Node { struct Node {
node: Arc<SimpleArcChannelManager<ChainMonitor, test_utils::TestBroadcaster, test_utils::TestFeeEstimator, test_utils::TestLogger>>, node: Arc<SimpleArcChannelManager<ChainMonitor, test_utils::TestBroadcaster, test_utils::TestFeeEstimator, test_utils::TestRouter, test_utils::TestLogger>>,
p2p_gossip_sync: PGS, p2p_gossip_sync: PGS,
rapid_gossip_sync: RGS, rapid_gossip_sync: RGS,
peer_manager: Arc<PeerManager<TestDescriptor, Arc<test_utils::TestChannelMessageHandler>, Arc<test_utils::TestRoutingMessageHandler>, IgnoringMessageHandler, Arc<test_utils::TestLogger>, IgnoringMessageHandler>>, peer_manager: Arc<PeerManager<TestDescriptor, Arc<test_utils::TestChannelMessageHandler>, Arc<test_utils::TestRoutingMessageHandler>, IgnoringMessageHandler, Arc<test_utils::TestLogger>, IgnoringMessageHandler>>,
@ -722,6 +727,7 @@ mod tests {
for i in 0..num_nodes { for i in 0..num_nodes {
let tx_broadcaster = Arc::new(test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new()), blocks: Arc::new(Mutex::new(Vec::new()))}); let tx_broadcaster = Arc::new(test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new()), blocks: Arc::new(Mutex::new(Vec::new()))});
let fee_estimator = Arc::new(test_utils::TestFeeEstimator { sat_per_kw: Mutex::new(253) }); let fee_estimator = Arc::new(test_utils::TestFeeEstimator { sat_per_kw: Mutex::new(253) });
let router = Arc::new(test_utils::TestRouter { });
let chain_source = Arc::new(test_utils::TestChainSource::new(Network::Testnet)); let chain_source = Arc::new(test_utils::TestChainSource::new(Network::Testnet));
let logger = Arc::new(test_utils::TestLogger::with_id(format!("node {}", i))); let logger = Arc::new(test_utils::TestLogger::with_id(format!("node {}", i)));
let persister = Arc::new(FilesystemPersister::new(format!("{}_persister_{}", persist_dir, i))); let persister = Arc::new(FilesystemPersister::new(format!("{}_persister_{}", persist_dir, i)));
@ -733,7 +739,7 @@ mod tests {
let chain_monitor = Arc::new(chainmonitor::ChainMonitor::new(Some(chain_source.clone()), tx_broadcaster.clone(), logger.clone(), fee_estimator.clone(), persister.clone())); let chain_monitor = Arc::new(chainmonitor::ChainMonitor::new(Some(chain_source.clone()), tx_broadcaster.clone(), logger.clone(), fee_estimator.clone(), persister.clone()));
let best_block = BestBlock::from_genesis(network); let best_block = BestBlock::from_genesis(network);
let params = ChainParameters { network, best_block }; let params = ChainParameters { network, best_block };
let manager = Arc::new(ChannelManager::new(fee_estimator.clone(), chain_monitor.clone(), tx_broadcaster.clone(), logger.clone(), keys_manager.clone(), UserConfig::default(), params)); let manager = Arc::new(ChannelManager::new(fee_estimator.clone(), chain_monitor.clone(), tx_broadcaster.clone(), router.clone(), logger.clone(), keys_manager.clone(), UserConfig::default(), params));
let network_graph = Arc::new(NetworkGraph::new(genesis_block.header.block_hash(), logger.clone())); let network_graph = Arc::new(NetworkGraph::new(genesis_block.header.block_hash(), logger.clone()));
let p2p_gossip_sync = Arc::new(P2PGossipSync::new(network_graph.clone(), Some(chain_source.clone()), logger.clone())); let p2p_gossip_sync = Arc::new(P2PGossipSync::new(network_graph.clone(), Some(chain_source.clone()), logger.clone()));
let rapid_gossip_sync = Arc::new(RapidGossipSync::new(network_graph.clone())); let rapid_gossip_sync = Arc::new(RapidGossipSync::new(network_graph.clone()));

9
lightning-block-sync/src/init.rs
View file

@ -49,8 +49,8 @@ BlockSourceResult<ValidatedBlockHeader> where B::Target: BlockSource {
/// use lightning::chain::chaininterface::FeeEstimator; /// use lightning::chain::chaininterface::FeeEstimator;
/// use lightning::chain::keysinterface; /// use lightning::chain::keysinterface;
/// use lightning::chain::keysinterface::KeysInterface; /// use lightning::chain::keysinterface::KeysInterface;
/// use lightning::ln::channelmanager::ChannelManager; /// use lightning::ln::channelmanager::{ChannelManager, ChannelManagerReadArgs};
/// use lightning::ln::channelmanager::ChannelManagerReadArgs; /// use lightning::routing::router::Router;
/// use lightning::util::config::UserConfig; /// use lightning::util::config::UserConfig;
/// use lightning::util::logger::Logger; /// use lightning::util::logger::Logger;
/// use lightning::util::ser::ReadableArgs; /// use lightning::util::ser::ReadableArgs;
@ -64,6 +64,7 @@ BlockSourceResult<ValidatedBlockHeader> where B::Target: BlockSource {
/// K: KeysInterface, /// K: KeysInterface,
/// T: BroadcasterInterface, /// T: BroadcasterInterface,
/// F: FeeEstimator, /// F: FeeEstimator,
/// R: Router,
/// L: Logger, /// L: Logger,
/// C: chain::Filter, /// C: chain::Filter,
/// P: chainmonitor::Persist<K::Signer>, /// P: chainmonitor::Persist<K::Signer>,
@ -74,6 +75,7 @@ BlockSourceResult<ValidatedBlockHeader> where B::Target: BlockSource {
/// keys_manager: &K, /// keys_manager: &K,
/// tx_broadcaster: &T, /// tx_broadcaster: &T,
/// fee_estimator: &F, /// fee_estimator: &F,
/// router: &R,
/// logger: &L, /// logger: &L,
/// persister: &P, /// persister: &P,
/// ) { /// ) {
@ -90,11 +92,12 @@ BlockSourceResult<ValidatedBlockHeader> where B::Target: BlockSource {
/// fee_estimator, /// fee_estimator,
/// chain_monitor, /// chain_monitor,
/// tx_broadcaster, /// tx_broadcaster,
/// router,
/// logger, /// logger,
/// config, /// config,
/// vec![&mut monitor], /// vec![&mut monitor],
/// ); /// );
/// <(BlockHash, ChannelManager<&ChainMonitor<K::Signer, &C, &T, &F, &L, &P>, &T, &K, &F, &L>)>::read( /// <(BlockHash, ChannelManager<&ChainMonitor<K::Signer, &C, &T, &F, &L, &P>, &T, &K, &F, &R, &L>)>::read(
/// &mut Cursor::new(&serialized_manager), read_args).unwrap() /// &mut Cursor::new(&serialized_manager), read_args).unwrap()
/// }; /// };
/// ///

40
lightning-invoice/src/utils.rs
View file

@ -15,7 +15,7 @@ use lightning::ln::channelmanager::{ChannelDetails, ChannelManager, PaymentId, P
use lightning::ln::channelmanager::{PhantomRouteHints, MIN_CLTV_EXPIRY_DELTA}; use lightning::ln::channelmanager::{PhantomRouteHints, MIN_CLTV_EXPIRY_DELTA};
use lightning::ln::inbound_payment::{create, create_from_hash, ExpandedKey}; use lightning::ln::inbound_payment::{create, create_from_hash, ExpandedKey};
use lightning::routing::gossip::RoutingFees; use lightning::routing::gossip::RoutingFees;
use lightning::routing::router::{InFlightHtlcs, Route, RouteHint, RouteHintHop}; use lightning::routing::router::{InFlightHtlcs, Route, RouteHint, RouteHintHop, Router};
use lightning::util::logger::Logger; use lightning::util::logger::Logger;
use secp256k1::PublicKey; use secp256k1::PublicKey;
use core::ops::Deref; use core::ops::Deref;
@ -232,8 +232,8 @@ where
/// ///
/// `invoice_expiry_delta_secs` describes the number of seconds that the invoice is valid for /// `invoice_expiry_delta_secs` describes the number of seconds that the invoice is valid for
/// in excess of the current time. /// in excess of the current time.
pub fn create_invoice_from_channelmanager<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>( pub fn create_invoice_from_channelmanager<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref>(
channelmanager: &ChannelManager<M, T, K, F, L>, keys_manager: K, logger: L, channelmanager: &ChannelManager<M, T, K, F, R, L>, keys_manager: K, logger: L,
network: Currency, amt_msat: Option<u64>, description: String, invoice_expiry_delta_secs: u32 network: Currency, amt_msat: Option<u64>, description: String, invoice_expiry_delta_secs: u32
) -> Result<Invoice, SignOrCreationError<()>> ) -> Result<Invoice, SignOrCreationError<()>>
where where
@ -241,6 +241,7 @@ where
T::Target: BroadcasterInterface, T::Target: BroadcasterInterface,
K::Target: KeysInterface, K::Target: KeysInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger, L::Target: Logger,
{ {
use std::time::SystemTime; use std::time::SystemTime;
@ -262,8 +263,8 @@ where
/// ///
/// `invoice_expiry_delta_secs` describes the number of seconds that the invoice is valid for /// `invoice_expiry_delta_secs` describes the number of seconds that the invoice is valid for
/// in excess of the current time. /// in excess of the current time.
pub fn create_invoice_from_channelmanager_with_description_hash<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>( pub fn create_invoice_from_channelmanager_with_description_hash<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref>(
channelmanager: &ChannelManager<M, T, K, F, L>, keys_manager: K, logger: L, channelmanager: &ChannelManager<M, T, K, F, R, L>, keys_manager: K, logger: L,
network: Currency, amt_msat: Option<u64>, description_hash: Sha256, network: Currency, amt_msat: Option<u64>, description_hash: Sha256,
invoice_expiry_delta_secs: u32 invoice_expiry_delta_secs: u32
) -> Result<Invoice, SignOrCreationError<()>> ) -> Result<Invoice, SignOrCreationError<()>>
@ -272,6 +273,7 @@ where
T::Target: BroadcasterInterface, T::Target: BroadcasterInterface,
K::Target: KeysInterface, K::Target: KeysInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger, L::Target: Logger,
{ {
use std::time::SystemTime; use std::time::SystemTime;
@ -289,8 +291,8 @@ where
/// See [`create_invoice_from_channelmanager_with_description_hash`] /// See [`create_invoice_from_channelmanager_with_description_hash`]
/// This version can be used in a `no_std` environment, where [`std::time::SystemTime`] is not /// This version can be used in a `no_std` environment, where [`std::time::SystemTime`] is not
/// available and the current time is supplied by the caller. /// available and the current time is supplied by the caller.
pub fn create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>( pub fn create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref>(
channelmanager: &ChannelManager<M, T, K, F, L>, keys_manager: K, logger: L, channelmanager: &ChannelManager<M, T, K, F, R, L>, keys_manager: K, logger: L,
network: Currency, amt_msat: Option<u64>, description_hash: Sha256, network: Currency, amt_msat: Option<u64>, description_hash: Sha256,
duration_since_epoch: Duration, invoice_expiry_delta_secs: u32 duration_since_epoch: Duration, invoice_expiry_delta_secs: u32
) -> Result<Invoice, SignOrCreationError<()>> ) -> Result<Invoice, SignOrCreationError<()>>
@ -299,6 +301,7 @@ pub fn create_invoice_from_channelmanager_with_description_hash_and_duration_sin
T::Target: BroadcasterInterface, T::Target: BroadcasterInterface,
K::Target: KeysInterface, K::Target: KeysInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger, L::Target: Logger,
{ {
_create_invoice_from_channelmanager_and_duration_since_epoch( _create_invoice_from_channelmanager_and_duration_since_epoch(
@ -311,8 +314,8 @@ pub fn create_invoice_from_channelmanager_with_description_hash_and_duration_sin
/// See [`create_invoice_from_channelmanager`] /// See [`create_invoice_from_channelmanager`]
/// This version can be used in a `no_std` environment, where [`std::time::SystemTime`] is not /// This version can be used in a `no_std` environment, where [`std::time::SystemTime`] is not
/// available and the current time is supplied by the caller. /// available and the current time is supplied by the caller.
pub fn create_invoice_from_channelmanager_and_duration_since_epoch<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>( pub fn create_invoice_from_channelmanager_and_duration_since_epoch<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref>(
channelmanager: &ChannelManager<M, T, K, F, L>, keys_manager: K, logger: L, channelmanager: &ChannelManager<M, T, K, F, R, L>, keys_manager: K, logger: L,
network: Currency, amt_msat: Option<u64>, description: String, duration_since_epoch: Duration, network: Currency, amt_msat: Option<u64>, description: String, duration_since_epoch: Duration,
invoice_expiry_delta_secs: u32 invoice_expiry_delta_secs: u32
) -> Result<Invoice, SignOrCreationError<()>> ) -> Result<Invoice, SignOrCreationError<()>>
@ -321,6 +324,7 @@ pub fn create_invoice_from_channelmanager_and_duration_since_epoch<M: Deref, T:
T::Target: BroadcasterInterface, T::Target: BroadcasterInterface,
K::Target: KeysInterface, K::Target: KeysInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger, L::Target: Logger,
{ {
_create_invoice_from_channelmanager_and_duration_since_epoch( _create_invoice_from_channelmanager_and_duration_since_epoch(
@ -332,8 +336,8 @@ pub fn create_invoice_from_channelmanager_and_duration_since_epoch<M: Deref, T:
) )
} }
fn _create_invoice_from_channelmanager_and_duration_since_epoch<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>( fn _create_invoice_from_channelmanager_and_duration_since_epoch<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref>(
channelmanager: &ChannelManager<M, T, K, F, L>, keys_manager: K, logger: L, channelmanager: &ChannelManager<M, T, K, F, R, L>, keys_manager: K, logger: L,
network: Currency, amt_msat: Option<u64>, description: InvoiceDescription, network: Currency, amt_msat: Option<u64>, description: InvoiceDescription,
duration_since_epoch: Duration, invoice_expiry_delta_secs: u32 duration_since_epoch: Duration, invoice_expiry_delta_secs: u32
) -> Result<Invoice, SignOrCreationError<()>> ) -> Result<Invoice, SignOrCreationError<()>>
@ -342,6 +346,7 @@ fn _create_invoice_from_channelmanager_and_duration_since_epoch<M: Deref, T: Der
T::Target: BroadcasterInterface, T::Target: BroadcasterInterface,
K::Target: KeysInterface, K::Target: KeysInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger, L::Target: Logger,
{ {
// `create_inbound_payment` only returns an error if the amount is greater than the total bitcoin // `create_inbound_payment` only returns an error if the amount is greater than the total bitcoin
@ -357,8 +362,8 @@ fn _create_invoice_from_channelmanager_and_duration_since_epoch<M: Deref, T: Der
/// This version allows for providing a custom [`PaymentHash`] for the invoice. /// This version allows for providing a custom [`PaymentHash`] for the invoice.
/// This may be useful if you're building an on-chain swap or involving another protocol where /// This may be useful if you're building an on-chain swap or involving another protocol where
/// the payment hash is also involved outside the scope of lightning. /// the payment hash is also involved outside the scope of lightning.
pub fn create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>( pub fn create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref>(
channelmanager: &ChannelManager<M, T, K, F, L>, keys_manager: K, logger: L, channelmanager: &ChannelManager<M, T, K, F, R, L>, keys_manager: K, logger: L,
network: Currency, amt_msat: Option<u64>, description: String, duration_since_epoch: Duration, network: Currency, amt_msat: Option<u64>, description: String, duration_since_epoch: Duration,
invoice_expiry_delta_secs: u32, payment_hash: PaymentHash invoice_expiry_delta_secs: u32, payment_hash: PaymentHash
) -> Result<Invoice, SignOrCreationError<()>> ) -> Result<Invoice, SignOrCreationError<()>>
@ -367,6 +372,7 @@ pub fn create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_
T::Target: BroadcasterInterface, T::Target: BroadcasterInterface,
K::Target: KeysInterface, K::Target: KeysInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger, L::Target: Logger,
{ {
let payment_secret = channelmanager let payment_secret = channelmanager
@ -381,8 +387,8 @@ pub fn create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_
) )
} }
fn _create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>( fn _create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref>(
channelmanager: &ChannelManager<M, T, K, F, L>, keys_manager: K, logger: L, channelmanager: &ChannelManager<M, T, K, F, R, L>, keys_manager: K, logger: L,
network: Currency, amt_msat: Option<u64>, description: InvoiceDescription, duration_since_epoch: Duration, network: Currency, amt_msat: Option<u64>, description: InvoiceDescription, duration_since_epoch: Duration,
invoice_expiry_delta_secs: u32, payment_hash: PaymentHash, payment_secret: PaymentSecret invoice_expiry_delta_secs: u32, payment_hash: PaymentHash, payment_secret: PaymentSecret
) -> Result<Invoice, SignOrCreationError<()>> ) -> Result<Invoice, SignOrCreationError<()>>
@ -391,6 +397,7 @@ fn _create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_has
T::Target: BroadcasterInterface, T::Target: BroadcasterInterface,
K::Target: KeysInterface, K::Target: KeysInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger, L::Target: Logger,
{ {
let our_node_pubkey = channelmanager.get_our_node_id(); let our_node_pubkey = channelmanager.get_our_node_id();
@ -565,12 +572,13 @@ fn filter_channels<L: Deref>(
.collect::<Vec<RouteHint>>() .collect::<Vec<RouteHint>>()
} }
impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> Payer for ChannelManager<M, T, K, F, L> impl<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref> Payer for ChannelManager<M, T, K, F, R, L>
where where
M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>, M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>,
T::Target: BroadcasterInterface, T::Target: BroadcasterInterface,
K::Target: KeysInterface, K::Target: KeysInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger, L::Target: Logger,
{ {
fn node_id(&self) -> PublicKey { fn node_id(&self) -> PublicKey {

5
lightning-net-tokio/src/lib.rs
View file

@ -31,13 +31,14 @@
//! // Define concrete types for our high-level objects: //! // Define concrete types for our high-level objects:
//! type TxBroadcaster = dyn lightning::chain::chaininterface::BroadcasterInterface + Send + Sync; //! type TxBroadcaster = dyn lightning::chain::chaininterface::BroadcasterInterface + Send + Sync;
//! type FeeEstimator = dyn lightning::chain::chaininterface::FeeEstimator + Send + Sync; //! type FeeEstimator = dyn lightning::chain::chaininterface::FeeEstimator + Send + Sync;
//! type Router = dyn lightning::routing::router::Router + Send + Sync;
//! type Logger = dyn lightning::util::logger::Logger + Send + Sync; //! type Logger = dyn lightning::util::logger::Logger + Send + Sync;
//! type ChainAccess = dyn lightning::chain::Access + Send + Sync; //! type ChainAccess = dyn lightning::chain::Access + Send + Sync;
//! type ChainFilter = dyn lightning::chain::Filter + Send + Sync; //! type ChainFilter = dyn lightning::chain::Filter + Send + Sync;
//! type DataPersister = dyn lightning::chain::chainmonitor::Persist<lightning::chain::keysinterface::InMemorySigner> + Send + Sync; //! type DataPersister = dyn lightning::chain::chainmonitor::Persist<lightning::chain::keysinterface::InMemorySigner> + Send + Sync;
//! type ChainMonitor = lightning::chain::chainmonitor::ChainMonitor<lightning::chain::keysinterface::InMemorySigner, Arc<ChainFilter>, Arc<TxBroadcaster>, Arc<FeeEstimator>, Arc<Logger>, Arc<DataPersister>>; //! type ChainMonitor = lightning::chain::chainmonitor::ChainMonitor<lightning::chain::keysinterface::InMemorySigner, Arc<ChainFilter>, Arc<TxBroadcaster>, Arc<FeeEstimator>, Arc<Logger>, Arc<DataPersister>>;
//! type ChannelManager = Arc<lightning::ln::channelmanager::SimpleArcChannelManager<ChainMonitor, TxBroadcaster, FeeEstimator, Logger>>; //! type ChannelManager = Arc<lightning::ln::channelmanager::SimpleArcChannelManager<ChainMonitor, TxBroadcaster, FeeEstimator, Router, Logger>>;
//! type PeerManager = Arc<lightning::ln::peer_handler::SimpleArcPeerManager<lightning_net_tokio::SocketDescriptor, ChainMonitor, TxBroadcaster, FeeEstimator, ChainAccess, Logger>>; //! type PeerManager = Arc<lightning::ln::peer_handler::SimpleArcPeerManager<lightning_net_tokio::SocketDescriptor, ChainMonitor, TxBroadcaster, FeeEstimator, ChainAccess, Router, Logger>>;
//! //!
//! // Connect to node with pubkey their_node_id at addr: //! // Connect to node with pubkey their_node_id at addr:
//! async fn connect_to_node(peer_manager: PeerManager, chain_monitor: Arc<ChainMonitor>, channel_manager: ChannelManager, their_node_id: PublicKey, addr: SocketAddr) { //! async fn connect_to_node(peer_manager: PeerManager, chain_monitor: Arc<ChainMonitor>, channel_manager: ChannelManager, their_node_id: PublicKey, addr: SocketAddr) {

6
lightning/src/ln/chanmon_update_fail_tests.rs
View file

@ -2231,7 +2231,7 @@ fn do_channel_holding_cell_serialize(disconnect: bool, reload_a: bool) {
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
let persister: test_utils::TestPersister; let persister: test_utils::TestPersister;
let new_chain_monitor: test_utils::TestChainMonitor; let new_chain_monitor: test_utils::TestChainMonitor;
let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
let chan_id = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 15_000_000, 7_000_000_000, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2; let chan_id = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 15_000_000, 7_000_000_000, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2;
@ -2724,7 +2724,7 @@ fn do_test_outbound_reload_without_init_mon(use_0conf: bool) {
let persister: test_utils::TestPersister; let persister: test_utils::TestPersister;
let new_chain_monitor: test_utils::TestChainMonitor; let new_chain_monitor: test_utils::TestChainMonitor;
let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let mut chan_config = test_default_channel_config(); let mut chan_config = test_default_channel_config();
chan_config.manually_accept_inbound_channels = true; chan_config.manually_accept_inbound_channels = true;
@ -2813,7 +2813,7 @@ fn do_test_inbound_reload_without_init_mon(use_0conf: bool, lock_commitment: boo
let persister: test_utils::TestPersister; let persister: test_utils::TestPersister;
let new_chain_monitor: test_utils::TestChainMonitor; let new_chain_monitor: test_utils::TestChainMonitor;
let nodes_1_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let nodes_1_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let mut chan_config = test_default_channel_config(); let mut chan_config = test_default_channel_config();
chan_config.manually_accept_inbound_channels = true; chan_config.manually_accept_inbound_channels = true;

183
lightning/src/ln/channelmanager.rs
View file

@ -46,7 +46,7 @@ use crate::ln::channel::{Channel, ChannelError, ChannelUpdateStatus, UpdateFulfi
use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures}; use crate::ln::features::{ChannelFeatures, ChannelTypeFeatures, InitFeatures, NodeFeatures};
#[cfg(any(feature = "_test_utils", test))] #[cfg(any(feature = "_test_utils", test))]
use crate::ln::features::InvoiceFeatures; use crate::ln::features::InvoiceFeatures;
use crate::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RoutePath}; use crate::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RoutePath, Router};
use crate::ln::msgs; use crate::ln::msgs;
use crate::ln::onion_utils; use crate::ln::onion_utils;
use crate::ln::onion_utils::HTLCFailReason; use crate::ln::onion_utils::HTLCFailReason;
@ -495,7 +495,7 @@ struct PendingInboundPayment {
/// concrete type of the KeysManager. /// concrete type of the KeysManager.
/// ///
/// (C-not exported) as Arcs don't make sense in bindings /// (C-not exported) as Arcs don't make sense in bindings
pub type SimpleArcChannelManager<M, T, F, L> = ChannelManager<Arc<M>, Arc<T>, Arc<KeysManager>, Arc<F>, Arc<L>>; pub type SimpleArcChannelManager<M, T, F, R, L> = ChannelManager<Arc<M>, Arc<T>, Arc<KeysManager>, Arc<F>, Arc<R>, Arc<L>>;
/// SimpleRefChannelManager is a type alias for a ChannelManager reference, and is the reference /// SimpleRefChannelManager is a type alias for a ChannelManager reference, and is the reference
/// counterpart to the SimpleArcChannelManager type alias. Use this type by default when you don't /// counterpart to the SimpleArcChannelManager type alias. Use this type by default when you don't
@ -507,7 +507,7 @@ pub type SimpleArcChannelManager<M, T, F, L> = ChannelManager<Arc<M>, Arc<T>, Ar
/// concrete type of the KeysManager. /// concrete type of the KeysManager.
/// ///
/// (C-not exported) as Arcs don't make sense in bindings /// (C-not exported) as Arcs don't make sense in bindings
pub type SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, M, T, F, L> = ChannelManager<&'a M, &'b T, &'c KeysManager, &'d F, &'e L>; pub type SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, 'f, M, T, F, R, L> = ChannelManager<&'a M, &'b T, &'c KeysManager, &'d F, &'e R, &'f L>;
/// Manager which keeps track of a number of channels and sends messages to the appropriate /// Manager which keeps track of a number of channels and sends messages to the appropriate
/// channel, also tracking HTLC preimages and forwarding onion packets appropriately. /// channel, also tracking HTLC preimages and forwarding onion packets appropriately.
@ -583,18 +583,22 @@ pub type SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, M, T, F, L> = ChannelManage
// | | // | |
// | |__`pending_background_events` // | |__`pending_background_events`
// //
pub struct ChannelManager<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> pub struct ChannelManager<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref>
where M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>, where
T::Target: BroadcasterInterface, M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>,
K::Target: KeysInterface, T::Target: BroadcasterInterface,
F::Target: FeeEstimator, K::Target: KeysInterface,
L::Target: Logger, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger,
{ {
default_configuration: UserConfig, default_configuration: UserConfig,
genesis_hash: BlockHash, genesis_hash: BlockHash,
fee_estimator: LowerBoundedFeeEstimator<F>, fee_estimator: LowerBoundedFeeEstimator<F>,
chain_monitor: M, chain_monitor: M,
tx_broadcaster: T, tx_broadcaster: T,
#[allow(unused)]
router: R,
/// See `ChannelManager` struct-level documentation for lock order requirements. /// See `ChannelManager` struct-level documentation for lock order requirements.
#[cfg(test)] #[cfg(test)]
@ -1358,12 +1362,14 @@ macro_rules! emit_channel_ready_event {
} }
} }
impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F, L> impl<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref> ChannelManager<M, T, K, F, R, L>
where M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>, where
T::Target: BroadcasterInterface, M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>,
K::Target: KeysInterface, T::Target: BroadcasterInterface,
F::Target: FeeEstimator, K::Target: KeysInterface,
L::Target: Logger, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger,
{ {
/// Constructs a new ChannelManager to hold several channels and route between them. /// Constructs a new ChannelManager to hold several channels and route between them.
/// ///
@ -1375,7 +1381,7 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F
/// Users need to notify the new ChannelManager when a new block is connected or /// Users need to notify the new ChannelManager when a new block is connected or
/// disconnected using its `block_connected` and `block_disconnected` methods, starting /// disconnected using its `block_connected` and `block_disconnected` methods, starting
/// from after `params.latest_hash`. /// from after `params.latest_hash`.
pub fn new(fee_est: F, chain_monitor: M, tx_broadcaster: T, logger: L, keys_manager: K, config: UserConfig, params: ChainParameters) -> Self { pub fn new(fee_est: F, chain_monitor: M, tx_broadcaster: T, router: R, logger: L, keys_manager: K, config: UserConfig, params: ChainParameters) -> Self {
let mut secp_ctx = Secp256k1::new(); let mut secp_ctx = Secp256k1::new();
secp_ctx.seeded_randomize(&keys_manager.get_secure_random_bytes()); secp_ctx.seeded_randomize(&keys_manager.get_secure_random_bytes());
let inbound_pmt_key_material = keys_manager.get_inbound_payment_key_material(); let inbound_pmt_key_material = keys_manager.get_inbound_payment_key_material();
@ -1386,6 +1392,7 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F
fee_estimator: LowerBoundedFeeEstimator::new(fee_est), fee_estimator: LowerBoundedFeeEstimator::new(fee_est),
chain_monitor, chain_monitor,
tx_broadcaster, tx_broadcaster,
router,
best_block: RwLock::new(params.best_block), best_block: RwLock::new(params.best_block),
@ -5264,12 +5271,14 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F
} }
} }
impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> MessageSendEventsProvider for ChannelManager<M, T, K, F, L> impl<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref> MessageSendEventsProvider for ChannelManager<M, T, K, F, R, L>
where M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>, where
T::Target: BroadcasterInterface, M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>,
K::Target: KeysInterface, T::Target: BroadcasterInterface,
F::Target: FeeEstimator, K::Target: KeysInterface,
L::Target: Logger, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger,
{ {
fn get_and_clear_pending_msg_events(&self) -> Vec<MessageSendEvent> { fn get_and_clear_pending_msg_events(&self) -> Vec<MessageSendEvent> {
let events = RefCell::new(Vec::new()); let events = RefCell::new(Vec::new());
@ -5303,12 +5312,13 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> MessageSendEventsProvider
} }
} }
impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> EventsProvider for ChannelManager<M, T, K, F, L> impl<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref> EventsProvider for ChannelManager<M, T, K, F, R, L>
where where
M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>, M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>,
T::Target: BroadcasterInterface, T::Target: BroadcasterInterface,
K::Target: KeysInterface, K::Target: KeysInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger, L::Target: Logger,
{ {
/// Processes events that must be periodically handled. /// Processes events that must be periodically handled.
@ -5339,12 +5349,13 @@ where
} }
} }
impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> chain::Listen for ChannelManager<M, T, K, F, L> impl<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref> chain::Listen for ChannelManager<M, T, K, F, R, L>
where where
M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>, M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>,
T::Target: BroadcasterInterface, T::Target: BroadcasterInterface,
K::Target: KeysInterface, K::Target: KeysInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger, L::Target: Logger,
{ {
fn filtered_block_connected(&self, header: &BlockHeader, txdata: &TransactionData, height: u32) { fn filtered_block_connected(&self, header: &BlockHeader, txdata: &TransactionData, height: u32) {
@ -5376,12 +5387,13 @@ where
} }
} }
impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> chain::Confirm for ChannelManager<M, T, K, F, L> impl<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref> chain::Confirm for ChannelManager<M, T, K, F, R, L>
where where
M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>, M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>,
T::Target: BroadcasterInterface, T::Target: BroadcasterInterface,
K::Target: KeysInterface, K::Target: KeysInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger, L::Target: Logger,
{ {
fn transactions_confirmed(&self, header: &BlockHeader, txdata: &TransactionData, height: u32) { fn transactions_confirmed(&self, header: &BlockHeader, txdata: &TransactionData, height: u32) {
@ -5463,12 +5475,13 @@ where
} }
} }
impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F, L> impl<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref> ChannelManager<M, T, K, F, R, L>
where where
M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>, M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>,
T::Target: BroadcasterInterface, T::Target: BroadcasterInterface,
K::Target: KeysInterface, K::Target: KeysInterface,
F::Target: FeeEstimator, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger, L::Target: Logger,
{ {
/// Calls a function which handles an on-chain event (blocks dis/connected, transactions /// Calls a function which handles an on-chain event (blocks dis/connected, transactions
@ -5663,13 +5676,15 @@ where
} }
} }
impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref > impl<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref>
ChannelMessageHandler for ChannelManager<M, T, K, F, L> ChannelMessageHandler for ChannelManager<M, T, K, F, R, L>
where M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>, where
T::Target: BroadcasterInterface, M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>,
K::Target: KeysInterface, T::Target: BroadcasterInterface,
F::Target: FeeEstimator, K::Target: KeysInterface,
L::Target: Logger, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger,
{ {
fn handle_open_channel(&self, counterparty_node_id: &PublicKey, their_features: InitFeatures, msg: &msgs::OpenChannel) { fn handle_open_channel(&self, counterparty_node_id: &PublicKey, their_features: InitFeatures, msg: &msgs::OpenChannel) {
let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(&self.total_consistency_lock, &self.persistence_notifier); let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(&self.total_consistency_lock, &self.persistence_notifier);
@ -6350,12 +6365,14 @@ impl_writeable_tlv_based!(PendingInboundPayment, {
(8, min_value_msat, required), (8, min_value_msat, required),
}); });
impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> Writeable for ChannelManager<M, T, K, F, L> impl<M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref> Writeable for ChannelManager<M, T, K, F, R, L>
where M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>, where
T::Target: BroadcasterInterface, M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>,
K::Target: KeysInterface, T::Target: BroadcasterInterface,
F::Target: FeeEstimator, K::Target: KeysInterface,
L::Target: Logger, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger,
{ {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> { fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
let _consistency_lock = self.total_consistency_lock.write().unwrap(); let _consistency_lock = self.total_consistency_lock.write().unwrap();
@ -6547,12 +6564,14 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> Writeable for ChannelMana
/// which you've already broadcasted the transaction. /// which you've already broadcasted the transaction.
/// ///
/// [`ChainMonitor`]: crate::chain::chainmonitor::ChainMonitor /// [`ChainMonitor`]: crate::chain::chainmonitor::ChainMonitor
pub struct ChannelManagerReadArgs<'a, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> pub struct ChannelManagerReadArgs<'a, M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref>
where M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>, where
T::Target: BroadcasterInterface, M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>,
K::Target: KeysInterface, T::Target: BroadcasterInterface,
F::Target: FeeEstimator, K::Target: KeysInterface,
L::Target: Logger, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger,
{ {
/// The keys provider which will give us relevant keys. Some keys will be loaded during /// The keys provider which will give us relevant keys. Some keys will be loaded during
/// deserialization and KeysInterface::read_chan_signer will be used to read per-Channel /// deserialization and KeysInterface::read_chan_signer will be used to read per-Channel
@ -6574,6 +6593,11 @@ pub struct ChannelManagerReadArgs<'a, M: Deref, T: Deref, K: Deref, F: Deref, L:
/// used to broadcast the latest local commitment transactions of channels which must be /// used to broadcast the latest local commitment transactions of channels which must be
/// force-closed during deserialization. /// force-closed during deserialization.
pub tx_broadcaster: T, pub tx_broadcaster: T,
/// The router which will be used in the ChannelManager in the future for finding routes
/// on-the-fly for trampoline payments. Absent in private nodes that don't support forwarding.
///
/// No calls to the router will be made during deserialization.
pub router: R,
/// The Logger for use in the ChannelManager and which may be used to log information during /// The Logger for use in the ChannelManager and which may be used to log information during
/// deserialization. /// deserialization.
pub logger: L, pub logger: L,
@ -6596,21 +6620,23 @@ pub struct ChannelManagerReadArgs<'a, M: Deref, T: Deref, K: Deref, F: Deref, L:
pub channel_monitors: HashMap<OutPoint, &'a mut ChannelMonitor<<K::Target as SignerProvider>::Signer>>, pub channel_monitors: HashMap<OutPoint, &'a mut ChannelMonitor<<K::Target as SignerProvider>::Signer>>,
} }
impl<'a, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> impl<'a, M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref>
ChannelManagerReadArgs<'a, M, T, K, F, L> ChannelManagerReadArgs<'a, M, T, K, F, R, L>
where M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>, where
T::Target: BroadcasterInterface, M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>,
K::Target: KeysInterface, T::Target: BroadcasterInterface,
F::Target: FeeEstimator, K::Target: KeysInterface,
L::Target: Logger, F::Target: FeeEstimator,
{ R::Target: Router,
L::Target: Logger,
{
/// Simple utility function to create a ChannelManagerReadArgs which creates the monitor /// Simple utility function to create a ChannelManagerReadArgs which creates the monitor
/// HashMap for you. This is primarily useful for C bindings where it is not practical to /// HashMap for you. This is primarily useful for C bindings where it is not practical to
/// populate a HashMap directly from C. /// populate a HashMap directly from C.
pub fn new(keys_manager: K, fee_estimator: F, chain_monitor: M, tx_broadcaster: T, logger: L, default_config: UserConfig, pub fn new(keys_manager: K, fee_estimator: F, chain_monitor: M, tx_broadcaster: T, router: R, logger: L, default_config: UserConfig,
mut channel_monitors: Vec<&'a mut ChannelMonitor<<K::Target as SignerProvider>::Signer>>) -> Self { mut channel_monitors: Vec<&'a mut ChannelMonitor<<K::Target as SignerProvider>::Signer>>) -> Self {
Self { Self {
keys_manager, fee_estimator, chain_monitor, tx_broadcaster, logger, default_config, keys_manager, fee_estimator, chain_monitor, tx_broadcaster, router, logger, default_config,
channel_monitors: channel_monitors.drain(..).map(|monitor| { (monitor.get_funding_txo().0, monitor) }).collect() channel_monitors: channel_monitors.drain(..).map(|monitor| { (monitor.get_funding_txo().0, monitor) }).collect()
} }
} }
@ -6618,29 +6644,33 @@ impl<'a, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
// Implement ReadableArgs for an Arc'd ChannelManager to make it a bit easier to work with the // Implement ReadableArgs for an Arc'd ChannelManager to make it a bit easier to work with the
// SipmleArcChannelManager type: // SipmleArcChannelManager type:
impl<'a, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> impl<'a, M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref>
ReadableArgs<ChannelManagerReadArgs<'a, M, T, K, F, L>> for (BlockHash, Arc<ChannelManager<M, T, K, F, L>>) ReadableArgs<ChannelManagerReadArgs<'a, M, T, K, F, R, L>> for (BlockHash, Arc<ChannelManager<M, T, K, F, R, L>>)
where M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>, where
T::Target: BroadcasterInterface, M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>,
K::Target: KeysInterface, T::Target: BroadcasterInterface,
F::Target: FeeEstimator, K::Target: KeysInterface,
L::Target: Logger, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger,
{ {
fn read<R: io::Read>(reader: &mut R, args: ChannelManagerReadArgs<'a, M, T, K, F, L>) -> Result<Self, DecodeError> { fn read<Reader: io::Read>(reader: &mut Reader, args: ChannelManagerReadArgs<'a, M, T, K, F, R, L>) -> Result<Self, DecodeError> {
let (blockhash, chan_manager) = <(BlockHash, ChannelManager<M, T, K, F, L>)>::read(reader, args)?; let (blockhash, chan_manager) = <(BlockHash, ChannelManager<M, T, K, F, R, L>)>::read(reader, args)?;
Ok((blockhash, Arc::new(chan_manager))) Ok((blockhash, Arc::new(chan_manager)))
} }
} }
impl<'a, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> impl<'a, M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref>
ReadableArgs<ChannelManagerReadArgs<'a, M, T, K, F, L>> for (BlockHash, ChannelManager<M, T, K, F, L>) ReadableArgs<ChannelManagerReadArgs<'a, M, T, K, F, R, L>> for (BlockHash, ChannelManager<M, T, K, F, R, L>)
where M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>, where
T::Target: BroadcasterInterface, M::Target: chain::Watch<<K::Target as SignerProvider>::Signer>,
K::Target: KeysInterface, T::Target: BroadcasterInterface,
F::Target: FeeEstimator, K::Target: KeysInterface,
L::Target: Logger, F::Target: FeeEstimator,
R::Target: Router,
L::Target: Logger,
{ {
fn read<R: io::Read>(reader: &mut R, mut args: ChannelManagerReadArgs<'a, M, T, K, F, L>) -> Result<Self, DecodeError> { fn read<Reader: io::Read>(reader: &mut Reader, mut args: ChannelManagerReadArgs<'a, M, T, K, F, R, L>) -> Result<Self, DecodeError> {
let _ver = read_ver_prefix!(reader, SERIALIZATION_VERSION); let _ver = read_ver_prefix!(reader, SERIALIZATION_VERSION);
let genesis_hash: BlockHash = Readable::read(reader)?; let genesis_hash: BlockHash = Readable::read(reader)?;
@ -7096,6 +7126,7 @@ impl<'a, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
fee_estimator: bounded_fee_estimator, fee_estimator: bounded_fee_estimator,
chain_monitor: args.chain_monitor, chain_monitor: args.chain_monitor,
tx_broadcaster: args.tx_broadcaster, tx_broadcaster: args.tx_broadcaster,
router: args.router,
best_block: RwLock::new(BestBlock::new(best_block_hash, best_block_height)), best_block: RwLock::new(BestBlock::new(best_block_hash, best_block_height)),
@ -7754,7 +7785,8 @@ pub mod bench {
&'a test_utils::TestBroadcaster, &'a test_utils::TestFeeEstimator, &'a test_utils::TestBroadcaster, &'a test_utils::TestFeeEstimator,
&'a test_utils::TestLogger, &'a P>, &'a test_utils::TestLogger, &'a P>,
&'a test_utils::TestBroadcaster, &'a KeysManager, &'a test_utils::TestBroadcaster, &'a KeysManager,
&'a test_utils::TestFeeEstimator, &'a test_utils::TestLogger>, &'a test_utils::TestFeeEstimator, &'a test_utils::TestRouter,
&'a test_utils::TestLogger>,
} }
#[cfg(test)] #[cfg(test)]
@ -7772,6 +7804,7 @@ pub mod bench {
let tx_broadcaster = test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new()), blocks: Arc::new(Mutex::new(Vec::new()))}; let tx_broadcaster = test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new()), blocks: Arc::new(Mutex::new(Vec::new()))};
let fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: Mutex::new(253) }; let fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: Mutex::new(253) };
let router = test_utils::TestRouter {};
let mut config: UserConfig = Default::default(); let mut config: UserConfig = Default::default();
config.channel_handshake_config.minimum_depth = 1; config.channel_handshake_config.minimum_depth = 1;
@ -7780,7 +7813,7 @@ pub mod bench {
let chain_monitor_a = ChainMonitor::new(None, &tx_broadcaster, &logger_a, &fee_estimator, &persister_a); let chain_monitor_a = ChainMonitor::new(None, &tx_broadcaster, &logger_a, &fee_estimator, &persister_a);
let seed_a = [1u8; 32]; let seed_a = [1u8; 32];
let keys_manager_a = KeysManager::new(&seed_a, 42, 42); let keys_manager_a = KeysManager::new(&seed_a, 42, 42);
let node_a = ChannelManager::new(&fee_estimator, &chain_monitor_a, &tx_broadcaster, &logger_a, &keys_manager_a, config.clone(), ChainParameters { let node_a = ChannelManager::new(&fee_estimator, &chain_monitor_a, &tx_broadcaster, &router, &logger_a, &keys_manager_a, config.clone(), ChainParameters {
network, network,
best_block: BestBlock::from_genesis(network), best_block: BestBlock::from_genesis(network),
}); });
@ -7790,7 +7823,7 @@ pub mod bench {
let chain_monitor_b = ChainMonitor::new(None, &tx_broadcaster, &logger_a, &fee_estimator, &persister_b); let chain_monitor_b = ChainMonitor::new(None, &tx_broadcaster, &logger_a, &fee_estimator, &persister_b);
let seed_b = [2u8; 32]; let seed_b = [2u8; 32];
let keys_manager_b = KeysManager::new(&seed_b, 42, 42); let keys_manager_b = KeysManager::new(&seed_b, 42, 42);
let node_b = ChannelManager::new(&fee_estimator, &chain_monitor_b, &tx_broadcaster, &logger_b, &keys_manager_b, config.clone(), ChainParameters { let node_b = ChannelManager::new(&fee_estimator, &chain_monitor_b, &tx_broadcaster, &router, &logger_b, &keys_manager_b, config.clone(), ChainParameters {
network, network,
best_block: BestBlock::from_genesis(network), best_block: BestBlock::from_genesis(network),
}); });

21
lightning/src/ln/functional_test_utils.rs
View file

@ -301,6 +301,7 @@ pub struct NodeCfg<'a> {
pub chain_source: &'a test_utils::TestChainSource, pub chain_source: &'a test_utils::TestChainSource,
pub tx_broadcaster: &'a test_utils::TestBroadcaster, pub tx_broadcaster: &'a test_utils::TestBroadcaster,
pub fee_estimator: &'a test_utils::TestFeeEstimator, pub fee_estimator: &'a test_utils::TestFeeEstimator,
pub router: test_utils::TestRouter,
pub chain_monitor: test_utils::TestChainMonitor<'a>, pub chain_monitor: test_utils::TestChainMonitor<'a>,
pub keys_manager: &'a test_utils::TestKeysInterface, pub keys_manager: &'a test_utils::TestKeysInterface,
pub logger: &'a test_utils::TestLogger, pub logger: &'a test_utils::TestLogger,
@ -313,9 +314,10 @@ pub struct Node<'a, 'b: 'a, 'c: 'b> {
pub chain_source: &'c test_utils::TestChainSource, pub chain_source: &'c test_utils::TestChainSource,
pub tx_broadcaster: &'c test_utils::TestBroadcaster, pub tx_broadcaster: &'c test_utils::TestBroadcaster,
pub fee_estimator: &'c test_utils::TestFeeEstimator, pub fee_estimator: &'c test_utils::TestFeeEstimator,
pub router: &'b test_utils::TestRouter,
pub chain_monitor: &'b test_utils::TestChainMonitor<'c>, pub chain_monitor: &'b test_utils::TestChainMonitor<'c>,
pub keys_manager: &'b test_utils::TestKeysInterface, pub keys_manager: &'b test_utils::TestKeysInterface,
pub node: &'a ChannelManager<&'b TestChainMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator, &'c test_utils::TestLogger>, pub node: &'a ChannelManager<&'b TestChainMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator, &'c test_utils::TestRouter, &'c test_utils::TestLogger>,
pub network_graph: &'b NetworkGraph<&'c test_utils::TestLogger>, pub network_graph: &'b NetworkGraph<&'c test_utils::TestLogger>,
pub gossip_sync: P2PGossipSync<&'b NetworkGraph<&'c test_utils::TestLogger>, &'c test_utils::TestChainSource, &'c test_utils::TestLogger>, pub gossip_sync: P2PGossipSync<&'b NetworkGraph<&'c test_utils::TestLogger>, &'c test_utils::TestChainSource, &'c test_utils::TestLogger>,
pub node_seed: [u8; 32], pub node_seed: [u8; 32],
@ -415,10 +417,11 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
let mut w = test_utils::TestVecWriter(Vec::new()); let mut w = test_utils::TestVecWriter(Vec::new());
self.node.write(&mut w).unwrap(); self.node.write(&mut w).unwrap();
<(BlockHash, ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut io::Cursor::new(w.0), ChannelManagerReadArgs { <(BlockHash, ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>)>::read(&mut io::Cursor::new(w.0), ChannelManagerReadArgs {
default_config: *self.node.get_current_default_configuration(), default_config: *self.node.get_current_default_configuration(),
keys_manager: self.keys_manager, keys_manager: self.keys_manager,
fee_estimator: &test_utils::TestFeeEstimator { sat_per_kw: Mutex::new(253) }, fee_estimator: &test_utils::TestFeeEstimator { sat_per_kw: Mutex::new(253) },
router: &test_utils::TestRouter {},
chain_monitor: self.chain_monitor, chain_monitor: self.chain_monitor,
tx_broadcaster: &broadcaster, tx_broadcaster: &broadcaster,
logger: &self.logger, logger: &self.logger,
@ -655,7 +658,7 @@ macro_rules! check_added_monitors {
} }
} }
pub fn _reload_node<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, default_config: UserConfig, chanman_encoded: &[u8], monitors_encoded: &[&[u8]]) -> ChannelManager<&'b TestChainMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator, &'c test_utils::TestLogger> { pub fn _reload_node<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, default_config: UserConfig, chanman_encoded: &[u8], monitors_encoded: &[&[u8]]) -> ChannelManager<&'b TestChainMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator, &'c test_utils::TestRouter, &'c test_utils::TestLogger> {
let mut monitors_read = Vec::with_capacity(monitors_encoded.len()); let mut monitors_read = Vec::with_capacity(monitors_encoded.len());
for encoded in monitors_encoded { for encoded in monitors_encoded {
let mut monitor_read = &encoded[..]; let mut monitor_read = &encoded[..];
@ -671,10 +674,11 @@ pub fn _reload_node<'a, 'b, 'c, 'd>(node: &'a Node<'b, 'c, 'd>, default_config:
for monitor in monitors_read.iter_mut() { for monitor in monitors_read.iter_mut() {
assert!(channel_monitors.insert(monitor.get_funding_txo().0, monitor).is_none()); assert!(channel_monitors.insert(monitor.get_funding_txo().0, monitor).is_none());
} }
<(BlockHash, ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut node_read, ChannelManagerReadArgs { <(BlockHash, ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>)>::read(&mut node_read, ChannelManagerReadArgs {
default_config, default_config,
keys_manager: node.keys_manager, keys_manager: node.keys_manager,
fee_estimator: node.fee_estimator, fee_estimator: node.fee_estimator,
router: node.router,
chain_monitor: node.chain_monitor, chain_monitor: node.chain_monitor,
tx_broadcaster: node.tx_broadcaster, tx_broadcaster: node.tx_broadcaster,
logger: node.logger, logger: node.logger,
@ -2169,6 +2173,7 @@ pub fn create_node_cfgs<'a>(node_count: usize, chanmon_cfgs: &'a Vec<TestChanMon
logger: &chanmon_cfgs[i].logger, logger: &chanmon_cfgs[i].logger,
tx_broadcaster: &chanmon_cfgs[i].tx_broadcaster, tx_broadcaster: &chanmon_cfgs[i].tx_broadcaster,
fee_estimator: &chanmon_cfgs[i].fee_estimator, fee_estimator: &chanmon_cfgs[i].fee_estimator,
router: test_utils::TestRouter {},
chain_monitor, chain_monitor,
keys_manager: &chanmon_cfgs[i].keys_manager, keys_manager: &chanmon_cfgs[i].keys_manager,
node_seed: seed, node_seed: seed,
@ -2196,7 +2201,7 @@ pub fn test_default_channel_config() -> UserConfig {
default_config default_config
} }
pub fn create_node_chanmgrs<'a, 'b>(node_count: usize, cfgs: &'a Vec<NodeCfg<'b>>, node_config: &[Option<UserConfig>]) -> Vec<ChannelManager<&'a TestChainMonitor<'b>, &'b test_utils::TestBroadcaster, &'a test_utils::TestKeysInterface, &'b test_utils::TestFeeEstimator, &'b test_utils::TestLogger>> { pub fn create_node_chanmgrs<'a, 'b>(node_count: usize, cfgs: &'a Vec<NodeCfg<'b>>, node_config: &[Option<UserConfig>]) -> Vec<ChannelManager<&'a TestChainMonitor<'b>, &'b test_utils::TestBroadcaster, &'a test_utils::TestKeysInterface, &'b test_utils::TestFeeEstimator, &'a test_utils::TestRouter, &'b test_utils::TestLogger>> {
let mut chanmgrs = Vec::new(); let mut chanmgrs = Vec::new();
for i in 0..node_count { for i in 0..node_count {
let network = Network::Testnet; let network = Network::Testnet;
@ -2204,7 +2209,7 @@ pub fn create_node_chanmgrs<'a, 'b>(node_count: usize, cfgs: &'a Vec<NodeCfg<'b>
network, network,
best_block: BestBlock::from_genesis(network), best_block: BestBlock::from_genesis(network),
}; };
let node = ChannelManager::new(cfgs[i].fee_estimator, &cfgs[i].chain_monitor, cfgs[i].tx_broadcaster, cfgs[i].logger, cfgs[i].keys_manager, let node = ChannelManager::new(cfgs[i].fee_estimator, &cfgs[i].chain_monitor, cfgs[i].tx_broadcaster, &cfgs[i].router, cfgs[i].logger, cfgs[i].keys_manager,
if node_config[i].is_some() { node_config[i].clone().unwrap() } else { test_default_channel_config() }, params); if node_config[i].is_some() { node_config[i].clone().unwrap() } else { test_default_channel_config() }, params);
chanmgrs.push(node); chanmgrs.push(node);
} }
@ -2212,7 +2217,7 @@ pub fn create_node_chanmgrs<'a, 'b>(node_count: usize, cfgs: &'a Vec<NodeCfg<'b>
chanmgrs chanmgrs
} }
pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec<NodeCfg<'c>>, chan_mgrs: &'a Vec<ChannelManager<&'b TestChainMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator, &'c test_utils::TestLogger>>) -> Vec<Node<'a, 'b, 'c>> { pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec<NodeCfg<'c>>, chan_mgrs: &'a Vec<ChannelManager<&'b TestChainMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator, &'c test_utils::TestRouter, &'c test_utils::TestLogger>>) -> Vec<Node<'a, 'b, 'c>> {
let mut nodes = Vec::new(); let mut nodes = Vec::new();
let chan_count = Rc::new(RefCell::new(0)); let chan_count = Rc::new(RefCell::new(0));
let payment_count = Rc::new(RefCell::new(0)); let payment_count = Rc::new(RefCell::new(0));
@ -2222,7 +2227,7 @@ pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec<NodeC
let gossip_sync = P2PGossipSync::new(&cfgs[i].network_graph, None, cfgs[i].logger); let gossip_sync = P2PGossipSync::new(&cfgs[i].network_graph, None, cfgs[i].logger);
nodes.push(Node{ nodes.push(Node{
chain_source: cfgs[i].chain_source, tx_broadcaster: cfgs[i].tx_broadcaster, chain_source: cfgs[i].chain_source, tx_broadcaster: cfgs[i].tx_broadcaster,
fee_estimator: cfgs[i].fee_estimator, fee_estimator: cfgs[i].fee_estimator, router: &cfgs[i].router,
chain_monitor: &cfgs[i].chain_monitor, keys_manager: &cfgs[i].keys_manager, chain_monitor: &cfgs[i].chain_monitor, keys_manager: &cfgs[i].keys_manager,
node: &chan_mgrs[i], network_graph: &cfgs[i].network_graph, gossip_sync, node: &chan_mgrs[i], network_graph: &cfgs[i].network_graph, gossip_sync,
node_seed: cfgs[i].node_seed, network_chan_count: chan_count.clone(), node_seed: cfgs[i].node_seed, network_chan_count: chan_count.clone(),

3
lightning/src/ln/functional_tests.rs
View file

@ -5214,8 +5214,9 @@ fn test_key_derivation_params() {
let seed = [42; 32]; let seed = [42; 32];
let keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet); let keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet);
let chain_monitor = test_utils::TestChainMonitor::new(Some(&chanmon_cfgs[0].chain_source), &chanmon_cfgs[0].tx_broadcaster, &chanmon_cfgs[0].logger, &chanmon_cfgs[0].fee_estimator, &chanmon_cfgs[0].persister, &keys_manager); let chain_monitor = test_utils::TestChainMonitor::new(Some(&chanmon_cfgs[0].chain_source), &chanmon_cfgs[0].tx_broadcaster, &chanmon_cfgs[0].logger, &chanmon_cfgs[0].fee_estimator, &chanmon_cfgs[0].persister, &keys_manager);
let router = test_utils::TestRouter {};
let network_graph = NetworkGraph::new(chanmon_cfgs[0].chain_source.genesis_hash, &chanmon_cfgs[0].logger); let network_graph = NetworkGraph::new(chanmon_cfgs[0].chain_source.genesis_hash, &chanmon_cfgs[0].logger);
let node = NodeCfg { chain_source: &chanmon_cfgs[0].chain_source, logger: &chanmon_cfgs[0].logger, tx_broadcaster: &chanmon_cfgs[0].tx_broadcaster, fee_estimator: &chanmon_cfgs[0].fee_estimator, chain_monitor, keys_manager: &keys_manager, network_graph, node_seed: seed, features: channelmanager::provided_init_features() }; let node = NodeCfg { chain_source: &chanmon_cfgs[0].chain_source, logger: &chanmon_cfgs[0].logger, tx_broadcaster: &chanmon_cfgs[0].tx_broadcaster, fee_estimator: &chanmon_cfgs[0].fee_estimator, router, chain_monitor, keys_manager: &keys_manager, network_graph, node_seed: seed, features: channelmanager::provided_init_features() };
let mut node_cfgs = create_node_cfgs(3, &chanmon_cfgs); let mut node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
node_cfgs.remove(0); node_cfgs.remove(0);
node_cfgs.insert(0, node); node_cfgs.insert(0, node);

12
lightning/src/ln/payment_tests.rs
View file

@ -367,7 +367,7 @@ fn do_retry_with_no_persist(confirm_before_reload: bool) {
let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
let persister: test_utils::TestPersister; let persister: test_utils::TestPersister;
let new_chain_monitor: test_utils::TestChainMonitor; let new_chain_monitor: test_utils::TestChainMonitor;
let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2; let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2;
@ -545,13 +545,13 @@ fn do_test_completed_payment_not_retryable_on_reload(use_dust: bool) {
let first_persister: test_utils::TestPersister; let first_persister: test_utils::TestPersister;
let first_new_chain_monitor: test_utils::TestChainMonitor; let first_new_chain_monitor: test_utils::TestChainMonitor;
let first_nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let first_nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let second_persister: test_utils::TestPersister; let second_persister: test_utils::TestPersister;
let second_new_chain_monitor: test_utils::TestChainMonitor; let second_new_chain_monitor: test_utils::TestChainMonitor;
let second_nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let second_nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let third_persister: test_utils::TestPersister; let third_persister: test_utils::TestPersister;
let third_new_chain_monitor: test_utils::TestChainMonitor; let third_new_chain_monitor: test_utils::TestChainMonitor;
let third_nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let third_nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
@ -716,7 +716,7 @@ fn do_test_dup_htlc_onchain_fails_on_reload(persist_manager_post_event: bool, co
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
let persister: test_utils::TestPersister; let persister: test_utils::TestPersister;
let new_chain_monitor: test_utils::TestChainMonitor; let new_chain_monitor: test_utils::TestChainMonitor;
let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 1, channelmanager::provided_init_features(), channelmanager::provided_init_features()); let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 1, channelmanager::provided_init_features(), channelmanager::provided_init_features());
@ -859,7 +859,7 @@ fn test_fulfill_restart_failure() {
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
let persister: test_utils::TestPersister; let persister: test_utils::TestPersister;
let new_chain_monitor: test_utils::TestChainMonitor; let new_chain_monitor: test_utils::TestChainMonitor;
let nodes_1_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let nodes_1_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2; let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2;

4
lightning/src/ln/peer_handler.rs
View file

@ -491,7 +491,7 @@ impl Peer {
/// issues such as overly long function definitions. /// issues such as overly long function definitions.
/// ///
/// (C-not exported) as `Arc`s don't make sense in bindings. /// (C-not exported) as `Arc`s don't make sense in bindings.
pub type SimpleArcPeerManager<SD, M, T, F, C, L> = PeerManager<SD, Arc<SimpleArcChannelManager<M, T, F, L>>, Arc<P2PGossipSync<Arc<NetworkGraph<Arc<L>>>, Arc<C>, Arc<L>>>, Arc<SimpleArcOnionMessenger<L>>, Arc<L>, IgnoringMessageHandler>; pub type SimpleArcPeerManager<SD, M, T, F, C, R, L> = PeerManager<SD, Arc<SimpleArcChannelManager<M, T, F, R, L>>, Arc<P2PGossipSync<Arc<NetworkGraph<Arc<L>>>, Arc<C>, Arc<L>>>, Arc<SimpleArcOnionMessenger<L>>, Arc<L>, IgnoringMessageHandler>;
/// SimpleRefPeerManager is a type alias for a PeerManager reference, and is the reference /// SimpleRefPeerManager is a type alias for a PeerManager reference, and is the reference
/// counterpart to the SimpleArcPeerManager type alias. Use this type by default when you don't /// counterpart to the SimpleArcPeerManager type alias. Use this type by default when you don't
@ -501,7 +501,7 @@ pub type SimpleArcPeerManager<SD, M, T, F, C, L> = PeerManager<SD, Arc<SimpleArc
/// helps with issues such as long function definitions. /// helps with issues such as long function definitions.
/// ///
/// (C-not exported) as general type aliases don't make sense in bindings. /// (C-not exported) as general type aliases don't make sense in bindings.
pub type SimpleRefPeerManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, SD, M, T, F, C, L> = PeerManager<SD, SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, M, T, F, L>, &'e P2PGossipSync<&'g NetworkGraph<&'f L>, &'h C, &'f L>, &'i SimpleRefOnionMessenger<'j, 'k, L>, &'f L, IgnoringMessageHandler>; pub type SimpleRefPeerManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, SD, M, T, F, C, R, L> = PeerManager<SD, SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, 'f, M, T, F, R, L>, &'f P2PGossipSync<&'g NetworkGraph<&'f L>, &'h C, &'f L>, &'i SimpleRefOnionMessenger<'j, 'k, L>, &'f L, IgnoringMessageHandler>;
/// A PeerManager manages a set of peers, described by their [`SocketDescriptor`] and marshalls /// A PeerManager manages a set of peers, described by their [`SocketDescriptor`] and marshalls
/// socket events into messages which it passes on to its [`MessageHandler`]. /// socket events into messages which it passes on to its [`MessageHandler`].

2
lightning/src/ln/priv_short_conf_tests.rs
View file

@ -48,7 +48,7 @@ fn test_priv_forwarding_rejection() {
let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(no_announce_cfg), None]); let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(no_announce_cfg), None]);
let persister: test_utils::TestPersister; let persister: test_utils::TestPersister;
let new_chain_monitor: test_utils::TestChainMonitor; let new_chain_monitor: test_utils::TestChainMonitor;
let nodes_1_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let nodes_1_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
let chan_id_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2; let chan_id_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2;

20
lightning/src/ln/reload_tests.rs
View file

@ -40,7 +40,7 @@ fn test_funding_peer_disconnect() {
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
let persister: test_utils::TestPersister; let persister: test_utils::TestPersister;
let new_chain_monitor: test_utils::TestChainMonitor; let new_chain_monitor: test_utils::TestChainMonitor;
let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features());
@ -185,7 +185,7 @@ fn test_no_txn_manager_serialize_deserialize() {
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
let persister: test_utils::TestPersister; let persister: test_utils::TestPersister;
let new_chain_monitor: test_utils::TestChainMonitor; let new_chain_monitor: test_utils::TestChainMonitor;
let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features()); let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, channelmanager::provided_init_features(), channelmanager::provided_init_features());
@ -225,7 +225,7 @@ fn test_manager_serialize_deserialize_events() {
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
let persister: test_utils::TestPersister; let persister: test_utils::TestPersister;
let new_chain_monitor: test_utils::TestChainMonitor; let new_chain_monitor: test_utils::TestChainMonitor;
let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
// Start creating a channel, but stop right before broadcasting the funding transaction // Start creating a channel, but stop right before broadcasting the funding transaction
@ -308,7 +308,7 @@ fn test_simple_manager_serialize_deserialize() {
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
let persister: test_utils::TestPersister; let persister: test_utils::TestPersister;
let new_chain_monitor: test_utils::TestChainMonitor; let new_chain_monitor: test_utils::TestChainMonitor;
let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2; let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2;
@ -336,7 +336,7 @@ fn test_manager_serialize_deserialize_inconsistent_monitor() {
let fee_estimator: test_utils::TestFeeEstimator; let fee_estimator: test_utils::TestFeeEstimator;
let persister: test_utils::TestPersister; let persister: test_utils::TestPersister;
let new_chain_monitor: test_utils::TestChainMonitor; let new_chain_monitor: test_utils::TestChainMonitor;
let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs); let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
let chan_id_1 = create_announced_chan_between_nodes(&nodes, 0, 1, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2; let chan_id_1 = create_announced_chan_between_nodes(&nodes, 0, 1, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2;
let chan_id_2 = create_announced_chan_between_nodes(&nodes, 2, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2; let chan_id_2 = create_announced_chan_between_nodes(&nodes, 2, 0, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2;
@ -392,10 +392,11 @@ fn test_manager_serialize_deserialize_inconsistent_monitor() {
let mut nodes_0_read = &nodes_0_serialized[..]; let mut nodes_0_read = &nodes_0_serialized[..];
if let Err(msgs::DecodeError::InvalidValue) = if let Err(msgs::DecodeError::InvalidValue) =
<(BlockHash, ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs { <(BlockHash, ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
default_config: UserConfig::default(), default_config: UserConfig::default(),
keys_manager, keys_manager,
fee_estimator: &fee_estimator, fee_estimator: &fee_estimator,
router: &nodes[0].router,
chain_monitor: nodes[0].chain_monitor, chain_monitor: nodes[0].chain_monitor,
tx_broadcaster: nodes[0].tx_broadcaster.clone(), tx_broadcaster: nodes[0].tx_broadcaster.clone(),
logger: &logger, logger: &logger,
@ -406,10 +407,11 @@ fn test_manager_serialize_deserialize_inconsistent_monitor() {
let mut nodes_0_read = &nodes_0_serialized[..]; let mut nodes_0_read = &nodes_0_serialized[..];
let (_, nodes_0_deserialized_tmp) = let (_, nodes_0_deserialized_tmp) =
<(BlockHash, ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs { <(BlockHash, ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
default_config: UserConfig::default(), default_config: UserConfig::default(),
keys_manager, keys_manager,
fee_estimator: &fee_estimator, fee_estimator: &fee_estimator,
router: nodes[0].router,
chain_monitor: nodes[0].chain_monitor, chain_monitor: nodes[0].chain_monitor,
tx_broadcaster: nodes[0].tx_broadcaster.clone(), tx_broadcaster: nodes[0].tx_broadcaster.clone(),
logger: &logger, logger: &logger,
@ -589,7 +591,7 @@ fn test_forwardable_regen() {
let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
let persister: test_utils::TestPersister; let persister: test_utils::TestPersister;
let new_chain_monitor: test_utils::TestChainMonitor; let new_chain_monitor: test_utils::TestChainMonitor;
let nodes_1_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let nodes_1_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
let chan_id_1 = create_announced_chan_between_nodes(&nodes, 0, 1, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2; let chan_id_1 = create_announced_chan_between_nodes(&nodes, 0, 1, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2;
let chan_id_2 = create_announced_chan_between_nodes(&nodes, 1, 2, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2; let chan_id_2 = create_announced_chan_between_nodes(&nodes, 1, 2, channelmanager::provided_init_features(), channelmanager::provided_init_features()).2;
@ -673,7 +675,7 @@ fn do_test_partial_claim_before_restart(persist_both_monitors: bool) {
let persister: test_utils::TestPersister; let persister: test_utils::TestPersister;
let new_chain_monitor: test_utils::TestChainMonitor; let new_chain_monitor: test_utils::TestChainMonitor;
let nodes_3_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let nodes_3_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs); let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);

2
lightning/src/ln/reorg_tests.rs
View file

@ -260,7 +260,7 @@ fn do_test_unconf_chan(reload_node: bool, reorg_after_reload: bool, use_funding_
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
let persister: test_utils::TestPersister; let persister: test_utils::TestPersister;
let new_chain_monitor: test_utils::TestChainMonitor; let new_chain_monitor: test_utils::TestChainMonitor;
let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>; let nodes_0_deserialized: ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>;
let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
*nodes[0].connect_style.borrow_mut() = connect_style; *nodes[0].connect_style.borrow_mut() = connect_style;

11
lightning/src/util/persist.rs
View file

@ -20,6 +20,7 @@ use crate::chain::keysinterface::{Sign, KeysInterface, SignerProvider};
use crate::chain::transaction::OutPoint; use crate::chain::transaction::OutPoint;
use crate::chain::channelmonitor::{ChannelMonitor, ChannelMonitorUpdate}; use crate::chain::channelmonitor::{ChannelMonitor, ChannelMonitorUpdate};
use crate::ln::channelmanager::ChannelManager; use crate::ln::channelmanager::ChannelManager;
use crate::routing::router::Router;
use crate::routing::gossip::NetworkGraph; use crate::routing::gossip::NetworkGraph;
use super::{logger::Logger, ser::Writeable}; use super::{logger::Logger, ser::Writeable};
@ -33,15 +34,16 @@ pub trait KVStorePersister {
} }
/// Trait that handles persisting a [`ChannelManager`], [`NetworkGraph`], and [`WriteableScore`] to disk. /// Trait that handles persisting a [`ChannelManager`], [`NetworkGraph`], and [`WriteableScore`] to disk.
pub trait Persister<'a, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref, S: WriteableScore<'a>> pub trait Persister<'a, M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref, S: WriteableScore<'a>>
where M::Target: 'static + chain::Watch<<K::Target as SignerProvider>::Signer>, where M::Target: 'static + chain::Watch<<K::Target as SignerProvider>::Signer>,
T::Target: 'static + BroadcasterInterface, T::Target: 'static + BroadcasterInterface,
K::Target: 'static + KeysInterface, K::Target: 'static + KeysInterface,
F::Target: 'static + FeeEstimator, F::Target: 'static + FeeEstimator,
R::Target: 'static + Router,
L::Target: 'static + Logger, L::Target: 'static + Logger,
{ {
/// Persist the given ['ChannelManager'] to disk, returning an error if persistence failed. /// Persist the given ['ChannelManager'] to disk, returning an error if persistence failed.
fn persist_manager(&self, channel_manager: &ChannelManager<M, T, K, F, L>) -> Result<(), io::Error>; fn persist_manager(&self, channel_manager: &ChannelManager<M, T, K, F, R, L>) -> Result<(), io::Error>;
/// Persist the given [`NetworkGraph`] to disk, returning an error if persistence failed. /// Persist the given [`NetworkGraph`] to disk, returning an error if persistence failed.
fn persist_graph(&self, network_graph: &NetworkGraph<L>) -> Result<(), io::Error>; fn persist_graph(&self, network_graph: &NetworkGraph<L>) -> Result<(), io::Error>;
@ -50,15 +52,16 @@ pub trait Persister<'a, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref, S: Wri
fn persist_scorer(&self, scorer: &S) -> Result<(), io::Error>; fn persist_scorer(&self, scorer: &S) -> Result<(), io::Error>;
} }
impl<'a, A: KVStorePersister, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref, S: WriteableScore<'a>> Persister<'a, M, T, K, F, L, S> for A impl<'a, A: KVStorePersister, M: Deref, T: Deref, K: Deref, F: Deref, R: Deref, L: Deref, S: WriteableScore<'a>> Persister<'a, M, T, K, F, R, L, S> for A
where M::Target: 'static + chain::Watch<<K::Target as SignerProvider>::Signer>, where M::Target: 'static + chain::Watch<<K::Target as SignerProvider>::Signer>,
T::Target: 'static + BroadcasterInterface, T::Target: 'static + BroadcasterInterface,
K::Target: 'static + KeysInterface, K::Target: 'static + KeysInterface,
F::Target: 'static + FeeEstimator, F::Target: 'static + FeeEstimator,
R::Target: 'static + Router,
L::Target: 'static + Logger, L::Target: 'static + Logger,
{ {
/// Persist the given ['ChannelManager'] to disk with the name "manager", returning an error if persistence failed. /// Persist the given ['ChannelManager'] to disk with the name "manager", returning an error if persistence failed.
fn persist_manager(&self, channel_manager: &ChannelManager<M, T, K, F, L>) -> Result<(), io::Error> { fn persist_manager(&self, channel_manager: &ChannelManager<M, T, K, F, R, L>) -> Result<(), io::Error> {
self.persist("manager", channel_manager) self.persist("manager", channel_manager)
} }

19
lightning/src/util/test_utils.rs
View file

@ -21,6 +21,7 @@ use crate::ln::channelmanager;
use crate::ln::features::{ChannelFeatures, InitFeatures, NodeFeatures}; use crate::ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
use crate::ln::{msgs, wire}; use crate::ln::{msgs, wire};
use crate::ln::script::ShutdownScript; use crate::ln::script::ShutdownScript;
use crate::routing::router::{InFlightHtlcs, Route, RouteHop, RouteParameters, Router};
use crate::routing::scoring::FixedPenaltyScorer; use crate::routing::scoring::FixedPenaltyScorer;
use crate::util::enforcing_trait_impls::{EnforcingSigner, EnforcementState}; use crate::util::enforcing_trait_impls::{EnforcingSigner, EnforcementState};
use crate::util::events; use crate::util::events;
@ -71,6 +72,24 @@ impl chaininterface::FeeEstimator for TestFeeEstimator {
} }
} }
pub struct TestRouter {}
impl Router for TestRouter {
fn find_route(
&self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&channelmanager::ChannelDetails]>,
_inflight_htlcs: InFlightHtlcs
) -> Result<Route, msgs::LightningError> {
Err(msgs::LightningError {
err: String::from("Not implemented"),
action: msgs::ErrorAction::IgnoreError
})
}
fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}
fn notify_payment_probe_successful(&self, _path: &[&RouteHop]) {}
fn notify_payment_probe_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
}
pub struct OnlyReadsKeysInterface {} pub struct OnlyReadsKeysInterface {}
impl EntropySource for OnlyReadsKeysInterface { impl EntropySource for OnlyReadsKeysInterface {