Feat: configurable probes

Cargo.toml

@@ -27,6 +27,7 @@ libc = "0.2"
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
 rand = "0.4"
 serde_json = { version = "1.0" }
+serde = { version = "1.0", features = ["derive"] }
 tokio = { version = "1", features = [ "io-util", "macros", "rt", "rt-multi-thread", "sync", "net", "time", "io-std" ] }
 
 [profile.release]

README.md

@@ -21,6 +21,19 @@ cargo run <bitcoind-rpc-username>:<bitcoind-rpc-password>@<bitcoind-rpc-host>:<b
 `announced-listen-addr` can be set to an IPv4 or IPv6 address to announce that as a publicly-connectable address for this node.
 `announced-node-name` can be any string up to 32 bytes in length, representing this node's alias.
 
+## Probe Config
+Targeted probing is disabled unless a config file exists.
+
+```
+cp ./prober_config.json.example <ldk data dir>/prober_config.json
+```
+
+`probe_peers` pubkey of peers you are probing.
+
+`probe_interval_sec` how often to probe, in seconds.
+
+`max_amount_msats` maximum amount to probe, in millisatoshis.
+
 ## License
 
 Licensed under either:

prober_config.json.example

@@ -0,0 +1,8 @@
+{
+ "probe_interval_sec" : 10,
+ "probe_peers" : [
+ "03cc91150efc4bbe8d9f8ced06fbc81ad50b076b9759139e4c2d7a8380566da7e1",
+ "037d8e050899fa0732fdd6fc1e0d5d8d685c2093932a7e10dc5e6fab8a34ed1c43"
+ ],
+ "max_amount_msats": 500000000
+}

src/main.rs

@@ -12,6 +12,7 @@ use bitcoin::blockdata::transaction::Transaction;
 use bitcoin::consensus::encode;
 use bitcoin::io;
 use bitcoin::network::Network;
+use bitcoin::secp256k1::PublicKey;
 use bitcoin::BlockHash;
 use bitcoin_bech32::WitnessProgram;
 use disk::{INBOUND_PAYMENTS_FNAME, OUTBOUND_PAYMENTS_FNAME};
@@ -33,7 +34,10 @@ use lightning::onion_message::messenger::{
 };
 use lightning::routing::gossip;
 use lightning::routing::gossip::{NodeId, P2PGossipSync};
-use lightning::routing::router::DefaultRouter;
+use lightning::routing::router::{
+	DefaultRouter, PaymentParameters, RouteParameters, ScorerAccountingForInFlightHtlcs,
+};
+use lightning::routing::scoring::ProbabilisticScorer;
 use lightning::routing::scoring::ProbabilisticScoringFeeParameters;
 use lightning::sign::{EntropySource, InMemorySigner, KeysManager, NodeSigner};
 use lightning::types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
@@ -54,6 +58,7 @@ use lightning_dns_resolver::OMDomainResolver;
 use lightning_net_tokio::SocketDescriptor;
 use lightning_persister::fs_store::FilesystemStore;
 use rand::{thread_rng, Rng};
+use serde::Deserialize;
 use std::collections::HashMap as StdHashMap;
 use std::convert::TryInto;
 use std::fmt;
@@ -73,6 +78,13 @@ pub(crate) enum HTLCStatus {
 	Failed,
 }
 
+#[derive(Deserialize)]
+struct ProbeConfig {
+	probe_interval_sec: u64,
+	probe_peers: Vec<String>,
+	max_amount_msats: u64,
+}
+
 impl_writeable_tlv_based_enum!(HTLCStatus,
 	(0, Pending) => {},
 	(1, Succeeded) => {},
@@ -209,6 +221,62 @@ pub(crate) type OutputSweeper = ldk_sweep::OutputSweeper<
 // Needed due to rust-lang/rust#63033.
 struct OutputSweeperWrapper(Arc<OutputSweeper>);
 
+fn prepare_probe(
+	channel_manager: &ChannelManager, graph: &NetworkGraph, logger: &disk::FilesystemLogger,
+	scorer: &RwLock<ProbabilisticScorer<Arc<NetworkGraph>, Arc<disk::FilesystemLogger>>>,
+	pub_key_hex: &str, probe_amount: u64,
+) {
+	if probe_amount == 0 {
+ return;
+	}
+	let amt = ::rand::random::<u64>() % probe_amount;
+	let pub_key_bytes = match hex_utils::to_vec(pub_key_hex) {
+ Some(bytes) => bytes,
+ None => return,
+	};
+	if let Ok(pk) = bitcoin::secp256k1::PublicKey::from_slice(&pub_key_bytes) {
+ send_probe(channel_manager, pk, graph, logger, amt, scorer);
+	}
+}
+
+fn send_probe(
+	channel_manager: &ChannelManager, recipient: PublicKey, graph: &NetworkGraph,
+	logger: &disk::FilesystemLogger, amt_msat: u64,
+	scorer: &RwLock<ProbabilisticScorer<Arc<NetworkGraph>, Arc<disk::FilesystemLogger>>>,
+) {
+	let chans = channel_manager.list_usable_channels();
+	let chan_refs = chans.iter().map(|a| a).collect::<Vec<_>>();
+	let mut payment_params = PaymentParameters::from_node_id(recipient, 144);
+	payment_params.max_path_count = 1;
+	let in_flight_htlcs = channel_manager.compute_inflight_htlcs();
+	let scorer = scorer.read().unwrap();
+	let inflight_scorer = ScorerAccountingForInFlightHtlcs::new(&scorer, &in_flight_htlcs);
+	let score_params: ProbabilisticScoringFeeParameters = Default::default();
+	let route_res = lightning::routing::router::find_route(
+ &channel_manager.get_our_node_id(),
+ &RouteParameters::from_payment_params_and_value(payment_params, amt_msat),
+ &graph,
+ Some(&chan_refs),
+ logger,
+ &inflight_scorer,
+ &score_params,
+ &[32; 32],
+	);
+	if let Ok(route) = route_res {
+ for path in route.paths {
+ let _ = channel_manager.send_probe(path);
+ }
+	}
+}
+
+fn read_probe_file(ldk_data_dir: &str) -> Result<ProbeConfig, std::io::Error> {
+	let prober_file = format!("{}/prober_config.json", ldk_data_dir);
+	let file = fs::read_to_string(prober_file)?;
+	let config: ProbeConfig = serde_json::from_str(&file)
+ .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
+	Ok(config)
+}
+
 fn handle_ldk_events<'a>(
 	channel_manager: Arc<ChannelManager>, bitcoind_client: &'a BitcoindClient,
 	network_graph: &'a NetworkGraph, keys_manager: &'a KeysManager,
@@ -1158,6 +1226,41 @@ async fn start_ldk() {
  Arc::clone(&output_sweeper),
 	));
 
+	// Regularly probe
+	let probing_cm = Arc::clone(&channel_manager);
+	let probing_graph = Arc::clone(&network_graph);
+	let probing_logger = Arc::clone(&logger);
+	let probing_scorer = Arc::clone(&scorer);
+	match read_probe_file(&ldk_data_dir) {
+ Ok(probe_config) => {
+ if probe_config.probe_peers.is_empty() {
+ println!("WARNING: prober_config.json has no probe_peers. Probing disabled.");
+ } else {
+ let mut index = 0usize;
+ tokio::spawn(async move {
+ let mut interval =
+ tokio::time::interval(Duration::from_secs(probe_config.probe_interval_sec));
+ loop {
+ interval.tick().await;
+ if index >= probe_config.probe_peers.len() {
+ index = 0;
+ }
+ prepare_probe(
+ &*probing_cm,
+ &*probing_graph,
+ &*probing_logger,
+ &*probing_scorer,
+ &probe_config.probe_peers[index],
+ probe_config.max_amount_msats,
+ );
+ index += 1;
+ }
+ });
+ }
+ },
+ Err(_) => println!("WARNING: prober_config.json is missing. Probing disabled."),
+	};
+
 	// Start the CLI.
 	let cli_channel_manager = Arc::clone(&channel_manager);
 	let cli_chain_monitor = Arc::clone(&chain_monitor);

