use bitcoin::network::constants::Network;
use bitcoin::secp256k1::PublicKey;
use lightning::ln::channelmanager::{PaymentId, RecipientOnionFields, Retry};
-use lightning::ln::msgs::NetAddress;
-use lightning::ln::{PaymentHash, PaymentPreimage};
+use lightning::ln::msgs::SocketAddress;
+use lightning::ln::{ChannelId, PaymentHash, PaymentPreimage};
use lightning::onion_message::OnionMessagePath;
use lightning::onion_message::{CustomOnionMessageContents, Destination, OnionMessageContents};
use lightning::routing::gossip::NodeId;
use lightning::routing::router::{PaymentParameters, RouteParameters};
use lightning::sign::{EntropySource, KeysManager};
use lightning::util::config::{ChannelHandshakeConfig, ChannelHandshakeLimits, UserConfig};
-use lightning::util::persist::KVStorePersister;
+use lightning::util::persist::KVStore;
use lightning::util::ser::{Writeable, Writer};
use lightning_invoice::payment::pay_invoice;
use lightning_invoice::{utils, Bolt11Invoice, Currency};
-use lightning_persister::FilesystemPersister;
+use lightning_persister::fs_store::FilesystemStore;
use std::env;
use std::io;
use std::io::Write;
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: Vec<NetAddress>,
+ pub(crate) ldk_announced_listen_addr: Vec<SocketAddress>,
pub(crate) ldk_announced_node_name: [u8; 32],
pub(crate) network: Network,
}
keys_manager: Arc<KeysManager>, network_graph: Arc<NetworkGraph>,
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>,
+ logger: Arc<disk::FilesystemLogger>, fs_store: Arc<FilesystemStore>,
) {
println!(
"LDK startup successful. Enter \"help\" to view available commands. Press Ctrl-D to quit."
&channel_manager,
&invoice,
&mut outbound_payments.lock().unwrap(),
- persister.clone(),
+ Arc::clone(&fs_store),
);
}
"keysend" => {
amt_msat,
&*keys_manager,
&mut outbound_payments.lock().unwrap(),
- persister.clone(),
+ Arc::clone(&fs_store),
);
}
"getinvoice" => {
expiry_secs.unwrap(),
Arc::clone(&logger),
);
- persister.persist(INBOUND_PAYMENTS_FNAME, &*inbound_payments).unwrap();
+ fs_store
+ .write("", "", INBOUND_PAYMENTS_FNAME, &inbound_payments.encode())
+ .unwrap();
}
"connectpeer" => {
let peer_pubkey_and_ip_addr = words.next();
for chan_info in channel_manager.list_channels() {
println!("");
println!("\t{{");
- println!("\t\tchannel_id: {},", hex_utils::hex_str(&chan_info.channel_id[..]));
+ println!("\t\tchannel_id: {},", chan_info.channel_id);
if let Some(funding_txo) = chan_info.funding_txo {
println!("\t\tfunding_txid: {},", funding_txo.txid);
}
}
println!("\t\tis_channel_ready: {},", chan_info.is_channel_ready);
println!("\t\tchannel_value_satoshis: {},", chan_info.channel_value_satoshis);
- println!("\t\tlocal_balance_msat: {},", chan_info.balance_msat);
+ println!("\t\toutbound_capacity_msat: {},", chan_info.outbound_capacity_msat);
if chan_info.is_usable {
println!("\t\tavailable_balance_for_send_msat: {},", chan_info.outbound_capacity_msat);
println!("\t\tavailable_balance_for_recv_msat: {},", chan_info.inbound_capacity_msat);
println!("");
println!("\t{{");
println!("\t\tamount_millisatoshis: {},", payment_info.amt_msat);
- println!("\t\tpayment_hash: {},", hex_utils::hex_str(&payment_hash.0));
+ println!("\t\tpayment_hash: {},", payment_hash);
println!("\t\thtlc_direction: inbound,");
println!(
"\t\thtlc_status: {},",
println!("");
println!("\t{{");
println!("\t\tamount_millisatoshis: {},", payment_info.amt_msat);
- println!("\t\tpayment_hash: {},", hex_utils::hex_str(&payment_hash.0));
+ println!("\t\tpayment_hash: {},", payment_hash);
println!("\t\thtlc_direction: outbound,");
println!(
"\t\thtlc_status: {},",
fn send_payment(
channel_manager: &ChannelManager, invoice: &Bolt11Invoice,
- outbound_payments: &mut PaymentInfoStorage, persister: Arc<FilesystemPersister>,
+ outbound_payments: &mut PaymentInfoStorage, fs_store: Arc<FilesystemStore>,
) {
let payment_hash = PaymentHash((*invoice.payment_hash()).into_inner());
let payment_secret = Some(*invoice.payment_secret());
amt_msat: MillisatAmount(invoice.amount_milli_satoshis()),
},
);
- persister.persist(OUTBOUND_PAYMENTS_FNAME, &*outbound_payments).unwrap();
+ fs_store.write("", "", OUTBOUND_PAYMENTS_FNAME, &outbound_payments.encode()).unwrap();
match pay_invoice(invoice, Retry::Timeout(Duration::from_secs(10)), channel_manager) {
Ok(_payment_id) => {
let payee_pubkey = invoice.recover_payee_pub_key();
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();
+ fs_store.write("", "", OUTBOUND_PAYMENTS_FNAME, &outbound_payments.encode()).unwrap();
}
};
}
fn keysend<E: EntropySource>(
channel_manager: &ChannelManager, payee_pubkey: PublicKey, amt_msat: u64, entropy_source: &E,
- outbound_payments: &mut PaymentInfoStorage, persister: Arc<FilesystemPersister>,
+ outbound_payments: &mut PaymentInfoStorage, fs_store: Arc<FilesystemStore>,
) {
let payment_preimage = PaymentPreimage(entropy_source.get_secure_random_bytes());
let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0[..]).into_inner());
- let route_params = RouteParameters {
- payment_params: PaymentParameters::for_keysend(payee_pubkey, 40, false),
- final_value_msat: amt_msat,
- };
+ let route_params = RouteParameters::from_payment_params_and_value(
+ PaymentParameters::for_keysend(payee_pubkey, 40, false),
+ amt_msat,
+ );
outbound_payments.payments.insert(
payment_hash,
PaymentInfo {
amt_msat: MillisatAmount(Some(amt_msat)),
},
);
- persister.persist(OUTBOUND_PAYMENTS_FNAME, &*outbound_payments).unwrap();
+ fs_store.write("", "", OUTBOUND_PAYMENTS_FNAME, &outbound_payments.encode()).unwrap();
match channel_manager.send_spontaneous_payment_with_retry(
Some(payment_preimage),
RecipientOnionFields::spontaneous_empty(),
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();
+ fs_store.write("", "", OUTBOUND_PAYMENTS_FNAME, &outbound_payments.encode()).unwrap();
}
};
}
fn close_channel(
channel_id: [u8; 32], counterparty_node_id: PublicKey, channel_manager: Arc<ChannelManager>,
) {
- match channel_manager.close_channel(&channel_id, &counterparty_node_id) {
+ match channel_manager.close_channel(&ChannelId(channel_id), &counterparty_node_id) {
Ok(()) => println!("EVENT: initiating channel close"),
Err(e) => println!("ERROR: failed to close channel: {:?}", e),
}
fn force_close_channel(
channel_id: [u8; 32], counterparty_node_id: PublicKey, channel_manager: Arc<ChannelManager>,
) {
- match channel_manager.force_close_broadcasting_latest_txn(&channel_id, &counterparty_node_id) {
+ match channel_manager
+ .force_close_broadcasting_latest_txn(&ChannelId(channel_id), &counterparty_node_id)
+ {
Ok(()) => println!("EVENT: initiating channel force-close"),
Err(e) => println!("ERROR: failed to force-close channel: {:?}", e),
}
projects / ldk-sample / blobdiff