use crate::logger::FilesystemLogger;
use crate::message_handler::NodeCustomMessageHandler;
use lightning::chain::chainmonitor;
use lightning::ln::channelmanager::ChannelDetails as LdkChannelDetails;
use lightning::ln::msgs::RoutingMessageHandler;
use lightning::ln::msgs::SocketAddress;
use lightning::ln::peer_handler::IgnoringMessageHandler;
use lightning::ln::ChannelId;
use lightning::routing::gossip;
use lightning::routing::router::DefaultRouter;
use lightning::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringFeeParameters};
use lightning::sign::InMemorySigner;
use lightning::util::config::ChannelConfig as LdkChannelConfig;
use lightning::util::config::MaxDustHTLCExposure as LdkMaxDustHTLCExposure;
use lightning::util::persist::KVStore;
use lightning::util::ser::{Readable, Writeable, Writer};
use lightning::util::sweep::OutputSweeper;
use lightning_net_tokio::SocketDescriptor;
use lightning_transaction_sync::EsploraSyncClient;
use bitcoin::secp256k1::PublicKey;
use bitcoin::OutPoint;
use std::sync::{Arc, Mutex, RwLock};
pub(crate) type DynStore = dyn KVStore + Sync + Send;
pub(crate) type ChainMonitor = chainmonitor::ChainMonitor<
InMemorySigner,
Arc<ChainSource>,
Arc<Broadcaster>,
Arc<FeeEstimator>,
Arc<FilesystemLogger>,
Arc<DynStore>,
>;
pub(crate) type PeerManager = lightning::ln::peer_handler::PeerManager<
SocketDescriptor,
Arc<ChannelManager>,
Arc<dyn RoutingMessageHandler + Send + Sync>,
Arc<OnionMessenger>,
Arc<FilesystemLogger>,
Arc<NodeCustomMessageHandler<Arc<FilesystemLogger>>>,
Arc<KeysManager>,
>;
pub(crate) type ChainSource = EsploraSyncClient<Arc<FilesystemLogger>>;
pub(crate) type LiquidityManager =
lightning_liquidity::LiquidityManager<Arc<KeysManager>, Arc<ChannelManager>, Arc<ChainSource>>;
pub(crate) type ChannelManager = lightning::ln::channelmanager::ChannelManager<
Arc<ChainMonitor>,
Arc<Broadcaster>,
Arc<KeysManager>,
Arc<KeysManager>,
Arc<KeysManager>,
Arc<FeeEstimator>,
Arc<Router>,
Arc<FilesystemLogger>,
>;
pub(crate) type Broadcaster = crate::tx_broadcaster::TransactionBroadcaster<Arc<FilesystemLogger>>;
pub(crate) type FeeEstimator = crate::fee_estimator::OnchainFeeEstimator<Arc<FilesystemLogger>>;
pub(crate) type Wallet = crate::wallet::Wallet<
bdk::database::SqliteDatabase,
Arc<Broadcaster>,
Arc<FeeEstimator>,
Arc<FilesystemLogger>,
>;
pub(crate) type KeysManager = crate::wallet::WalletKeysManager<
bdk::database::SqliteDatabase,
Arc<Broadcaster>,
Arc<FeeEstimator>,
Arc<FilesystemLogger>,
>;
pub(crate) type Router = DefaultRouter<
Arc<Graph>,
Arc<FilesystemLogger>,
Arc<KeysManager>,
Arc<Mutex<Scorer>>,
ProbabilisticScoringFeeParameters,
Scorer,
>;
pub(crate) type Scorer = ProbabilisticScorer<Arc<Graph>, Arc<FilesystemLogger>>;
pub(crate) type Graph = gossip::NetworkGraph<Arc<FilesystemLogger>>;
pub(crate) type UtxoLookup = dyn lightning::routing::utxo::UtxoLookup + Send + Sync;
pub(crate) type P2PGossipSync =
lightning::routing::gossip::P2PGossipSync<Arc<Graph>, Arc<UtxoLookup>, Arc<FilesystemLogger>>;
pub(crate) type RapidGossipSync =
lightning_rapid_gossip_sync::RapidGossipSync<Arc<Graph>, Arc<FilesystemLogger>>;
pub(crate) type GossipSync = lightning_background_processor::GossipSync<
Arc<P2PGossipSync>,
Arc<RapidGossipSync>,
Arc<Graph>,
Arc<UtxoLookup>,
Arc<FilesystemLogger>,
>;
pub(crate) type OnionMessenger = lightning::onion_message::messenger::OnionMessenger<
Arc<KeysManager>,
Arc<KeysManager>,
Arc<FilesystemLogger>,
Arc<ChannelManager>,
Arc<MessageRouter>,
Arc<ChannelManager>,
IgnoringMessageHandler,
>;
pub(crate) type MessageRouter = lightning::onion_message::messenger::DefaultMessageRouter<
Arc<Graph>,
Arc<FilesystemLogger>,
Arc<KeysManager>,
>;
pub(crate) type Sweeper = OutputSweeper<
Arc<Broadcaster>,
Arc<KeysManager>,
Arc<FeeEstimator>,
Arc<ChainSource>,
Arc<DynStore>,
Arc<FilesystemLogger>,
Arc<KeysManager>,
>;
pub(crate) type BumpTransactionEventHandler =
lightning::events::bump_transaction::BumpTransactionEventHandler<
Arc<Broadcaster>,
Arc<lightning::events::bump_transaction::Wallet<Arc<Wallet>, Arc<FilesystemLogger>>>,
Arc<KeysManager>,
Arc<FilesystemLogger>,
>;
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct UserChannelId(pub u128);
impl Writeable for UserChannelId {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), lightning::io::Error> {
Ok(self.0.write(writer)?)
}
}
impl Readable for UserChannelId {
fn read<R: lightning::io::Read>(
reader: &mut R,
) -> Result<Self, lightning::ln::msgs::DecodeError> {
Ok(Self(Readable::read(reader)?))
}
}
#[derive(Debug, Clone)]
pub struct ChannelDetails {
pub channel_id: ChannelId,
pub counterparty_node_id: PublicKey,
pub funding_txo: Option<OutPoint>,
pub channel_value_sats: u64,
pub unspendable_punishment_reserve: Option<u64>,
pub user_channel_id: UserChannelId,
pub feerate_sat_per_1000_weight: u32,
pub outbound_capacity_msat: u64,
pub inbound_capacity_msat: u64,
pub confirmations_required: Option<u32>,
pub confirmations: Option<u32>,
pub is_outbound: bool,
pub is_channel_ready: bool,
pub is_usable: bool,
pub is_public: bool,
pub cltv_expiry_delta: Option<u16>,
pub counterparty_unspendable_punishment_reserve: u64,
pub counterparty_outbound_htlc_minimum_msat: Option<u64>,
pub counterparty_outbound_htlc_maximum_msat: Option<u64>,
pub counterparty_forwarding_info_fee_base_msat: Option<u32>,
pub counterparty_forwarding_info_fee_proportional_millionths: Option<u32>,
pub counterparty_forwarding_info_cltv_expiry_delta: Option<u16>,
pub next_outbound_htlc_limit_msat: u64,
pub next_outbound_htlc_minimum_msat: u64,
pub force_close_spend_delay: Option<u16>,
pub inbound_htlc_minimum_msat: u64,
pub inbound_htlc_maximum_msat: Option<u64>,
pub config: Arc<ChannelConfig>,
}
impl From<LdkChannelDetails> for ChannelDetails {
fn from(value: LdkChannelDetails) -> Self {
ChannelDetails {
channel_id: value.channel_id,
counterparty_node_id: value.counterparty.node_id,
funding_txo: value.funding_txo.map(|o| o.into_bitcoin_outpoint()),
channel_value_sats: value.channel_value_satoshis,
unspendable_punishment_reserve: value.unspendable_punishment_reserve,
user_channel_id: UserChannelId(value.user_channel_id),
feerate_sat_per_1000_weight: value.feerate_sat_per_1000_weight.unwrap(),
outbound_capacity_msat: value.outbound_capacity_msat,
inbound_capacity_msat: value.inbound_capacity_msat,
confirmations_required: value.confirmations_required,
confirmations: value.confirmations,
is_outbound: value.is_outbound,
is_channel_ready: value.is_channel_ready,
is_usable: value.is_usable,
is_public: value.is_public,
cltv_expiry_delta: value.config.map(|c| c.cltv_expiry_delta),
counterparty_unspendable_punishment_reserve: value
.counterparty
.unspendable_punishment_reserve,
counterparty_outbound_htlc_minimum_msat: value.counterparty.outbound_htlc_minimum_msat,
counterparty_outbound_htlc_maximum_msat: value.counterparty.outbound_htlc_maximum_msat,
counterparty_forwarding_info_fee_base_msat: value
.counterparty
.forwarding_info
.as_ref()
.map(|f| f.fee_base_msat),
counterparty_forwarding_info_fee_proportional_millionths: value
.counterparty
.forwarding_info
.as_ref()
.map(|f| f.fee_proportional_millionths),
counterparty_forwarding_info_cltv_expiry_delta: value
.counterparty
.forwarding_info
.as_ref()
.map(|f| f.cltv_expiry_delta),
next_outbound_htlc_limit_msat: value.next_outbound_htlc_limit_msat,
next_outbound_htlc_minimum_msat: value.next_outbound_htlc_minimum_msat,
force_close_spend_delay: value.force_close_spend_delay,
inbound_htlc_minimum_msat: value.inbound_htlc_minimum_msat.unwrap_or(0),
inbound_htlc_maximum_msat: value.inbound_htlc_maximum_msat,
config: value.config.map(|c| Arc::new(c.into())).unwrap(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PeerDetails {
pub node_id: PublicKey,
pub address: SocketAddress,
pub is_persisted: bool,
pub is_connected: bool,
}
#[derive(Debug)]
pub struct ChannelConfig {
inner: RwLock<LdkChannelConfig>,
}
impl Clone for ChannelConfig {
fn clone(&self) -> Self {
self.inner.read().unwrap().clone().into()
}
}
impl ChannelConfig {
pub fn new() -> Self {
Self::default()
}
pub fn forwarding_fee_proportional_millionths(&self) -> u32 {
self.inner.read().unwrap().forwarding_fee_proportional_millionths
}
pub fn set_forwarding_fee_proportional_millionths(&self, value: u32) {
self.inner.write().unwrap().forwarding_fee_proportional_millionths = value;
}
pub fn forwarding_fee_base_msat(&self) -> u32 {
self.inner.read().unwrap().forwarding_fee_base_msat
}
pub fn set_forwarding_fee_base_msat(&self, fee_msat: u32) {
self.inner.write().unwrap().forwarding_fee_base_msat = fee_msat;
}
pub fn cltv_expiry_delta(&self) -> u16 {
self.inner.read().unwrap().cltv_expiry_delta
}
pub fn set_cltv_expiry_delta(&self, value: u16) {
self.inner.write().unwrap().cltv_expiry_delta = value;
}
pub fn force_close_avoidance_max_fee_satoshis(&self) -> u64 {
self.inner.read().unwrap().force_close_avoidance_max_fee_satoshis
}
pub fn set_force_close_avoidance_max_fee_satoshis(&self, value_sat: u64) {
self.inner.write().unwrap().force_close_avoidance_max_fee_satoshis = value_sat;
}
pub fn accept_underpaying_htlcs(&self) -> bool {
self.inner.read().unwrap().accept_underpaying_htlcs
}
pub fn set_accept_underpaying_htlcs(&self, value: bool) {
self.inner.write().unwrap().accept_underpaying_htlcs = value;
}
pub fn set_max_dust_htlc_exposure_from_fixed_limit(&self, limit_msat: u64) {
self.inner.write().unwrap().max_dust_htlc_exposure =
LdkMaxDustHTLCExposure::FixedLimitMsat(limit_msat);
}
pub fn set_max_dust_htlc_exposure_from_fee_rate_multiplier(&self, multiplier: u64) {
self.inner.write().unwrap().max_dust_htlc_exposure =
LdkMaxDustHTLCExposure::FeeRateMultiplier(multiplier);
}
}
impl From<LdkChannelConfig> for ChannelConfig {
fn from(value: LdkChannelConfig) -> Self {
Self { inner: RwLock::new(value) }
}
}
impl From<ChannelConfig> for LdkChannelConfig {
fn from(value: ChannelConfig) -> Self {
*value.inner.read().unwrap()
}
}
impl Default for ChannelConfig {
fn default() -> Self {
LdkChannelConfig::default().into()
}
}