use lightning::ln::msgs::DecodeError;
use lightning::ln::peer_handler::{IgnoringMessageHandler, MessageHandler, SimpleArcPeerManager};
use lightning::ln::{ChannelId, PaymentHash, PaymentPreimage, PaymentSecret};
-use lightning::onion_message::{DefaultMessageRouter, SimpleArcOnionMessenger};
+use lightning::onion_message::messenger::{DefaultMessageRouter, SimpleArcOnionMessenger};
use lightning::routing::gossip;
use lightning::routing::gossip::{NodeId, P2PGossipSync};
use lightning::routing::router::DefaultRouter;
use std::fs::File;
use std::io;
use std::io::Write;
+use std::net::ToSocketAddrs;
use std::path::Path;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, RwLock};
lightning_block_sync::gossip::TokioSpawner,
Arc<lightning_block_sync::rpc::RpcClient>,
Arc<FilesystemLogger>,
- SocketDescriptor,
- Arc<ChannelManager>,
- Arc<OnionMessenger>,
- IgnoringMessageHandler,
- Arc<KeysManager>,
>;
pub(crate) type PeerManager = SimpleArcPeerManager<
>;
async fn handle_ldk_events(
- channel_manager: &Arc<ChannelManager>, bitcoind_client: &BitcoindClient,
+ channel_manager: Arc<ChannelManager>, bitcoind_client: &BitcoindClient,
network_graph: &NetworkGraph, keys_manager: &KeysManager,
- bump_tx_event_handler: &BumpTxEventHandler,
+ bump_tx_event_handler: &BumpTxEventHandler, peer_manager: Arc<PeerManager>,
inbound_payments: Arc<Mutex<InboundPaymentInfoStorage>>,
- outbound_payments: Arc<Mutex<OutboundPaymentInfoStorage>>, fs_store: &Arc<FilesystemStore>,
+ outbound_payments: Arc<Mutex<OutboundPaymentInfoStorage>>, fs_store: Arc<FilesystemStore>,
network: Network, event: Event,
) {
match event {
// Construct the raw transaction with one output, that is paid the amount of the
// channel.
let addr = WitnessProgram::from_scriptpubkey(
- &output_script[..],
+ &output_script.as_bytes(),
match network {
Network::Bitcoin => bitcoin_bech32::constants::Network::Bitcoin,
- Network::Testnet => bitcoin_bech32::constants::Network::Testnet,
Network::Regtest => bitcoin_bech32::constants::Network::Regtest,
Network::Signet => bitcoin_bech32::constants::Network::Signet,
+ Network::Testnet | _ => bitcoin_bech32::constants::Network::Testnet,
},
)
.expect("Lightning funding tx should always be to a SegWit output")
print!("> ");
io::stdout().flush().unwrap();
}
- }
+ },
Event::PaymentClaimable {
payment_hash,
purpose,
PaymentPurpose::SpontaneousPayment(preimage) => Some(preimage),
};
channel_manager.claim_funds(payment_preimage.unwrap());
- }
+ },
Event::PaymentClaimed {
payment_hash,
purpose,
let (payment_preimage, payment_secret) = match purpose {
PaymentPurpose::InvoicePayment { payment_preimage, payment_secret, .. } => {
(payment_preimage, Some(payment_secret))
- }
+ },
PaymentPurpose::SpontaneousPayment(preimage) => (Some(preimage), None),
};
let mut inbound = inbound_payments.lock().unwrap();
payment.status = HTLCStatus::Succeeded;
payment.preimage = payment_preimage;
payment.secret = payment_secret;
- }
+ },
Entry::Vacant(e) => {
e.insert(PaymentInfo {
preimage: payment_preimage,
status: HTLCStatus::Succeeded,
amt_msat: MillisatAmount(Some(amount_msat)),
});
- }
+ },
}
fs_store.write("", "", INBOUND_PAYMENTS_FNAME, &inbound.encode()).unwrap();
- }
+ },
Event::PaymentSent {
payment_preimage, payment_hash, fee_paid_msat, payment_id, ..
} => {
}
}
fs_store.write("", "", OUTBOUND_PAYMENTS_FNAME, &outbound.encode()).unwrap();
- }
+ },
Event::OpenChannelRequest {
ref temporary_channel_id, ref counterparty_node_id, ..
} => {
}
print!("> ");
io::stdout().flush().unwrap();
- }
- Event::PaymentPathSuccessful { .. } => {}
- Event::PaymentPathFailed { .. } => {}
- Event::ProbeSuccessful { .. } => {}
- Event::ProbeFailed { .. } => {}
+ },
+ Event::PaymentPathSuccessful { .. } => {},
+ Event::PaymentPathFailed { .. } => {},
+ Event::ProbeSuccessful { .. } => {},
+ Event::ProbeFailed { .. } => {},
Event::PaymentFailed { payment_hash, reason, payment_id, .. } => {
print!(
"\nEVENT: Failed to send payment to payment hash {}: {:?}",
payment.status = HTLCStatus::Failed;
}
fs_store.write("", "", OUTBOUND_PAYMENTS_FNAME, &outbound.encode()).unwrap();
- }
+ },
Event::InvoiceRequestFailed { payment_id } => {
print!("\nEVENT: Failed to request invoice to send payment with id {}", payment_id);
print!("> ");
payment.status = HTLCStatus::Failed;
}
fs_store.write("", "", OUTBOUND_PAYMENTS_FNAME, &outbound.encode()).unwrap();
- }
+ },
Event::PaymentForwarded {
prev_channel_id,
next_channel_id,
None => "unnamed node".to_string(),
Some(announcement) => {
format!("node {}", announcement.alias)
- }
+ },
},
}
- }
+ },
},
};
let channel_str = |channel_id: &Option<ChannelId>| {
}
print!("> ");
io::stdout().flush().unwrap();
- }
- Event::HTLCHandlingFailed { .. } => {}
+ },
+ Event::HTLCHandlingFailed { .. } => {},
Event::PendingHTLCsForwardable { time_forwardable } => {
let forwarding_channel_manager = channel_manager.clone();
let min = time_forwardable.as_millis() as u64;
tokio::time::sleep(Duration::from_millis(millis_to_sleep)).await;
forwarding_channel_manager.process_pending_htlc_forwards();
});
- }
+ },
Event::SpendableOutputs { outputs, channel_id: _ } => {
// SpendableOutputDescriptors, of which outputs is a vec of, are critical to keep track
// of! While a `StaticOutput` descriptor is just an output to a static, well-known key,
let output: SpendableOutputDescriptor = output;
fs_store.write(PENDING_SPENDABLE_OUTPUT_DIR, "", &key, &output.encode()).unwrap();
}
- }
+ },
Event::ChannelPending { channel_id, counterparty_node_id, .. } => {
println!(
"\nEVENT: Channel {} with peer {} is pending awaiting funding lock-in!",
);
print!("> ");
io::stdout().flush().unwrap();
- }
+ },
Event::ChannelReady {
ref channel_id,
user_channel_id: _,
);
print!("> ");
io::stdout().flush().unwrap();
- }
+ },
Event::ChannelClosed {
channel_id,
reason,
user_channel_id: _,
counterparty_node_id,
channel_capacity_sats: _,
+ channel_funding_txo: _,
} => {
println!(
"\nEVENT: Channel {} with counterparty {} closed due to: {:?}",
);
print!("> ");
io::stdout().flush().unwrap();
- }
+ },
Event::DiscardFunding { .. } => {
// A "real" node should probably "lock" the UTXOs spent in funding transactions until
// the funding transaction either confirms, or this event is generated.
- }
- Event::HTLCIntercepted { .. } => {}
+ },
+ Event::HTLCIntercepted { .. } => {},
Event::BumpTransaction(event) => bump_tx_event_handler.handle_event(&event),
+ Event::ConnectionNeeded { node_id, addresses } => {
+ tokio::spawn(async move {
+ for address in addresses {
+ if let Ok(sockaddrs) = address.to_socket_addrs() {
+ for addr in sockaddrs {
+ let pm = Arc::clone(&peer_manager);
+ if cli::connect_peer_if_necessary(node_id, addr, pm).await.is_ok() {
+ return;
+ }
+ }
+ }
+ }
+ });
+ },
}
}
args.bitcoind_rpc_port,
args.bitcoind_rpc_username.clone(),
args.bitcoind_rpc_password.clone(),
+ args.network,
tokio::runtime::Handle::current(),
Arc::clone(&logger),
)
Err(e) => {
println!("Failed to connect to bitcoind client: {}", e);
return;
- }
+ },
};
// Check that the bitcoind we've connected to is running the network we expect
if bitcoind_chain
!= match args.network {
bitcoin::Network::Bitcoin => "main",
- bitcoin::Network::Testnet => "test",
bitcoin::Network::Regtest => "regtest",
bitcoin::Network::Signet => "signet",
+ bitcoin::Network::Testnet | _ => "test",
} {
println!(
"Chain argument ({}) didn't match bitcoind chain ({})",
Ok(mut f) => {
Write::write_all(&mut f, &key).expect("Failed to write node keys seed to disk");
f.sync_all().expect("Failed to sync node keys seed to disk");
- }
+ },
Err(e) => {
println!("ERROR: Unable to create keys seed file {}: {}", keys_seed_path, e);
return;
- }
+ },
}
key
};
Arc::clone(&keys_manager),
Arc::clone(&keys_manager),
Arc::clone(&logger),
- Arc::new(DefaultMessageRouter {}),
+ Arc::new(DefaultMessageRouter::new(Arc::clone(&network_graph))),
Arc::clone(&channel_manager),
IgnoringMessageHandler {},
));
let inbound_payments_event_listener = Arc::clone(&inbound_payments);
let outbound_payments_event_listener = Arc::clone(&outbound_payments);
let fs_store_event_listener = Arc::clone(&fs_store);
+ let peer_manager_event_listener = Arc::clone(&peer_manager);
let network = args.network;
let event_handler = move |event: Event| {
let channel_manager_event_listener = Arc::clone(&channel_manager_event_listener);
let inbound_payments_event_listener = Arc::clone(&inbound_payments_event_listener);
let outbound_payments_event_listener = Arc::clone(&outbound_payments_event_listener);
let fs_store_event_listener = Arc::clone(&fs_store_event_listener);
+ let peer_manager_event_listener = Arc::clone(&peer_manager_event_listener);
async move {
handle_ldk_events(
- &channel_manager_event_listener,
+ channel_manager_event_listener,
&bitcoind_client_event_listener,
&network_graph_event_listener,
&keys_manager_event_listener,
&bump_tx_event_handler,
+ peer_manager_event_listener,
inbound_payments_event_listener,
outbound_payments_event_listener,
- &fs_store_event_listener,
+ fs_store_event_listener,
network,
event,
)
})
},
false,
+ || Some(SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap()),
));
// Regularly reconnect to channel peers.
}
}
}
- }
+ },
Err(e) => println!("ERROR: errored reading channel peer info from disk: {:?}", e),
}
}
projects / ldk-sample / blobdiff