Cargo.toml

@@ -27,6 +27,7 @@ libc = "0.2"
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
 rand = "0.4"
 serde_json = { version = "1.0" }
+serde = { version = "1.0", features = ["derive"] }
 tokio = { version = "1", features = [ "io-util", "macros", "rt", "rt-multi-thread", "sync", "net", "time", "io-std" ] }
 
 [profile.release]

README.md

@@ -21,6 +21,19 @@ cargo run <bitcoind-rpc-username>:<bitcoind-rpc-password>@<bitcoind-rpc-host>:<b
 `announced-listen-addr` can be set to an IPv4 or IPv6 address to announce that as a publicly-connectable address for this node.
 `announced-node-name` can be any string up to 32 bytes in length, representing this node's alias.
 
+## Probe Config
+Targeted probing is disabled unless a config file exists.
+
+```
+cp ./prober_config.json.example <ldk data dir>/prober_config.json
+```
+
+`probe_peers` pubkey of peers you are probing.
+
+`probe_interval_sec` how often to probe, in seconds.
+
+`max_amount_msats` maximum amount to probe, in millisatoshis.
+
 ## License
 
 Licensed under either:

prober_config.json.example

@@ -0,0 +1,8 @@
+{
+ "probe_interval_sec" : 10,
+ "probe_peers" : [
+ "03cc91150efc4bbe8d9f8ced06fbc81ad50b076b9759139e4c2d7a8380566da7e1",
+ "037d8e050899fa0732fdd6fc1e0d5d8d685c2093932a7e10dc5e6fab8a34ed1c43"
+ ],
+ "max_amount_msats": 500000000
+}

src/main.rs

@@ -12,6 +12,7 @@ use bitcoin::blockdata::transaction::Transaction;
 use bitcoin::consensus::encode;
 use bitcoin::io;
 use bitcoin::network::Network;
+use bitcoin::secp256k1::PublicKey;
 use bitcoin::BlockHash;
 use bitcoin_bech32::WitnessProgram;
 use disk::{INBOUND_PAYMENTS_FNAME, OUTBOUND_PAYMENTS_FNAME};
@@ -33,7 +34,10 @@ use lightning::onion_message::messenger::{
 };
 use lightning::routing::gossip;
 use lightning::routing::gossip::{NodeId, P2PGossipSync};
-use lightning::routing::router::DefaultRouter;
+use lightning::routing::router::{
+	DefaultRouter, PaymentParameters, RouteParameters, ScorerAccountingForInFlightHtlcs,
+};
+use lightning::routing::scoring::ProbabilisticScorer;
 use lightning::routing::scoring::ProbabilisticScoringFeeParameters;
 use lightning::sign::{EntropySource, InMemorySigner, KeysManager, NodeSigner};
 use lightning::types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
@@ -54,6 +58,7 @@ use lightning_dns_resolver::OMDomainResolver;
 use lightning_net_tokio::SocketDescriptor;
 use lightning_persister::fs_store::FilesystemStore;
 use rand::{thread_rng, Rng};
+use serde::Deserialize;
 use std::collections::HashMap as StdHashMap;
 use std::convert::TryInto;
 use std::fmt;
@@ -73,6 +78,13 @@ pub(crate) enum HTLCStatus {
 	Failed,
 }
 
+#[derive(Deserialize)]
+struct ProbeConfig {
+	probe_interval_sec: u64,
+	probe_peers: Vec<String>,
+	max_amount_msats: u64,
+}
+
 impl_writeable_tlv_based_enum!(HTLCStatus,
 	(0, Pending) => {},
 	(1, Succeeded) => {},
@@ -209,6 +221,62 @@ pub(crate) type OutputSweeper = ldk_sweep::OutputSweeper<
 // Needed due to rust-lang/rust#63033.
 struct OutputSweeperWrapper(Arc<OutputSweeper>);
 
+fn prepare_probe(
+	channel_manager: &ChannelManager, graph: &NetworkGraph, logger: &disk::FilesystemLogger,
+	scorer: &RwLock<ProbabilisticScorer<Arc<NetworkGraph>, Arc<disk::FilesystemLogger>>>,
+	pub_key_hex: &str, probe_amount: u64,
+) {
+	if probe_amount == 0 {
+ return;
+	}
+	let amt = ::rand::random::<u64>() % probe_amount;
+	let pub_key_bytes = match hex_utils::to_vec(pub_key_hex) {
+ Some(bytes) => bytes,
+ None => return,
+	};
+	if let Ok(pk) = bitcoin::secp256k1::PublicKey::from_slice(&pub_key_bytes) {
+ send_probe(channel_manager, pk, graph, logger, amt, scorer);
+	}
+}
+
+fn send_probe(
+	channel_manager: &ChannelManager, recipient: PublicKey, graph: &NetworkGraph,
+	logger: &disk::FilesystemLogger, amt_msat: u64,
+	scorer: &RwLock<ProbabilisticScorer<Arc<NetworkGraph>, Arc<disk::FilesystemLogger>>>,
+) {
+	let chans = channel_manager.list_usable_channels();
+	let chan_refs = chans.iter().map(|a| a).collect::<Vec<_>>();
+	let mut payment_params = PaymentParameters::from_node_id(recipient, 144);
+	payment_params.max_path_count = 1;
+	let in_flight_htlcs = channel_manager.compute_inflight_htlcs();
+	let scorer = scorer.read().unwrap();
+	let inflight_scorer = ScorerAccountingForInFlightHtlcs::new(&scorer, &in_flight_htlcs);
+	let score_params: ProbabilisticScoringFeeParameters = Default::default();
+	let route_res = lightning::routing::router::find_route(
+ &channel_manager.get_our_node_id(),
+ &RouteParameters::from_payment_params_and_value(payment_params, amt_msat),
+ &graph,
+ Some(&chan_refs),
+ logger,
+ &inflight_scorer,
+ &score_params,
+ &[32; 32],
+	);
+	if let Ok(route) = route_res {
+ for path in route.paths {
+ let _ = channel_manager.send_probe(path);
+ }
+	}
+}
+
+fn read_probe_file(ldk_data_dir: &str) -> Result<ProbeConfig, std::io::Error> {
+	let prober_file = format!("{}/prober_config.json", ldk_data_dir);
+	let file = fs::read_to_string(prober_file)?;
+	let config: ProbeConfig = serde_json::from_str(&file)
+ .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
+	Ok(config)
+}
+
 fn handle_ldk_events<'a>(
 	channel_manager: Arc<ChannelManager>, bitcoind_client: &'a BitcoindClient,
 	network_graph: &'a NetworkGraph, keys_manager: &'a KeysManager,
@@ -1158,6 +1226,41 @@ async fn start_ldk() {
  Arc::clone(&output_sweeper),
 	));
 
+	// Regularly probe
+	let probing_cm = Arc::clone(&channel_manager);
+	let probing_graph = Arc::clone(&network_graph);
+	let probing_logger = Arc::clone(&logger);
+	let probing_scorer = Arc::clone(&scorer);
+	match read_probe_file(&ldk_data_dir) {
+ Ok(probe_config) => {
+ if probe_config.probe_peers.is_empty() {
+ println!("WARNING: prober_config.json has no probe_peers. Probing disabled.");
+ } else {
+ let mut index = 0usize;
+ tokio::spawn(async move {
+ let mut interval =
+ tokio::time::interval(Duration::from_secs(probe_config.probe_interval_sec));
+ loop {
+ interval.tick().await;
+ if index >= probe_config.probe_peers.len() {
+ index = 0;
+ }
+ prepare_probe(
+ &*probing_cm,
+ &*probing_graph,
+ &*probing_logger,
+ &*probing_scorer,
+ &probe_config.probe_peers[index],
+ probe_config.max_amount_msats,
+ );
+ index += 1;
+ }
+ });
+ }
+ },
+ Err(_) => println!("WARNING: prober_config.json is missing. Probing disabled."),
+	};
+
 	// Start the CLI.
 	let cli_channel_manager = Arc::clone(&channel_manager);
 	let cli_chain_monitor = Arc::clone(&chain_monitor);

