-use crate::disk;
+use crate::disk::{self, INBOUND_PAYMENTS_FNAME, OUTBOUND_PAYMENTS_FNAME};
use crate::hex_utils;
use crate::{
ChannelManager, HTLCStatus, MillisatAmount, NetworkGraph, OnionMessenger, PaymentInfo,
use lightning::routing::gossip::NodeId;
use lightning::routing::router::{PaymentParameters, RouteParameters};
use lightning::util::config::{ChannelHandshakeConfig, ChannelHandshakeLimits, UserConfig};
+use lightning::util::persist::KVStorePersister;
use lightning::util::ser::{Writeable, Writer};
use lightning_invoice::payment::pay_invoice;
use lightning_invoice::{utils, Currency, Invoice};
+use lightning_persister::FilesystemPersister;
use std::env;
use std::io;
use std::io::Write;
use std::net::{SocketAddr, ToSocketAddrs};
-use std::ops::Deref;
use std::path::Path;
use std::str::FromStr;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
use std::time::Duration;
pub(crate) struct LdkUserInfo {
pub(crate) async fn poll_for_user_input(
peer_manager: Arc<PeerManager>, channel_manager: Arc<ChannelManager>,
keys_manager: Arc<KeysManager>, network_graph: Arc<NetworkGraph>,
- onion_messenger: Arc<OnionMessenger>, inbound_payments: PaymentInfoStorage,
- outbound_payments: PaymentInfoStorage, ldk_data_dir: String, network: Network,
- logger: Arc<disk::FilesystemLogger>,
+ onion_messenger: Arc<OnionMessenger>, inbound_payments: Arc<Mutex<PaymentInfoStorage>>,
+ outbound_payments: Arc<Mutex<PaymentInfoStorage>>, ldk_data_dir: String, network: Network,
+ logger: Arc<disk::FilesystemLogger>, persister: Arc<FilesystemPersister>,
) {
println!(
"LDK startup successful. Enter \"help\" to view available commands. Press Ctrl-D to quit."
}
};
- send_payment(&*channel_manager, &invoice, outbound_payments.clone());
+ send_payment(
+ &channel_manager,
+ &invoice,
+ &mut outbound_payments.lock().unwrap(),
+ persister.clone(),
+ );
}
"keysend" => {
let dest_pubkey = match words.next() {
}
};
keysend(
- &*channel_manager,
+ &channel_manager,
dest_pubkey,
amt_msat,
&*keys_manager,
- outbound_payments.clone(),
+ &mut outbound_payments.lock().unwrap(),
+ persister.clone(),
);
}
"getinvoice" => {
continue;
}
+ let mut inbound_payments = inbound_payments.lock().unwrap();
get_invoice(
amt_msat.unwrap(),
- Arc::clone(&inbound_payments),
- &*channel_manager,
+ &mut inbound_payments,
+ &channel_manager,
Arc::clone(&keys_manager),
network,
expiry_secs.unwrap(),
Arc::clone(&logger),
);
+ persister.persist(INBOUND_PAYMENTS_FNAME, &*inbound_payments).unwrap();
}
"connectpeer" => {
let peer_pubkey_and_ip_addr = words.next();
}
}
"listchannels" => list_channels(&channel_manager, &network_graph),
- "listpayments" => {
- list_payments(inbound_payments.clone(), outbound_payments.clone())
- }
+ "listpayments" => list_payments(
+ &inbound_payments.lock().unwrap(),
+ &outbound_payments.lock().unwrap(),
+ ),
"closechannel" => {
let channel_id_str = words.next();
if channel_id_str.is_none() {
println!("]");
}
-fn list_payments(inbound_payments: PaymentInfoStorage, outbound_payments: PaymentInfoStorage) {
- let inbound = inbound_payments.lock().unwrap();
- let outbound = outbound_payments.lock().unwrap();
+fn list_payments(inbound_payments: &PaymentInfoStorage, outbound_payments: &PaymentInfoStorage) {
print!("[");
- for (payment_hash, payment_info) in inbound.deref() {
+ for (payment_hash, payment_info) in &inbound_payments.payments {
println!("");
println!("\t{{");
println!("\t\tamount_millisatoshis: {},", payment_info.amt_msat);
println!("\t}},");
}
- for (payment_hash, payment_info) in outbound.deref() {
+ for (payment_hash, payment_info) in &outbound_payments.payments {
println!("");
println!("\t{{");
println!("\t\tamount_millisatoshis: {},", payment_info.amt_msat);
}
fn send_payment(
- channel_manager: &ChannelManager, invoice: &Invoice, payment_storage: PaymentInfoStorage,
+ channel_manager: &ChannelManager, invoice: &Invoice,
+ outbound_payments: &mut PaymentInfoStorage, persister: Arc<FilesystemPersister>,
) {
- let status =
- match pay_invoice(invoice, Retry::Timeout(Duration::from_secs(10)), channel_manager) {
- Ok(_payment_id) => {
- let payee_pubkey = invoice.recover_payee_pub_key();
- let amt_msat = invoice.amount_milli_satoshis().unwrap();
- println!("EVENT: initiated sending {} msats to {}", amt_msat, payee_pubkey);
- print!("> ");
- HTLCStatus::Pending
- }
- Err(e) => {
- println!("ERROR: failed to send payment: {:?}", e);
- print!("> ");
- HTLCStatus::Failed
- }
- };
- let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
- let payment_secret = Some(invoice.payment_secret().clone());
-
- let mut payments = payment_storage.lock().unwrap();
- payments.insert(
+ let payment_hash = PaymentHash((*invoice.payment_hash()).into_inner());
+ let payment_secret = Some(*invoice.payment_secret());
+ outbound_payments.payments.insert(
payment_hash,
PaymentInfo {
preimage: None,
secret: payment_secret,
- status,
+ status: HTLCStatus::Pending,
amt_msat: MillisatAmount(invoice.amount_milli_satoshis()),
},
);
+ persister.persist(OUTBOUND_PAYMENTS_FNAME, &*outbound_payments).unwrap();
+ match pay_invoice(invoice, Retry::Timeout(Duration::from_secs(10)), channel_manager) {
+ Ok(_payment_id) => {
+ let payee_pubkey = invoice.recover_payee_pub_key();
+ let amt_msat = invoice.amount_milli_satoshis().unwrap();
+ println!("EVENT: initiated sending {} msats to {}", amt_msat, payee_pubkey);
+ print!("> ");
+ }
+ Err(e) => {
+ println!("ERROR: failed to send payment: {:?}", e);
+ print!("> ");
+ outbound_payments.payments.get_mut(&payment_hash).unwrap().status = HTLCStatus::Failed;
+ persister.persist(OUTBOUND_PAYMENTS_FNAME, &*outbound_payments).unwrap();
+ }
+ };
}
fn keysend<E: EntropySource>(
channel_manager: &ChannelManager, payee_pubkey: PublicKey, amt_msat: u64, entropy_source: &E,
- payment_storage: PaymentInfoStorage,
+ outbound_payments: &mut PaymentInfoStorage, persister: Arc<FilesystemPersister>,
) {
let payment_preimage = PaymentPreimage(entropy_source.get_secure_random_bytes());
let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0[..]).into_inner());
payment_params: PaymentParameters::for_keysend(payee_pubkey, 40),
final_value_msat: amt_msat,
};
- let status = match channel_manager.send_spontaneous_payment_with_retry(
+ outbound_payments.payments.insert(
+ payment_hash,
+ PaymentInfo {
+ preimage: None,
+ secret: None,
+ status: HTLCStatus::Pending,
+ amt_msat: MillisatAmount(Some(amt_msat)),
+ },
+ );
+ persister.persist(OUTBOUND_PAYMENTS_FNAME, &*outbound_payments).unwrap();
+ match channel_manager.send_spontaneous_payment_with_retry(
Some(payment_preimage),
RecipientOnionFields::spontaneous_empty(),
PaymentId(payment_hash.0),
Ok(_payment_hash) => {
println!("EVENT: initiated sending {} msats to {}", amt_msat, payee_pubkey);
print!("> ");
- HTLCStatus::Pending
}
Err(e) => {
println!("ERROR: failed to send payment: {:?}", e);
print!("> ");
- HTLCStatus::Failed
+ outbound_payments.payments.get_mut(&payment_hash).unwrap().status = HTLCStatus::Failed;
+ persister.persist(OUTBOUND_PAYMENTS_FNAME, &*outbound_payments).unwrap();
}
};
-
- let mut payments = payment_storage.lock().unwrap();
- payments.insert(
- payment_hash,
- PaymentInfo {
- preimage: None,
- secret: None,
- status,
- amt_msat: MillisatAmount(Some(amt_msat)),
- },
- );
}
fn get_invoice(
- amt_msat: u64, payment_storage: PaymentInfoStorage, channel_manager: &ChannelManager,
+ amt_msat: u64, inbound_payments: &mut PaymentInfoStorage, channel_manager: &ChannelManager,
keys_manager: Arc<KeysManager>, network: Network, expiry_secs: u32,
logger: Arc<disk::FilesystemLogger>,
) {
- let mut payments = payment_storage.lock().unwrap();
let currency = match network {
Network::Bitcoin => Currency::Bitcoin,
Network::Testnet => Currency::BitcoinTestnet,
};
let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
- payments.insert(
+ inbound_payments.payments.insert(
payment_hash,
PaymentInfo {
preimage: None,
-use crate::{cli, NetworkGraph};
+use crate::{cli, NetworkGraph, PaymentInfoStorage};
use bitcoin::secp256k1::PublicKey;
use bitcoin::Network;
use chrono::Utc;
use lightning::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringParameters};
use lightning::util::logger::{Logger, Record};
-use lightning::util::ser::{ReadableArgs, Writer};
+use lightning::util::ser::{Readable, ReadableArgs, Writer};
use std::collections::HashMap;
use std::fs;
use std::fs::File;
use std::path::Path;
use std::sync::Arc;
+pub(crate) const INBOUND_PAYMENTS_FNAME: &str = "inbound_payments";
+pub(crate) const OUTBOUND_PAYMENTS_FNAME: &str = "outbound_payments";
+
pub(crate) struct FilesystemLogger {
data_dir: String,
}
NetworkGraph::new(network, logger)
}
+pub(crate) fn read_payment_info(path: &Path) -> PaymentInfoStorage {
+ if let Ok(file) = File::open(path) {
+ if let Ok(info) = PaymentInfoStorage::read(&mut BufReader::new(file)) {
+ return info;
+ }
+ }
+ PaymentInfoStorage { payments: HashMap::new() }
+}
+
pub(crate) fn read_scorer(
path: &Path, graph: Arc<NetworkGraph>, logger: Arc<FilesystemLogger>,
) -> ProbabilisticScorer<Arc<NetworkGraph>, Arc<FilesystemLogger>> {
use bitcoin::network::constants::Network;
use bitcoin::BlockHash;
use bitcoin_bech32::WitnessProgram;
-use lightning::chain;
+use disk::{INBOUND_PAYMENTS_FNAME, OUTBOUND_PAYMENTS_FNAME};
use lightning::chain::keysinterface::{
EntropySource, InMemorySigner, KeysManager, SpendableOutputDescriptor,
};
use lightning::chain::{chainmonitor, ChannelMonitorUpdateStatus};
use lightning::chain::{Filter, Watch};
use lightning::events::{Event, PaymentFailureReason, PaymentPurpose};
-use lightning::ln::channelmanager;
+use lightning::ln::channelmanager::{self, RecentPaymentDetails};
use lightning::ln::channelmanager::{
ChainParameters, ChannelManagerReadArgs, SimpleArcChannelManager,
};
+use lightning::ln::msgs::DecodeError;
use lightning::ln::peer_handler::{IgnoringMessageHandler, MessageHandler, SimpleArcPeerManager};
use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
use lightning::onion_message::SimpleArcOnionMessenger;
use lightning::routing::router::DefaultRouter;
use lightning::util::config::UserConfig;
use lightning::util::persist::KVStorePersister;
-use lightning::util::ser::ReadableArgs;
+use lightning::util::ser::{Readable, ReadableArgs, Writeable, Writer};
+use lightning::{chain, impl_writeable_tlv_based, impl_writeable_tlv_based_enum};
use lightning_background_processor::{process_events_async, GossipSync};
use lightning_block_sync::init;
use lightning_block_sync::poll;
pub(crate) const PENDING_SPENDABLE_OUTPUT_DIR: &'static str = "pending_spendable_outputs";
+#[derive(Copy, Clone)]
pub(crate) enum HTLCStatus {
Pending,
Succeeded,
Failed,
}
+impl_writeable_tlv_based_enum!(HTLCStatus,
+ (0, Pending) => {},
+ (1, Succeeded) => {},
+ (2, Failed) => {};
+);
+
pub(crate) struct MillisatAmount(Option<u64>);
impl fmt::Display for MillisatAmount {
}
}
+impl Readable for MillisatAmount {
+ fn read<R: io::Read>(r: &mut R) -> Result<Self, DecodeError> {
+ let amt: Option<u64> = Readable::read(r)?;
+ Ok(MillisatAmount(amt))
+ }
+}
+
+impl Writeable for MillisatAmount {
+ fn write<W: Writer>(&self, w: &mut W) -> Result<(), std::io::Error> {
+ self.0.write(w)
+ }
+}
+
pub(crate) struct PaymentInfo {
preimage: Option<PaymentPreimage>,
secret: Option<PaymentSecret>,
amt_msat: MillisatAmount,
}
-pub(crate) type PaymentInfoStorage = Arc<Mutex<HashMap<PaymentHash, PaymentInfo>>>;
+impl_writeable_tlv_based!(PaymentInfo, {
+ (0, preimage, required),
+ (2, secret, required),
+ (4, status, required),
+ (6, amt_msat, required),
+});
+
+pub(crate) struct PaymentInfoStorage {
+ payments: HashMap<PaymentHash, PaymentInfo>,
+}
+
+impl_writeable_tlv_based!(PaymentInfoStorage, {
+ (0, payments, required),
+});
type ChainMonitor = chainmonitor::ChainMonitor<
InMemorySigner,
async fn handle_ldk_events(
channel_manager: &Arc<ChannelManager>, bitcoind_client: &BitcoindClient,
network_graph: &NetworkGraph, keys_manager: &KeysManager,
- inbound_payments: &PaymentInfoStorage, outbound_payments: &PaymentInfoStorage,
- persister: &Arc<FilesystemPersister>, network: Network, event: Event,
+ inbound_payments: Arc<Mutex<PaymentInfoStorage>>,
+ outbound_payments: Arc<Mutex<PaymentInfoStorage>>, persister: &Arc<FilesystemPersister>,
+ network: Network, event: Event,
) {
match event {
Event::FundingGenerationReady {
}
PaymentPurpose::SpontaneousPayment(preimage) => (Some(preimage), None),
};
- let mut payments = inbound_payments.lock().unwrap();
- match payments.entry(payment_hash) {
+ let mut inbound = inbound_payments.lock().unwrap();
+ match inbound.payments.entry(payment_hash) {
Entry::Occupied(mut e) => {
let payment = e.get_mut();
payment.status = HTLCStatus::Succeeded;
});
}
}
+ persister.persist(INBOUND_PAYMENTS_FNAME, &*inbound).unwrap();
}
Event::PaymentSent { payment_preimage, payment_hash, fee_paid_msat, .. } => {
- let mut payments = outbound_payments.lock().unwrap();
- for (hash, payment) in payments.iter_mut() {
+ let mut outbound = outbound_payments.lock().unwrap();
+ for (hash, payment) in outbound.payments.iter_mut() {
if *hash == payment_hash {
payment.preimage = Some(payment_preimage);
payment.status = HTLCStatus::Succeeded;
io::stdout().flush().unwrap();
}
}
+ persister.persist(OUTBOUND_PAYMENTS_FNAME, &*outbound).unwrap();
}
Event::OpenChannelRequest { .. } => {
// Unreachable, we don't set manually_accept_inbound_channels
print!("> ");
io::stdout().flush().unwrap();
- let mut payments = outbound_payments.lock().unwrap();
- if payments.contains_key(&payment_hash) {
- let payment = payments.get_mut(&payment_hash).unwrap();
+ let mut outbound = outbound_payments.lock().unwrap();
+ if outbound.payments.contains_key(&payment_hash) {
+ let payment = outbound.payments.get_mut(&payment_hash).unwrap();
payment.status = HTLCStatus::Failed;
}
+ persister.persist(OUTBOUND_PAYMENTS_FNAME, &*outbound).unwrap();
}
Event::PaymentForwarded {
prev_channel_id,
thread_rng().fill_bytes(&mut key);
match File::create(keys_seed_path.clone()) {
Ok(mut f) => {
- f.write_all(&key).expect("Failed to write node keys seed to disk");
+ 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) => {
}
});
- // TODO: persist payment info to disk
- let inbound_payments: PaymentInfoStorage = Arc::new(Mutex::new(HashMap::new()));
- let outbound_payments: PaymentInfoStorage = Arc::new(Mutex::new(HashMap::new()));
+ let inbound_payments = Arc::new(Mutex::new(disk::read_payment_info(Path::new(&format!(
+ "{}/{}",
+ ldk_data_dir, INBOUND_PAYMENTS_FNAME
+ )))));
+ let outbound_payments = Arc::new(Mutex::new(disk::read_payment_info(Path::new(&format!(
+ "{}/{}",
+ ldk_data_dir, OUTBOUND_PAYMENTS_FNAME
+ )))));
+ let recent_payments_payment_hashes = channel_manager
+ .list_recent_payments()
+ .into_iter()
+ .filter_map(|p| match p {
+ RecentPaymentDetails::Pending { payment_hash, .. } => Some(payment_hash),
+ RecentPaymentDetails::Fulfilled { payment_hash } => payment_hash,
+ RecentPaymentDetails::Abandoned { payment_hash } => Some(payment_hash),
+ })
+ .collect::<Vec<PaymentHash>>();
+ for (payment_hash, payment_info) in outbound_payments
+ .lock()
+ .unwrap()
+ .payments
+ .iter_mut()
+ .filter(|(_, i)| matches!(i.status, HTLCStatus::Pending))
+ {
+ if !recent_payments_payment_hashes.contains(payment_hash) {
+ payment_info.status = HTLCStatus::Failed;
+ }
+ }
+ persister.persist(OUTBOUND_PAYMENTS_FNAME, &*outbound_payments.lock().unwrap()).unwrap();
// Step 18: Handle LDK Events
let channel_manager_event_listener = Arc::clone(&channel_manager);
&bitcoind_client_event_listener,
&network_graph_event_listener,
&keys_manager_event_listener,
- &inbound_payments_event_listener,
- &outbound_payments_event_listener,
+ inbound_payments_event_listener,
+ outbound_payments_event_listener,
&persister_event_listener,
network,
event,
ldk_data_dir,
network,
Arc::clone(&logger),
+ Arc::clone(&persister),
)
.await;