X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fmain.rs;h=87ad4e9a718997f48c58af19aa32688c1944791d;hb=5ec1c3f55f5c6794972846ccbe6dc67440313dab;hp=4b1a8d5b82268b7706a79af64e4dfd2c1fdd1449;hpb=d85a979e3a03d1e234fb25f676a23736dd3c5e68;p=ldk-sample diff --git a/src/main.rs b/src/main.rs index 4b1a8d5..87ad4e9 100644 --- a/src/main.rs +++ b/src/main.rs @@ -19,12 +19,12 @@ use lightning::chain; use lightning::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget, FeeEstimator}; use lightning::chain::chainmonitor; use lightning::chain::keysinterface::{InMemorySigner, KeysInterface, KeysManager}; -use lightning::chain::transaction::OutPoint; use lightning::chain::Filter; use lightning::chain::Watch; use lightning::ln::channelmanager; use lightning::ln::channelmanager::{ - ChainParameters, ChannelManagerReadArgs, PaymentHash, PaymentPreimage, SimpleArcChannelManager, + ChainParameters, ChannelManagerReadArgs, PaymentHash, PaymentPreimage, PaymentSecret, + SimpleArcChannelManager, }; use lightning::ln::peer_handler::{MessageHandler, SimpleArcPeerManager}; use lightning::routing::network_graph::NetGraphMsgHandler; @@ -63,9 +63,9 @@ pub(crate) enum HTLCStatus { Failed, } -pub(crate) struct SatoshiAmount(Option); +pub(crate) struct MillisatAmount(Option); -impl fmt::Display for SatoshiAmount { +impl fmt::Display for MillisatAmount { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.0 { Some(amt) => write!(f, "{}", amt), @@ -74,11 +74,15 @@ impl fmt::Display for SatoshiAmount { } } -pub(crate) type PaymentInfoStorage = Arc< - Mutex< - HashMap, HTLCDirection, HTLCStatus, SatoshiAmount)>, - >, ->; +pub(crate) struct PaymentInfo { + preimage: Option, + secret: Option, + direction: HTLCDirection, + status: HTLCStatus, + amt_msat: MillisatAmount, +} + +pub(crate) type PaymentInfoStorage = Arc>>; type ChainMonitor = chainmonitor::ChainMonitor< InMemorySigner, @@ -102,13 +106,11 @@ pub(crate) type ChannelManager = SimpleArcChannelManager; async fn handle_ldk_events( - peer_manager: Arc, channel_manager: Arc, - chain_monitor: Arc, bitcoind_client: Arc, - keys_manager: Arc, payment_storage: PaymentInfoStorage, network: Network, + channel_manager: Arc, chain_monitor: Arc, + bitcoind_client: Arc, keys_manager: Arc, + payment_storage: PaymentInfoStorage, network: Network, ) { - let mut pending_txs: HashMap = HashMap::new(); loop { - peer_manager.process_events(); let loop_channel_manager = channel_manager.clone(); let mut events = channel_manager.get_and_clear_pending_events(); events.append(&mut chain_monitor.get_and_clear_pending_events()); @@ -149,62 +151,55 @@ async fn handle_ldk_events( assert_eq!(signed_tx.complete, true); let final_tx: Transaction = encode::deserialize(&hex_utils::to_vec(&signed_tx.hex).unwrap()).unwrap(); - let outpoint = OutPoint { - txid: final_tx.txid(), - index: if change_output_position == 0 { 1 } else { 0 }, - }; // Give the funding transaction back to LDK for opening the channel. loop_channel_manager - .funding_transaction_generated(&temporary_channel_id, outpoint); - pending_txs.insert(outpoint, final_tx); - } - Event::FundingBroadcastSafe { funding_txo, .. } => { - let funding_tx = pending_txs.remove(&funding_txo).unwrap(); - bitcoind_client.broadcast_transaction(&funding_tx); - println!("\nEVENT: broadcasted funding transaction"); - print!("> "); - io::stdout().flush().unwrap(); + .funding_transaction_generated(&temporary_channel_id, final_tx) + .unwrap(); } - Event::PaymentReceived { payment_hash, payment_secret, amt: amt_msat } => { + Event::PaymentReceived { payment_hash, .. } => { let mut payments = payment_storage.lock().unwrap(); - if let Some((Some(preimage), _, _, _)) = payments.get(&payment_hash) { + if let Some(payment) = payments.get_mut(&payment_hash) { assert!(loop_channel_manager.claim_funds( - preimage.clone(), - &payment_secret, - amt_msat + payment.preimage.unwrap().clone(), + &payment.secret, + payment.amt_msat.0.unwrap(), )); println!( - "\nEVENT: received payment from payment_hash {} of {} satoshis", + "\nEVENT: received payment from payment_hash {} of {} millisatoshis", hex_utils::hex_str(&payment_hash.0), - amt_msat / 1000 + payment.amt_msat ); print!("> "); io::stdout().flush().unwrap(); - let (_, _, ref mut status, _) = payments.get_mut(&payment_hash).unwrap(); - *status = HTLCStatus::Succeeded; + payment.status = HTLCStatus::Succeeded; } else { println!("\nERROR: we received a payment but didn't know the preimage"); print!("> "); io::stdout().flush().unwrap(); - loop_channel_manager.fail_htlc_backwards(&payment_hash, &payment_secret); + loop_channel_manager.fail_htlc_backwards(&payment_hash, &None); payments.insert( payment_hash, - (None, HTLCDirection::Inbound, HTLCStatus::Failed, SatoshiAmount(None)), + PaymentInfo { + preimage: None, + secret: None, + direction: HTLCDirection::Inbound, + status: HTLCStatus::Failed, + amt_msat: MillisatAmount(None), + }, ); } } Event::PaymentSent { payment_preimage } => { let hashed = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner()); let mut payments = payment_storage.lock().unwrap(); - for (payment_hash, (preimage_option, _, status, amt_sat)) in payments.iter_mut() - { + for (payment_hash, payment) in payments.iter_mut() { if *payment_hash == hashed { - *preimage_option = Some(payment_preimage); - *status = HTLCStatus::Succeeded; + payment.preimage = Some(payment_preimage); + payment.status = HTLCStatus::Succeeded; println!( - "\nEVENT: successfully sent payment of {} satoshis from \ + "\nEVENT: successfully sent payment of {} millisatoshis from \ payment hash {:?} with preimage {:?}", - amt_sat, + payment.amt_msat, hex_utils::hex_str(&payment_hash.0), hex_utils::hex_str(&payment_preimage.0) ); @@ -228,8 +223,8 @@ async fn handle_ldk_events( let mut payments = payment_storage.lock().unwrap(); if payments.contains_key(&payment_hash) { - let (_, _, ref mut status, _) = payments.get_mut(&payment_hash).unwrap(); - *status = HTLCStatus::Failed; + let payment = payments.get_mut(&payment_hash).unwrap(); + payment.status = HTLCStatus::Failed; } } Event::PendingHTLCsForwardable { time_forwardable } => { @@ -263,8 +258,7 @@ async fn handle_ldk_events( } } -#[tokio::main] -pub async fn main() { +async fn start_ldk() { let args = match cli::parse_startup_args() { Ok(user_args) => user_args, Err(()) => return, @@ -346,9 +340,7 @@ pub async fn main() { let keys_manager = Arc::new(KeysManager::new(&keys_seed, cur.as_secs(), cur.subsec_nanos())); // Step 7: Read ChannelMonitor state from disk - let monitors_path = format!("{}/monitors", ldk_data_dir.clone()); - let mut outpoint_to_channelmonitor = - disk::read_channelmonitors(monitors_path.to_string(), keys_manager.clone()).unwrap(); + let mut channelmonitors = persister.read_channelmonitors(keys_manager.clone()).unwrap(); // Step 9: Initialize the ChannelManager let user_config = UserConfig::default(); @@ -356,8 +348,8 @@ pub async fn main() { let (channel_manager_blockhash, mut channel_manager) = { if let Ok(mut f) = fs::File::open(format!("{}/manager", ldk_data_dir.clone())) { let mut channel_monitor_mut_references = Vec::new(); - for (_, channel_monitor) in outpoint_to_channelmonitor.iter_mut() { - channel_monitor_mut_references.push(&mut channel_monitor.1); + for (_, channel_monitor) in channelmonitors.iter_mut() { + channel_monitor_mut_references.push(channel_monitor); } let read_args = ChannelManagerReadArgs::new( keys_manager.clone(), @@ -400,9 +392,8 @@ pub async fn main() { let mut chain_listeners = vec![(channel_manager_blockhash, &mut channel_manager as &mut dyn chain::Listen)]; - for (outpoint, blockhash_and_monitor) in outpoint_to_channelmonitor.drain() { - let blockhash = blockhash_and_monitor.0; - let channel_monitor = blockhash_and_monitor.1; + for (blockhash, channel_monitor) in channelmonitors.drain(..) { + let outpoint = channel_monitor.get_funding_txo().0; chain_listener_channel_monitors.push(( blockhash, (channel_monitor, broadcaster.clone(), fee_estimator.clone(), logger.clone()), @@ -505,29 +496,21 @@ pub async fn main() { BackgroundProcessor::start( persist_channel_manager_callback, channel_manager.clone(), + peer_manager.clone(), logger.clone(), ); - let peer_manager_processor = peer_manager.clone(); - tokio::spawn(async move { - loop { - peer_manager_processor.timer_tick_occurred(); - tokio::time::sleep(Duration::from_secs(60)).await; - } - }); - // Step 15: Initialize LDK Event Handling - let peer_manager_event_listener = peer_manager.clone(); let channel_manager_event_listener = channel_manager.clone(); let chain_monitor_event_listener = chain_monitor.clone(); let keys_manager_listener = keys_manager.clone(); + // TODO: persist payment info to disk let payment_info: PaymentInfoStorage = Arc::new(Mutex::new(HashMap::new())); let payment_info_for_events = payment_info.clone(); let network = args.network; let bitcoind_rpc = bitcoind_client.clone(); tokio::spawn(async move { handle_ldk_events( - peer_manager_event_listener, channel_manager_event_listener, chain_monitor_event_listener, bitcoind_rpc, @@ -572,3 +555,8 @@ pub async fn main() { ) .await; } + +#[tokio::main] +pub async fn main() { + start_ldk().await; +}