Cargo.toml

@@ -27,6 +27,7 @@ libc = "0.2"
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
 rand = "0.4"
 serde_json = { version = "1.0" }
+serde = { version = "1.0", features = ["derive"] }
 tokio = { version = "1", features = [ "io-util", "macros", "rt", "rt-multi-thread", "sync", "net", "time", "io-std" ] }
 
 [profile.release]

README.md

@@ -21,6 +21,19 @@ cargo run <bitcoind-rpc-username>:<bitcoind-rpc-password>@<bitcoind-rpc-host>:<b
 `announced-listen-addr` can be set to an IPv4 or IPv6 address to announce that as a publicly-connectable address for this node.
 `announced-node-name` can be any string up to 32 bytes in length, representing this node's alias.
 
+## Probe Config
+Targeted probing is disabled unless a config file exists.
+
+```
+cp ./prober_config.json.example <ldk data dir>/prober_config.json
+```
+
+`probe_peers` pubkey of peers you are probing.
+
+`probe_interval_sec` how often to probe, in seconds.
+
+`max_amount_msats` maximum amount to probe, in millisatoshis.
+
 ## License
 
 Licensed under either:

prober_config.json.example

@@ -0,0 +1,8 @@
+{
+ "probe_interval_sec" : 10,
+ "probe_peers" : [
+ "03cc91150efc4bbe8d9f8ced06fbc81ad50b076b9759139e4c2d7a8380566da7e1",
+ "037d8e050899fa0732fdd6fc1e0d5d8d685c2093932a7e10dc5e6fab8a34ed1c43"
+ ],
+ "max_amount_msats": 500000000
+}

src/main.rs

@@ -12,6 +12,7 @@ use bitcoin::blockdata::transaction::Transaction;
 use bitcoin::consensus::encode;
 use bitcoin::io;
 use bitcoin::network::Network;
+use bitcoin::secp256k1::PublicKey;
 use bitcoin::BlockHash;
 use bitcoin_bech32::WitnessProgram;
 use disk::{INBOUND_PAYMENTS_FNAME, OUTBOUND_PAYMENTS_FNAME};
@@ -33,7 +34,10 @@ use lightning::onion_message::messenger::{
 };
 use lightning::routing::gossip;
 use lightning::routing::gossip::{NodeId, P2PGossipSync};
-use lightning::routing::router::DefaultRouter;
+use lightning::routing::router::{
+	DefaultRouter, PaymentParameters, RouteParameters, ScorerAccountingForInFlightHtlcs,
+};
+use lightning::routing::scoring::ProbabilisticScorer;
 use lightning::routing::scoring::ProbabilisticScoringFeeParameters;
 use lightning::sign::{EntropySource, InMemorySigner, KeysManager, NodeSigner};
 use lightning::types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
@@ -54,6 +58,7 @@ use lightning_dns_resolver::OMDomainResolver;
 use lightning_net_tokio::SocketDescriptor;
 use lightning_persister::fs_store::FilesystemStore;
 use rand::{thread_rng, Rng};
+use serde::Deserialize;
 use std::collections::HashMap as StdHashMap;
 use std::convert::TryInto;
 use std::fmt;
@@ -73,6 +78,13 @@ pub(crate) enum HTLCStatus {
 	Failed,
 }
 
+#[derive(Deserialize)]
+struct ProbeConfig {
+	probe_interval_sec: u64,
+	probe_peers: Vec<String>,
+	max_amount_msats: u64,
+}
+
 impl_writeable_tlv_based_enum!(HTLCStatus,
 	(0, Pending) => {},
 	(1, Succeeded) => {},
@@ -209,6 +221,62 @@ pub(crate) type OutputSweeper = ldk_sweep::OutputSweeper<
 // Needed due to rust-lang/rust#63033.
 struct OutputSweeperWrapper(Arc<OutputSweeper>);
 
+fn prepare_probe(
+	channel_manager: &ChannelManager, graph: &NetworkGraph, logger: &disk::FilesystemLogger,
+	scorer: &RwLock<ProbabilisticScorer<Arc<NetworkGraph>, Arc<disk::FilesystemLogger>>>,
+	pub_key_hex: &str, probe_amount: u64,
+) {
+	if probe_amount == 0 {
+ return;
+	}
+	let amt = ::rand::random::<u64>() % probe_amount;
+	let pub_key_bytes = match hex_utils::to_vec(pub_key_hex) {
+ Some(bytes) => bytes,
+ None => return,
+	};
+	if let Ok(pk) = bitcoin::secp256k1::PublicKey::from_slice(&pub_key_bytes) {
+ send_probe(channel_manager, pk, graph, logger, amt, scorer);
+	}
+}
+
+fn send_probe(
+	channel_manager: &ChannelManager, recipient: PublicKey, graph: &NetworkGraph,
+	logger: &disk::FilesystemLogger, amt_msat: u64,
+	scorer: &RwLock<ProbabilisticScorer<Arc<NetworkGraph>, Arc<disk::FilesystemLogger>>>,
+) {
+	let chans = channel_manager.list_usable_channels();
+	let chan_refs = chans.iter().map(|a| a).collect::<Vec<_>>();
+	let mut payment_params = PaymentParameters::from_node_id(recipient, 144);
+	payment_params.max_path_count = 1;
+	let in_flight_htlcs = channel_manager.compute_inflight_htlcs();
+	let scorer = scorer.read().unwrap();
+	let inflight_scorer = ScorerAccountingForInFlightHtlcs::new(&scorer, &in_flight_htlcs);
+	let score_params: ProbabilisticScoringFeeParameters = Default::default();
+	let route_res = lightning::routing::router::find_route(
+ &channel_manager.get_our_node_id(),
+ &RouteParameters::from_payment_params_and_value(payment_params, amt_msat),
+ &graph,
+ Some(&chan_refs),
+ logger,
+ &inflight_scorer,
+ &score_params,
+ &[32; 32],
+	);
+	if let Ok(route) = route_res {
+ for path in route.paths {
+ let _ = channel_manager.send_probe(path);
+ }
+	}
+}
+
+fn read_probe_file(ldk_data_dir: &str) -> Result<ProbeConfig, std::io::Error> {
+	let prober_file = format!("{}/prober_config.json", ldk_data_dir);
+	let file = fs::read_to_string(prober_file)?;
+	let config: ProbeConfig = serde_json::from_str(&file)
+ .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
+	Ok(config)
+}
+
 fn handle_ldk_events<'a>(
 	channel_manager: Arc<ChannelManager>, bitcoind_client: &'a BitcoindClient,
 	network_graph: &'a NetworkGraph, keys_manager: &'a KeysManager,
@@ -1158,6 +1226,41 @@ async fn start_ldk() {
  Arc::clone(&output_sweeper),
 	));
 
+	// Regularly probe
+	let probing_cm = Arc::clone(&channel_manager);
+	let probing_graph = Arc::clone(&network_graph);
+	let probing_logger = Arc::clone(&logger);
+	let probing_scorer = Arc::clone(&scorer);
+	match read_probe_file(&ldk_data_dir) {
+ Ok(probe_config) => {
+ if probe_config.probe_peers.is_empty() {
+ println!("WARNING: prober_config.json has no probe_peers. Probing disabled.");
+ } else {
+ let mut index = 0usize;
+ tokio::spawn(async move {
+ let mut interval =
+ tokio::time::interval(Duration::from_secs(probe_config.probe_interval_sec));
+ loop {
+ interval.tick().await;
+ if index >= probe_config.probe_peers.len() {
+ index = 0;
+ }
+ prepare_probe(
+ &*probing_cm,
+ &*probing_graph,
+ &*probing_logger,
+ &*probing_scorer,
+ &probe_config.probe_peers[index],
+ probe_config.max_amount_msats,
+ );
+ index += 1;
+ }
+ });
+ }
+ },
+ Err(_) => println!("WARNING: prober_config.json is missing. Probing disabled."),
+	};
+
 	// Start the CLI.
 	let cli_channel_manager = Arc::clone(&channel_manager);
 	let cli_chain_monitor = Arc::clone(&chain_monitor);

