ChannelManager, FilesystemLogger, HTLCStatus, MillisatAmount, PaymentInfo, PaymentInfoStorage,
PeerManager,
};
+use bitcoin::hashes::Hash;
use bitcoin::network::constants::Network;
use bitcoin::secp256k1::key::PublicKey;
use lightning::chain;
use lightning::routing::network_graph::NetGraphMsgHandler;
use lightning::routing::router;
use lightning::routing::router::RouteHint;
-use lightning::util::config::UserConfig;
+use lightning::util::config::{ChannelConfig, ChannelHandshakeLimits, UserConfig};
use lightning_invoice::{utils, Currency, Invoice};
use std::env;
use std::io;
pub(crate) bitcoind_rpc_host: String,
pub(crate) ldk_storage_dir_path: String,
pub(crate) ldk_peer_listening_port: u16,
- pub(crate) ldk_announced_listen_addr: Option<NetAddress>,
+ pub(crate) ldk_announced_listen_addr: Vec<NetAddress>,
pub(crate) ldk_announced_node_name: [u8; 32],
pub(crate) network: Network,
}
pub(crate) fn parse_startup_args() -> Result<LdkUserInfo, ()> {
if env::args().len() < 3 {
- println!("ldk-tutorial-node requires 3 arguments: `cargo run <bitcoind-rpc-username>:<bitcoind-rpc-password>@<bitcoind-rpc-host>:<bitcoind-rpc-port> ldk_storage_directory_path [<ldk-incoming-peer-listening-port>] [bitcoin-network] [announced-listen-addr announced-node-name]`");
+ println!("ldk-tutorial-node requires 3 arguments: `cargo run <bitcoind-rpc-username>:<bitcoind-rpc-password>@<bitcoind-rpc-host>:<bitcoind-rpc-port> ldk_storage_directory_path [<ldk-incoming-peer-listening-port>] [bitcoin-network] [announced-node-name announced-listen-addr*]`");
return Err(());
}
let bitcoind_rpc_info = env::args().skip(1).next().unwrap();
}
};
- let arg_idx = match ldk_peer_port_set {
+ let mut arg_idx = match ldk_peer_port_set {
true => 4,
false => 3,
};
None => Network::Testnet,
};
- let ldk_announced_listen_addr = match env::args().skip(arg_idx + 1).next().as_ref() {
- Some(s) => match IpAddr::from_str(s) {
- Ok(IpAddr::V4(a)) => {
- Some(NetAddress::IPv4 { addr: a.octets(), port: ldk_peer_listening_port })
- }
- Ok(IpAddr::V6(a)) => {
- Some(NetAddress::IPv6 { addr: a.octets(), port: ldk_peer_listening_port })
- }
- Err(_) => panic!("Failed to parse announced-listen-addr into an IP address"),
- },
- None => None,
- };
-
- let ldk_announced_node_name = match env::args().skip(arg_idx + 2).next().as_ref() {
+ let ldk_announced_node_name = match env::args().skip(arg_idx + 1).next().as_ref() {
Some(s) => {
if s.len() > 32 {
panic!("Node Alias can not be longer than 32 bytes");
}
+ arg_idx += 1;
let mut bytes = [0; 32];
bytes[..s.len()].copy_from_slice(s.as_bytes());
bytes
None => [0; 32],
};
+ let mut ldk_announced_listen_addr = Vec::new();
+ loop {
+ match env::args().skip(arg_idx + 1).next().as_ref() {
+ Some(s) => match IpAddr::from_str(s) {
+ Ok(IpAddr::V4(a)) => {
+ ldk_announced_listen_addr
+ .push(NetAddress::IPv4 { addr: a.octets(), port: ldk_peer_listening_port });
+ arg_idx += 1;
+ }
+ Ok(IpAddr::V6(a)) => {
+ ldk_announced_listen_addr
+ .push(NetAddress::IPv6 { addr: a.octets(), port: ldk_peer_listening_port });
+ arg_idx += 1;
+ }
+ Err(_) => panic!("Failed to parse announced-listen-addr into an IP address"),
+ },
+ None => break,
+ }
+ }
+
Ok(LdkUserInfo {
bitcoind_rpc_username,
bitcoind_rpc_password,
let payee_pubkey = invoice.recover_payee_pub_key();
let final_cltv = invoice.min_final_cltv_expiry() as u32;
-
- let mut payment_hash = PaymentHash([0; 32]);
- payment_hash.0.copy_from_slice(&invoice.payment_hash().as_ref()[0..32]);
-
- let payment_secret = match invoice.payment_secret() {
- Some(secret) => {
- let mut payment_secret = PaymentSecret([0; 32]);
- payment_secret.0.copy_from_slice(&secret.0);
- Some(payment_secret)
- }
- None => None,
- };
-
- let invoice_features = match invoice.features() {
- Some(feat) => Some(feat.clone()),
- None => None,
- };
+ let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
+ let payment_secret = invoice.payment_secret().cloned();
+ let invoice_features = invoice.features().cloned();
send_payment(
payee_pubkey,
}
println!(
"\t\tpeer_pubkey: {},",
- hex_utils::hex_str(&chan_info.remote_network_id.serialize())
+ hex_utils::hex_str(&chan_info.counterparty.node_id.serialize())
);
if let Some(id) = chan_info.short_channel_id {
println!("\t\tshort_channel_id: {},", id);
}
match lightning_net_tokio::connect_outbound(Arc::clone(&peer_manager), pubkey, peer_addr).await
{
- Some(conn_closed_fut) => {
- let mut closed_fut_box = Box::pin(conn_closed_fut);
- let mut peer_connected = false;
- while !peer_connected {
- match futures::poll!(&mut closed_fut_box) {
+ Some(connection_closed_future) => {
+ let mut connection_closed_future = Box::pin(connection_closed_future);
+ loop {
+ match futures::poll!(&mut connection_closed_future) {
std::task::Poll::Ready(_) => {
println!("ERROR: Peer disconnected before we finished the handshake");
return Err(());
}
std::task::Poll::Pending => {}
}
- for node_pubkey in peer_manager.get_peer_node_ids() {
- if node_pubkey == pubkey {
- peer_connected = true;
- }
- }
// Avoid blocking the tokio context by sleeping a bit
- tokio::time::sleep(Duration::from_millis(10)).await;
+ match peer_manager.get_peer_node_ids().iter().find(|id| **id == pubkey) {
+ Some(_) => break,
+ None => tokio::time::sleep(Duration::from_millis(10)).await,
+ }
}
}
None => {
}
fn open_channel(
- peer_pubkey: PublicKey, channel_amt_sat: u64, announce_channel: bool,
+ peer_pubkey: PublicKey, channel_amt_sat: u64, announced_channel: bool,
channel_manager: Arc<ChannelManager>,
) -> Result<(), ()> {
- let mut config = UserConfig::default();
- if announce_channel {
- config.channel_options.announced_channel = true;
- }
- // lnd's max to_self_delay is 2016, so we want to be compatible.
- config.peer_channel_config_limits.their_to_self_delay = 2016;
+ let config = UserConfig {
+ peer_channel_config_limits: ChannelHandshakeLimits {
+ // lnd's max to_self_delay is 2016, so we want to be compatible.
+ their_to_self_delay: 2016,
+ ..Default::default()
+ },
+ channel_options: ChannelConfig { announced_channel, ..Default::default() },
+ ..Default::default()
+ };
+
match channel_manager.create_channel(peer_pubkey, channel_amt_sat, 0, 0, Some(config)) {
Ok(_) => {
println!("EVENT: initiated channel with peer {}. ", peer_pubkey);
}
};
- let mut payment_hash = PaymentHash([0; 32]);
- payment_hash.0.copy_from_slice(&invoice.payment_hash().as_ref()[0..32]);
+ let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
payments.insert(
payment_hash,
PaymentInfo {
preimage: None,
- // We can't add payment secrets to invoices until we support features in invoices.
- // Otherwise lnd errors with "destination hop doesn't understand payment addresses"
- // (for context, lnd calls payment secrets "payment addresses").
- secret: Some(invoice.payment_secret().unwrap().clone()),
+ secret: invoice.payment_secret().cloned(),
status: HTLCStatus::Pending,
amt_msat: MillisatAmount(Some(amt_msat)),
},
projects / ldk-sample / blobdiff