Cargo.toml

@@ -27,6 +27,7 @@ libc = "0.2"
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
 rand = "0.4"
 serde_json = { version = "1.0" }
+serde = { version = "1.0", features = ["derive"] }
 tokio = { version = "1", features = [ "io-util", "macros", "rt", "rt-multi-thread", "sync", "net", "time", "io-std" ] }
 
 [profile.release]

README.md

@@ -21,6 +21,19 @@ cargo run <bitcoind-rpc-username>:<bitcoind-rpc-password>@<bitcoind-rpc-host>:<b
 `announced-listen-addr` can be set to an IPv4 or IPv6 address to announce that as a publicly-connectable address for this node.
 `announced-node-name` can be any string up to 32 bytes in length, representing this node's alias.
 
+## Probe Config
+Targeted probing is disabled unless a config file exists.
+
+```
+cp ./prober_config.json.example <ldk data dir>/prober_config.json
+```
+
+`probe_peers` pubkey of peers you are probing.
+
+`probe_interval_sec` how often to probe, in seconds.
+
+`max_amount_msats` maximum amount to probe, in millisatoshis.
+
 ## License
 
 Licensed under either:

prober_config.json.example

@@ -0,0 +1,8 @@
+{
+ "probe_interval_sec" : 10,
+ "probe_peers" : [
+ "03cc91150efc4bbe8d9f8ced06fbc81ad50b076b9759139e4c2d7a8380566da7e1",
+ "037d8e050899fa0732fdd6fc1e0d5d8d685c2093932a7e10dc5e6fab8a34ed1c43"
+ ],
+ "max_amount_msats": 500000000
+}

src/main.rs

@@ -12,6 +12,7 @@ use bitcoin::blockdata::transaction::Transaction;
 use bitcoin::consensus::encode;
 use bitcoin::io;
 use bitcoin::network::Network;
+use bitcoin::secp256k1::PublicKey;
 use bitcoin::BlockHash;
 use bitcoin_bech32::WitnessProgram;
 use disk::{INBOUND_PAYMENTS_FNAME, OUTBOUND_PAYMENTS_FNAME};
@@ -33,7 +34,10 @@ use lightning::onion_message::messenger::{
 };
 use lightning::routing::gossip;
 use lightning::routing::gossip::{NodeId, P2PGossipSync};
-use lightning::routing::router::DefaultRouter;
+use lightning::routing::router::{
+	DefaultRouter, PaymentParameters, RouteParameters, ScorerAccountingForInFlightHtlcs,
+};
+use lightning::routing::scoring::ProbabilisticScorer;
 use lightning::routing::scoring::ProbabilisticScoringFeeParameters;
 use lightning::sign::{EntropySource, InMemorySigner, KeysManager, NodeSigner};
 use lightning::types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
@@ -54,6 +58,7 @@ use lightning_dns_resolver::OMDomainResolver;
 use lightning_net_tokio::SocketDescriptor;
 use lightning_persister::fs_store::FilesystemStore;
 use rand::{thread_rng, Rng};
+use serde::Deserialize;
 use std::collections::HashMap as StdHashMap;
 use std::convert::TryInto;
 use std::fmt;
@@ -73,6 +78,13 @@ pub(crate) enum HTLCStatus {
 	Failed,
 }
 
+#[derive(Deserialize)]
+struct ProbeConfig {
+	probe_interval_sec: u64,
+	probe_peers: Vec<String>,
+	max_amount_msats: u64,
+}
+
 impl_writeable_tlv_based_enum!(HTLCStatus,
 	(0, Pending) => {},
 	(1, Succeeded) => {},
@@ -209,6 +221,62 @@ pub(crate) type OutputSweeper = ldk_sweep::OutputSweeper<
 // Needed due to rust-lang/rust#63033.
 struct OutputSweeperWrapper(Arc<OutputSweeper>);
 
+fn prepare_probe(
+	channel_manager: &ChannelManager, graph: &NetworkGraph, logger: &disk::FilesystemLogger,
+	scorer: &RwLock<ProbabilisticScorer<Arc<NetworkGraph>, Arc<disk::FilesystemLogger>>>,
+	pub_key_hex: &str, probe_amount: u64,
+) {
+	if probe_amount == 0 {
+ return;
+	}
+	let amt = ::rand::random::<u64>() % probe_amount;
+	let pub_key_bytes = match hex_utils::to_vec(pub_key_hex) {
+ Some(bytes) => bytes,
+ None => return,
+	};
+	if let Ok(pk) = bitcoin::secp256k1::PublicKey::from_slice(&pub_key_bytes) {
+ send_probe(channel_manager, pk, graph, logger, amt, scorer);
+	}
+}
+
+fn send_probe(
+	channel_manager: &ChannelManager, recipient: PublicKey, graph: &NetworkGraph,
+	logger: &disk::FilesystemLogger, amt_msat: u64,
+	scorer: &RwLock<ProbabilisticScorer<Arc<NetworkGraph>, Arc<disk::FilesystemLogger>>>,
+) {
+	let chans = channel_manager.list_usable_channels();
+	let chan_refs = chans.iter().map(|a| a).collect::<Vec<_>>();
+	let mut payment_params = PaymentParameters::from_node_id(recipient, 144);
+	payment_params.max_path_count = 1;
+	let in_flight_htlcs = channel_manager.compute_inflight_htlcs();
+	let scorer = scorer.read().unwrap();
+	let inflight_scorer = ScorerAccountingForInFlightHtlcs::new(&scorer, &in_flight_htlcs);
+	let score_params: ProbabilisticScoringFeeParameters = Default::default();
+	let route_res = lightning::routing::router::find_route(
+ &channel_manager.get_our_node_id(),
+ &RouteParameters::from_payment_params_and_value(payment_params, amt_msat),
+ &graph,
+ Some(&chan_refs),
+ logger,
+ &inflight_scorer,
+ &score_params,
+ &[32; 32],
+	);
+	if let Ok(route) = route_res {
+ for path in route.paths {
+ let _ = channel_manager.send_probe(path);
+ }
+	}
+}
+
+fn read_probe_file(ldk_data_dir: &str) -> Result<ProbeConfig, std::io::Error> {
+	let prober_file = format!("{}/prober_config.json", ldk_data_dir);
+	let file = fs::read_to_string(prober_file)?;
+	let config: ProbeConfig = serde_json::from_str(&file)
+ .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
+	Ok(config)
+}
+
 fn handle_ldk_events<'a>(
 	channel_manager: Arc<ChannelManager>, bitcoind_client: &'a BitcoindClient,
 	network_graph: &'a NetworkGraph, keys_manager: &'a KeysManager,
@@ -1158,6 +1226,41 @@ async fn start_ldk() {
  Arc::clone(&output_sweeper),
 	));
 
+	// Regularly probe
+	let probing_cm = Arc::clone(&channel_manager);
+	let probing_graph = Arc::clone(&network_graph);
+	let probing_logger = Arc::clone(&logger);
+	let probing_scorer = Arc::clone(&scorer);
+	match read_probe_file(&ldk_data_dir) {
+ Ok(probe_config) => {
+ if probe_config.probe_peers.is_empty() {
+ println!("WARNING: prober_config.json has no probe_peers. Probing disabled.");
+ } else {
+ let mut index = 0usize;
+ tokio::spawn(async move {
+ let mut interval =
+ tokio::time::interval(Duration::from_secs(probe_config.probe_interval_sec));
+ loop {
+ interval.tick().await;
+ if index >= probe_config.probe_peers.len() {
+ index = 0;
+ }
+ prepare_probe(
+ &*probing_cm,
+ &*probing_graph,
+ &*probing_logger,
+ &*probing_scorer,
+ &probe_config.probe_peers[index],
+ probe_config.max_amount_msats,
+ );
+ index += 1;
+ }
+ });
+ }
+ },
+ Err(_) => println!("WARNING: prober_config.json is missing. Probing disabled."),
+	};
+
 	// Start the CLI.
 	let cli_channel_manager = Arc::clone(&channel_manager);
 	let cli_chain_monitor = Arc::clone(&chain_monitor);

Cargo.toml

@@ -27,6 +27,7 @@ libc = "0.2"
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
 rand = "0.4"
 serde_json = { version = "1.0" }
+serde = { version = "1.0", features = ["derive"] }
 tokio = { version = "1", features = [ "io-util", "macros", "rt", "rt-multi-thread", "sync", "net", "time", "io-std" ] }
 
 [profile.release]

README.md

@@ -21,6 +21,19 @@ cargo run <bitcoind-rpc-username>:<bitcoind-rpc-password>@<bitcoind-rpc-host>:<b
 `announced-listen-addr` can be set to an IPv4 or IPv6 address to announce that as a publicly-connectable address for this node.
 `announced-node-name` can be any string up to 32 bytes in length, representing this node's alias.
 
+## Probe Config
+Targeted probing is disabled unless a config file exists.
+
+```
+cp ./prober_config.json.example <ldk data dir>/prober_config.json
+```
+
+`probe_peers` pubkey of peers you are probing.
+
+`probe_interval_sec` how often to probe, in seconds.
+
+`max_amount_msats` maximum amount to probe, in millisatoshis.
+
 ## License
 
 Licensed under either:

prober_config.json.example

@@ -0,0 +1,8 @@
+{
+ "probe_interval_sec" : 10,
+ "probe_peers" : [
+ "03cc91150efc4bbe8d9f8ced06fbc81ad50b076b9759139e4c2d7a8380566da7e1",
+ "037d8e050899fa0732fdd6fc1e0d5d8d685c2093932a7e10dc5e6fab8a34ed1c43"
+ ],
+ "max_amount_msats": 500000000
+}

src/main.rs

@@ -12,6 +12,7 @@ use bitcoin::blockdata::transaction::Transaction;
 use bitcoin::consensus::encode;
 use bitcoin::io;
 use bitcoin::network::Network;
+use bitcoin::secp256k1::PublicKey;
 use bitcoin::BlockHash;
 use bitcoin_bech32::WitnessProgram;
 use disk::{INBOUND_PAYMENTS_FNAME, OUTBOUND_PAYMENTS_FNAME};
@@ -33,7 +34,10 @@ use lightning::onion_message::messenger::{
 };
 use lightning::routing::gossip;
 use lightning::routing::gossip::{NodeId, P2PGossipSync};
-use lightning::routing::router::DefaultRouter;
+use lightning::routing::router::{
+	DefaultRouter, PaymentParameters, RouteParameters, ScorerAccountingForInFlightHtlcs,
+};
+use lightning::routing::scoring::ProbabilisticScorer;
 use lightning::routing::scoring::ProbabilisticScoringFeeParameters;
 use lightning::sign::{EntropySource, InMemorySigner, KeysManager, NodeSigner};
 use lightning::types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
@@ -54,6 +58,7 @@ use lightning_dns_resolver::OMDomainResolver;
 use lightning_net_tokio::SocketDescriptor;
 use lightning_persister::fs_store::FilesystemStore;
 use rand::{thread_rng, Rng};
+use serde::Deserialize;
 use std::collections::HashMap as StdHashMap;
 use std::convert::TryInto;
 use std::fmt;
@@ -73,6 +78,13 @@ pub(crate) enum HTLCStatus {
 	Failed,
 }
 
+#[derive(Deserialize)]
+struct ProbeConfig {
+	probe_interval_sec: u64,
+	probe_peers: Vec<String>,
+	max_amount_msats: u64,
+}
+
 impl_writeable_tlv_based_enum!(HTLCStatus,
 	(0, Pending) => {},
 	(1, Succeeded) => {},
@@ -209,6 +221,62 @@ pub(crate) type OutputSweeper = ldk_sweep::OutputSweeper<
 // Needed due to rust-lang/rust#63033.
 struct OutputSweeperWrapper(Arc<OutputSweeper>);
 
+fn prepare_probe(
+	channel_manager: &ChannelManager, graph: &NetworkGraph, logger: &disk::FilesystemLogger,
+	scorer: &RwLock<ProbabilisticScorer<Arc<NetworkGraph>, Arc<disk::FilesystemLogger>>>,
+	pub_key_hex: &str, probe_amount: u64,
+) {
+	if probe_amount == 0 {
+ return;
+	}
+	let amt = ::rand::random::<u64>() % probe_amount;
+	let pub_key_bytes = match hex_utils::to_vec(pub_key_hex) {
+ Some(bytes) => bytes,
+ None => return,
+	};
+	if let Ok(pk) = bitcoin::secp256k1::PublicKey::from_slice(&pub_key_bytes) {
+ send_probe(channel_manager, pk, graph, logger, amt, scorer);
+	}
+}
+
+fn send_probe(
+	channel_manager: &ChannelManager, recipient: PublicKey, graph: &NetworkGraph,
+	logger: &disk::FilesystemLogger, amt_msat: u64,
+	scorer: &RwLock<ProbabilisticScorer<Arc<NetworkGraph>, Arc<disk::FilesystemLogger>>>,
+) {
+	let chans = channel_manager.list_usable_channels();
+	let chan_refs = chans.iter().map(|a| a).collect::<Vec<_>>();
+	let mut payment_params = PaymentParameters::from_node_id(recipient, 144);
+	payment_params.max_path_count = 1;
+	let in_flight_htlcs = channel_manager.compute_inflight_htlcs();
+	let scorer = scorer.read().unwrap();
+	let inflight_scorer = ScorerAccountingForInFlightHtlcs::new(&scorer, &in_flight_htlcs);
+	let score_params: ProbabilisticScoringFeeParameters = Default::default();
+	let route_res = lightning::routing::router::find_route(
+ &channel_manager.get_our_node_id(),
+ &RouteParameters::from_payment_params_and_value(payment_params, amt_msat),
+ &graph,
+ Some(&chan_refs),
+ logger,
+ &inflight_scorer,
+ &score_params,
+ &[32; 32],
+	);
+	if let Ok(route) = route_res {
+ for path in route.paths {
+ let _ = channel_manager.send_probe(path);
+ }
+	}
+}
+
+fn read_probe_file(ldk_data_dir: &str) -> Result<ProbeConfig, std::io::Error> {
+	let prober_file = format!("{}/prober_config.json", ldk_data_dir);
+	let file = fs::read_to_string(prober_file)?;
+	let config: ProbeConfig = serde_json::from_str(&file)
+ .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
+	Ok(config)
+}
+
 fn handle_ldk_events<'a>(
 	channel_manager: Arc<ChannelManager>, bitcoind_client: &'a BitcoindClient,
 	network_graph: &'a NetworkGraph, keys_manager: &'a KeysManager,
@@ -1158,6 +1226,41 @@ async fn start_ldk() {
  Arc::clone(&output_sweeper),
 	));
 
+	// Regularly probe
+	let probing_cm = Arc::clone(&channel_manager);
+	let probing_graph = Arc::clone(&network_graph);
+	let probing_logger = Arc::clone(&logger);
+	let probing_scorer = Arc::clone(&scorer);
+	match read_probe_file(&ldk_data_dir) {
+ Ok(probe_config) => {
+ if probe_config.probe_peers.is_empty() {
+ println!("WARNING: prober_config.json has no probe_peers. Probing disabled.");
+ } else {
+ let mut index = 0usize;
+ tokio::spawn(async move {
+ let mut interval =
+ tokio::time::interval(Duration::from_secs(probe_config.probe_interval_sec));
+ loop {
+ interval.tick().await;
+ if index >= probe_config.probe_peers.len() {
+ index = 0;
+ }
+ prepare_probe(
+ &*probing_cm,
+ &*probing_graph,
+ &*probing_logger,
+ &*probing_scorer,
+ &probe_config.probe_peers[index],
+ probe_config.max_amount_msats,
+ );
+ index += 1;
+ }
+ });
+ }
+ },
+ Err(_) => println!("WARNING: prober_config.json is missing. Probing disabled."),
+	};
+
 	// Start the CLI.
 	let cli_channel_manager = Arc::clone(&channel_manager);
 	let cli_chain_monitor = Arc::clone(&chain_monitor);

Cargo.toml

@@ -27,6 +27,7 @@ libc = "0.2"
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
 rand = "0.4"
 serde_json = { version = "1.0" }
+serde = { version = "1.0", features = ["derive"] }
 tokio = { version = "1", features = [ "io-util", "macros", "rt", "rt-multi-thread", "sync", "net", "time", "io-std" ] }
 
 [profile.release]

README.md

@@ -21,6 +21,19 @@ cargo run <bitcoind-rpc-username>:<bitcoind-rpc-password>@<bitcoind-rpc-host>:<b
 `announced-listen-addr` can be set to an IPv4 or IPv6 address to announce that as a publicly-connectable address for this node.
 `announced-node-name` can be any string up to 32 bytes in length, representing this node's alias.
 
+## Probe Config
+Targeted probing is disabled unless a config file exists.
+
+```
+cp ./prober_config.json.example <ldk data dir>/prober_config.json
+```
+
+`probe_peers` pubkey of peers you are probing.
+
+`probe_interval_sec` how often to probe, in seconds.
+
+`max_amount_msats` maximum amount to probe, in millisatoshis.
+
 ## License
 
 Licensed under either:

prober_config.json.example

@@ -0,0 +1,8 @@
+{
+ "probe_interval_sec" : 10,
+ "probe_peers" : [
+ "03cc91150efc4bbe8d9f8ced06fbc81ad50b076b9759139e4c2d7a8380566da7e1",
+ "037d8e050899fa0732fdd6fc1e0d5d8d685c2093932a7e10dc5e6fab8a34ed1c43"
+ ],
+ "max_amount_msats": 500000000
+}

src/main.rs

@@ -12,6 +12,7 @@ use bitcoin::blockdata::transaction::Transaction;
 use bitcoin::consensus::encode;
 use bitcoin::io;
 use bitcoin::network::Network;
+use bitcoin::secp256k1::PublicKey;
 use bitcoin::BlockHash;
 use bitcoin_bech32::WitnessProgram;
 use disk::{INBOUND_PAYMENTS_FNAME, OUTBOUND_PAYMENTS_FNAME};
@@ -33,7 +34,10 @@ use lightning::onion_message::messenger::{
 };
 use lightning::routing::gossip;
 use lightning::routing::gossip::{NodeId, P2PGossipSync};
-use lightning::routing::router::DefaultRouter;
+use lightning::routing::router::{
+	DefaultRouter, PaymentParameters, RouteParameters, ScorerAccountingForInFlightHtlcs,
+};
+use lightning::routing::scoring::ProbabilisticScorer;
 use lightning::routing::scoring::ProbabilisticScoringFeeParameters;
 use lightning::sign::{EntropySource, InMemorySigner, KeysManager, NodeSigner};
 use lightning::types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
@@ -54,6 +58,7 @@ use lightning_dns_resolver::OMDomainResolver;
 use lightning_net_tokio::SocketDescriptor;
 use lightning_persister::fs_store::FilesystemStore;
 use rand::{thread_rng, Rng};
+use serde::Deserialize;
 use std::collections::HashMap as StdHashMap;
 use std::convert::TryInto;
 use std::fmt;
@@ -73,6 +78,13 @@ pub(crate) enum HTLCStatus {
 	Failed,
 }
 
+#[derive(Deserialize)]
+struct ProbeConfig {
+	probe_interval_sec: u64,
+	probe_peers: Vec<String>,
+	max_amount_msats: u64,
+}
+
 impl_writeable_tlv_based_enum!(HTLCStatus,
 	(0, Pending) => {},
 	(1, Succeeded) => {},
@@ -209,6 +221,62 @@ pub(crate) type OutputSweeper = ldk_sweep::OutputSweeper<
 // Needed due to rust-lang/rust#63033.
 struct OutputSweeperWrapper(Arc<OutputSweeper>);
 
+fn prepare_probe(
+	channel_manager: &ChannelManager, graph: &NetworkGraph, logger: &disk::FilesystemLogger,
+	scorer: &RwLock<ProbabilisticScorer<Arc<NetworkGraph>, Arc<disk::FilesystemLogger>>>,
+	pub_key_hex: &str, probe_amount: u64,
+) {
+	if probe_amount == 0 {
+ return;
+	}
+	let amt = ::rand::random::<u64>() % probe_amount;
+	let pub_key_bytes = match hex_utils::to_vec(pub_key_hex) {
+ Some(bytes) => bytes,
+ None => return,
+	};
+	if let Ok(pk) = bitcoin::secp256k1::PublicKey::from_slice(&pub_key_bytes) {
+ send_probe(channel_manager, pk, graph, logger, amt, scorer);
+	}
+}
+
+fn send_probe(
+	channel_manager: &ChannelManager, recipient: PublicKey, graph: &NetworkGraph,
+	logger: &disk::FilesystemLogger, amt_msat: u64,
+	scorer: &RwLock<ProbabilisticScorer<Arc<NetworkGraph>, Arc<disk::FilesystemLogger>>>,
+) {
+	let chans = channel_manager.list_usable_channels();
+	let chan_refs = chans.iter().map(|a| a).collect::<Vec<_>>();
+	let mut payment_params = PaymentParameters::from_node_id(recipient, 144);
+	payment_params.max_path_count = 1;
+	let in_flight_htlcs = channel_manager.compute_inflight_htlcs();
+	let scorer = scorer.read().unwrap();
+	let inflight_scorer = ScorerAccountingForInFlightHtlcs::new(&scorer, &in_flight_htlcs);
+	let score_params: ProbabilisticScoringFeeParameters = Default::default();
+	let route_res = lightning::routing::router::find_route(
+ &channel_manager.get_our_node_id(),
+ &RouteParameters::from_payment_params_and_value(payment_params, amt_msat),
+ &graph,
+ Some(&chan_refs),
+ logger,
+ &inflight_scorer,
+ &score_params,
+ &[32; 32],
+	);
+	if let Ok(route) = route_res {
+ for path in route.paths {
+ let _ = channel_manager.send_probe(path);
+ }
+	}
+}
+
+fn read_probe_file(ldk_data_dir: &str) -> Result<ProbeConfig, std::io::Error> {
+	let prober_file = format!("{}/prober_config.json", ldk_data_dir);
+	let file = fs::read_to_string(prober_file)?;
+	let config: ProbeConfig = serde_json::from_str(&file)
+ .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
+	Ok(config)
+}
+
 fn handle_ldk_events<'a>(
 	channel_manager: Arc<ChannelManager>, bitcoind_client: &'a BitcoindClient,
 	network_graph: &'a NetworkGraph, keys_manager: &'a KeysManager,
@@ -1158,6 +1226,41 @@ async fn start_ldk() {
  Arc::clone(&output_sweeper),
 	));
 
+	// Regularly probe
+	let probing_cm = Arc::clone(&channel_manager);
+	let probing_graph = Arc::clone(&network_graph);
+	let probing_logger = Arc::clone(&logger);
+	let probing_scorer = Arc::clone(&scorer);
+	match read_probe_file(&ldk_data_dir) {
+ Ok(probe_config) => {
+ if probe_config.probe_peers.is_empty() {
+ println!("WARNING: prober_config.json has no probe_peers. Probing disabled.");
+ } else {
+ let mut index = 0usize;
+ tokio::spawn(async move {
+ let mut interval =
+ tokio::time::interval(Duration::from_secs(probe_config.probe_interval_sec));
+ loop {
+ interval.tick().await;
+ if index >= probe_config.probe_peers.len() {
+ index = 0;
+ }
+ prepare_probe(
+ &*probing_cm,
+ &*probing_graph,
+ &*probing_logger,
+ &*probing_scorer,
+ &probe_config.probe_peers[index],
+ probe_config.max_amount_msats,
+ );
+ index += 1;
+ }
+ });
+ }
+ },
+ Err(_) => println!("WARNING: prober_config.json is missing. Probing disabled."),
+	};
+
 	// Start the CLI.
 	let cli_channel_manager = Arc::clone(&channel_manager);
 	let cli_chain_monitor = Arc::clone(&chain_monitor);

Cargo.toml

@@ -27,6 +27,7 @@ libc = "0.2"
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
 rand = "0.4"
 serde_json = { version = "1.0" }
+serde = { version = "1.0", features = ["derive"] }
 tokio = { version = "1", features = [ "io-util", "macros", "rt", "rt-multi-thread", "sync", "net", "time", "io-std" ] }
 
 [profile.release]

README.md

@@ -21,6 +21,19 @@ cargo run <bitcoind-rpc-username>:<bitcoind-rpc-password>@<bitcoind-rpc-host>:<b
 `announced-listen-addr` can be set to an IPv4 or IPv6 address to announce that as a publicly-connectable address for this node.
 `announced-node-name` can be any string up to 32 bytes in length, representing this node's alias.
 
+## Probe Config
+Targeted probing is disabled unless a config file exists.
+
+```
+cp ./prober_config.json.example <ldk data dir>/prober_config.json
+```
+
+`probe_peers` pubkey of peers you are probing.
+
+`probe_interval_sec` how often to probe, in seconds.
+
+`max_amount_msats` maximum amount to probe, in millisatoshis.
+
 ## License
 
 Licensed under either:

prober_config.json.example

@@ -0,0 +1,8 @@
+{
+ "probe_interval_sec" : 10,
+ "probe_peers" : [
+ "03cc91150efc4bbe8d9f8ced06fbc81ad50b076b9759139e4c2d7a8380566da7e1",
+ "037d8e050899fa0732fdd6fc1e0d5d8d685c2093932a7e10dc5e6fab8a34ed1c43"
+ ],
+ "max_amount_msats": 500000000
+}

src/main.rs

@@ -12,6 +12,7 @@ use bitcoin::blockdata::transaction::Transaction;
 use bitcoin::consensus::encode;
 use bitcoin::io;
 use bitcoin::network::Network;
+use bitcoin::secp256k1::PublicKey;
 use bitcoin::BlockHash;
 use bitcoin_bech32::WitnessProgram;
 use disk::{INBOUND_PAYMENTS_FNAME, OUTBOUND_PAYMENTS_FNAME};
@@ -33,7 +34,10 @@ use lightning::onion_message::messenger::{
 };
 use lightning::routing::gossip;
 use lightning::routing::gossip::{NodeId, P2PGossipSync};
-use lightning::routing::router::DefaultRouter;
+use lightning::routing::router::{
+	DefaultRouter, PaymentParameters, RouteParameters, ScorerAccountingForInFlightHtlcs,
+};
+use lightning::routing::scoring::ProbabilisticScorer;
 use lightning::routing::scoring::ProbabilisticScoringFeeParameters;
 use lightning::sign::{EntropySource, InMemorySigner, KeysManager, NodeSigner};
 use lightning::types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
@@ -54,6 +58,7 @@ use lightning_dns_resolver::OMDomainResolver;
 use lightning_net_tokio::SocketDescriptor;
 use lightning_persister::fs_store::FilesystemStore;
 use rand::{thread_rng, Rng};
+use serde::Deserialize;
 use std::collections::HashMap as StdHashMap;
 use std::convert::TryInto;
 use std::fmt;
@@ -73,6 +78,13 @@ pub(crate) enum HTLCStatus {
 	Failed,
 }
 
+#[derive(Deserialize)]
+struct ProbeConfig {
+	probe_interval_sec: u64,
+	probe_peers: Vec<String>,
+	max_amount_msats: u64,
+}
+
 impl_writeable_tlv_based_enum!(HTLCStatus,
 	(0, Pending) => {},
 	(1, Succeeded) => {},
@@ -209,6 +221,62 @@ pub(crate) type OutputSweeper = ldk_sweep::OutputSweeper<
 // Needed due to rust-lang/rust#63033.
 struct OutputSweeperWrapper(Arc<OutputSweeper>);
 
+fn prepare_probe(
+	channel_manager: &ChannelManager, graph: &NetworkGraph, logger: &disk::FilesystemLogger,
+	scorer: &RwLock<ProbabilisticScorer<Arc<NetworkGraph>, Arc<disk::FilesystemLogger>>>,
+	pub_key_hex: &str, probe_amount: u64,
+) {
+	if probe_amount == 0 {
+ return;
+	}
+	let amt = ::rand::random::<u64>() % probe_amount;
+	let pub_key_bytes = match hex_utils::to_vec(pub_key_hex) {
+ Some(bytes) => bytes,
+ None => return,
+	};
+	if let Ok(pk) = bitcoin::secp256k1::PublicKey::from_slice(&pub_key_bytes) {
+ send_probe(channel_manager, pk, graph, logger, amt, scorer);
+	}
+}
+
+fn send_probe(
+	channel_manager: &ChannelManager, recipient: PublicKey, graph: &NetworkGraph,
+	logger: &disk::FilesystemLogger, amt_msat: u64,
+	scorer: &RwLock<ProbabilisticScorer<Arc<NetworkGraph>, Arc<disk::FilesystemLogger>>>,
+) {
+	let chans = channel_manager.list_usable_channels();
+	let chan_refs = chans.iter().map(|a| a).collect::<Vec<_>>();
+	let mut payment_params = PaymentParameters::from_node_id(recipient, 144);
+	payment_params.max_path_count = 1;
+	let in_flight_htlcs = channel_manager.compute_inflight_htlcs();
+	let scorer = scorer.read().unwrap();
+	let inflight_scorer = ScorerAccountingForInFlightHtlcs::new(&scorer, &in_flight_htlcs);
+	let score_params: ProbabilisticScoringFeeParameters = Default::default();
+	let route_res = lightning::routing::router::find_route(
+ &channel_manager.get_our_node_id(),
+ &RouteParameters::from_payment_params_and_value(payment_params, amt_msat),
+ &graph,
+ Some(&chan_refs),
+ logger,
+ &inflight_scorer,
+ &score_params,
+ &[32; 32],
+	);
+	if let Ok(route) = route_res {
+ for path in route.paths {
+ let _ = channel_manager.send_probe(path);
+ }
+	}
+}
+
+fn read_probe_file(ldk_data_dir: &str) -> Result<ProbeConfig, std::io::Error> {
+	let prober_file = format!("{}/prober_config.json", ldk_data_dir);
+	let file = fs::read_to_string(prober_file)?;
+	let config: ProbeConfig = serde_json::from_str(&file)
+ .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
+	Ok(config)
+}
+
 fn handle_ldk_events<'a>(
 	channel_manager: Arc<ChannelManager>, bitcoind_client: &'a BitcoindClient,
 	network_graph: &'a NetworkGraph, keys_manager: &'a KeysManager,
@@ -1158,6 +1226,41 @@ async fn start_ldk() {
  Arc::clone(&output_sweeper),
 	));
 
+	// Regularly probe
+	let probing_cm = Arc::clone(&channel_manager);
+	let probing_graph = Arc::clone(&network_graph);
+	let probing_logger = Arc::clone(&logger);
+	let probing_scorer = Arc::clone(&scorer);
+	match read_probe_file(&ldk_data_dir) {
+ Ok(probe_config) => {
+ if probe_config.probe_peers.is_empty() {
+ println!("WARNING: prober_config.json has no probe_peers. Probing disabled.");
+ } else {
+ let mut index = 0usize;
+ tokio::spawn(async move {
+ let mut interval =
+ tokio::time::interval(Duration::from_secs(probe_config.probe_interval_sec));
+ loop {
+ interval.tick().await;
+ if index >= probe_config.probe_peers.len() {
+ index = 0;
+ }
+ prepare_probe(
+ &*probing_cm,
+ &*probing_graph,
+ &*probing_logger,
+ &*probing_scorer,
+ &probe_config.probe_peers[index],
+ probe_config.max_amount_msats,
+ );
+ index += 1;
+ }
+ });
+ }
+ },
+ Err(_) => println!("WARNING: prober_config.json is missing. Probing disabled."),
+	};
+
 	// Start the CLI.
 	let cli_channel_manager = Arc::clone(&channel_manager);
 	let cli_chain_monitor = Arc::clone(&chain_monitor);

Cargo.toml

@@ -27,6 +27,7 @@ libc = "0.2"
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
 rand = "0.4"
 serde_json = { version = "1.0" }
+serde = { version = "1.0", features = ["derive"] }
 tokio = { version = "1", features = [ "io-util", "macros", "rt", "rt-multi-thread", "sync", "net", "time", "io-std" ] }
 
 [profile.release]

README.md

@@ -21,6 +21,19 @@ cargo run <bitcoind-rpc-username>:<bitcoind-rpc-password>@<bitcoind-rpc-host>:<b
 `announced-listen-addr` can be set to an IPv4 or IPv6 address to announce that as a publicly-connectable address for this node.
 `announced-node-name` can be any string up to 32 bytes in length, representing this node's alias.
 
+## Probe Config
+Targeted probing is disabled unless a config file exists.
+
+```
+cp ./prober_config.json.example <ldk data dir>/prober_config.json
+```
+
+`probe_peers` pubkey of peers you are probing.
+
+`probe_interval_sec` how often to probe, in seconds.
+
+`max_amount_msats` maximum amount to probe, in millisatoshis.
+
 ## License
 
 Licensed under either:

prober_config.json.example

@@ -0,0 +1,8 @@
+{
+ "probe_interval_sec" : 10,
+ "probe_peers" : [
+ "03cc91150efc4bbe8d9f8ced06fbc81ad50b076b9759139e4c2d7a8380566da7e1",
+ "037d8e050899fa0732fdd6fc1e0d5d8d685c2093932a7e10dc5e6fab8a34ed1c43"
+ ],
+ "max_amount_msats": 500000000
+}

src/main.rs

@@ -12,6 +12,7 @@ use bitcoin::blockdata::transaction::Transaction;
 use bitcoin::consensus::encode;
 use bitcoin::io;
 use bitcoin::network::Network;
+use bitcoin::secp256k1::PublicKey;
 use bitcoin::BlockHash;
 use bitcoin_bech32::WitnessProgram;
 use disk::{INBOUND_PAYMENTS_FNAME, OUTBOUND_PAYMENTS_FNAME};
@@ -33,7 +34,10 @@ use lightning::onion_message::messenger::{
 };
 use lightning::routing::gossip;
 use lightning::routing::gossip::{NodeId, P2PGossipSync};
-use lightning::routing::router::DefaultRouter;
+use lightning::routing::router::{
+	DefaultRouter, PaymentParameters, RouteParameters, ScorerAccountingForInFlightHtlcs,
+};
+use lightning::routing::scoring::ProbabilisticScorer;
 use lightning::routing::scoring::ProbabilisticScoringFeeParameters;
 use lightning::sign::{EntropySource, InMemorySigner, KeysManager, NodeSigner};
 use lightning::types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
@@ -54,6 +58,7 @@ use lightning_dns_resolver::OMDomainResolver;
 use lightning_net_tokio::SocketDescriptor;
 use lightning_persister::fs_store::FilesystemStore;
 use rand::{thread_rng, Rng};
+use serde::Deserialize;
 use std::collections::HashMap as StdHashMap;
 use std::convert::TryInto;
 use std::fmt;
@@ -73,6 +78,13 @@ pub(crate) enum HTLCStatus {
 	Failed,
 }
 
+#[derive(Deserialize)]
+struct ProbeConfig {
+	probe_interval_sec: u64,
+	probe_peers: Vec<String>,
+	max_amount_msats: u64,
+}
+
 impl_writeable_tlv_based_enum!(HTLCStatus,
 	(0, Pending) => {},
 	(1, Succeeded) => {},
@@ -209,6 +221,62 @@ pub(crate) type OutputSweeper = ldk_sweep::OutputSweeper<
 // Needed due to rust-lang/rust#63033.
 struct OutputSweeperWrapper(Arc<OutputSweeper>);
 
+fn prepare_probe(
+	channel_manager: &ChannelManager, graph: &NetworkGraph, logger: &disk::FilesystemLogger,
+	scorer: &RwLock<ProbabilisticScorer<Arc<NetworkGraph>, Arc<disk::FilesystemLogger>>>,
+	pub_key_hex: &str, probe_amount: u64,
+) {
+	if probe_amount == 0 {
+ return;
+	}
+	let amt = ::rand::random::<u64>() % probe_amount;
+	let pub_key_bytes = match hex_utils::to_vec(pub_key_hex) {
+ Some(bytes) => bytes,
+ None => return,
+	};
+	if let Ok(pk) = bitcoin::secp256k1::PublicKey::from_slice(&pub_key_bytes) {
+ send_probe(channel_manager, pk, graph, logger, amt, scorer);
+	}
+}
+
+fn send_probe(
+	channel_manager: &ChannelManager, recipient: PublicKey, graph: &NetworkGraph,
+	logger: &disk::FilesystemLogger, amt_msat: u64,
+	scorer: &RwLock<ProbabilisticScorer<Arc<NetworkGraph>, Arc<disk::FilesystemLogger>>>,
+) {
+	let chans = channel_manager.list_usable_channels();
+	let chan_refs = chans.iter().map(|a| a).collect::<Vec<_>>();
+	let mut payment_params = PaymentParameters::from_node_id(recipient, 144);
+	payment_params.max_path_count = 1;
+	let in_flight_htlcs = channel_manager.compute_inflight_htlcs();
+	let scorer = scorer.read().unwrap();
+	let inflight_scorer = ScorerAccountingForInFlightHtlcs::new(&scorer, &in_flight_htlcs);
+	let score_params: ProbabilisticScoringFeeParameters = Default::default();
+	let route_res = lightning::routing::router::find_route(
+ &channel_manager.get_our_node_id(),
+ &RouteParameters::from_payment_params_and_value(payment_params, amt_msat),
+ &graph,
+ Some(&chan_refs),
+ logger,
+ &inflight_scorer,
+ &score_params,
+ &[32; 32],
+	);
+	if let Ok(route) = route_res {
+ for path in route.paths {
+ let _ = channel_manager.send_probe(path);
+ }
+	}
+}
+
+fn read_probe_file(ldk_data_dir: &str) -> Result<ProbeConfig, std::io::Error> {
+	let prober_file = format!("{}/prober_config.json", ldk_data_dir);
+	let file = fs::read_to_string(prober_file)?;
+	let config: ProbeConfig = serde_json::from_str(&file)
+ .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
+	Ok(config)
+}
+
 fn handle_ldk_events<'a>(
 	channel_manager: Arc<ChannelManager>, bitcoind_client: &'a BitcoindClient,
 	network_graph: &'a NetworkGraph, keys_manager: &'a KeysManager,
@@ -1158,6 +1226,41 @@ async fn start_ldk() {
  Arc::clone(&output_sweeper),
 	));
 
+	// Regularly probe
+	let probing_cm = Arc::clone(&channel_manager);
+	let probing_graph = Arc::clone(&network_graph);
+	let probing_logger = Arc::clone(&logger);
+	let probing_scorer = Arc::clone(&scorer);
+	match read_probe_file(&ldk_data_dir) {
+ Ok(probe_config) => {
+ if probe_config.probe_peers.is_empty() {
+ println!("WARNING: prober_config.json has no probe_peers. Probing disabled.");
+ } else {
+ let mut index = 0usize;
+ tokio::spawn(async move {
+ let mut interval =
+ tokio::time::interval(Duration::from_secs(probe_config.probe_interval_sec));
+ loop {
+ interval.tick().await;
+ if index >= probe_config.probe_peers.len() {
+ index = 0;
+ }
+ prepare_probe(
+ &*probing_cm,
+ &*probing_graph,
+ &*probing_logger,
+ &*probing_scorer,
+ &probe_config.probe_peers[index],
+ probe_config.max_amount_msats,
+ );
+ index += 1;
+ }
+ });
+ }
+ },
+ Err(_) => println!("WARNING: prober_config.json is missing. Probing disabled."),
+	};
+
 	// Start the CLI.
 	let cli_channel_manager = Arc::clone(&channel_manager);
 	let cli_chain_monitor = Arc::clone(&chain_monitor);