X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fevents%2Fmod.rs;h=887851864c97e84f62a7502673cd37e2259d316a;hb=642913c586fc71b0e413532e7dedcd19cfd4815c;hp=0350f816a48cc418ea6d41f7671d027a89bd71ec;hpb=7d2d04798daa9c78f183424f73f3fea6c8564573;p=rust-lightning diff --git a/lightning/src/events/mod.rs b/lightning/src/events/mod.rs index 0350f816..88785186 100644 --- a/lightning/src/events/mod.rs +++ b/lightning/src/events/mod.rs @@ -19,18 +19,20 @@ pub mod bump_transaction; pub use bump_transaction::BumpTransactionEvent; use crate::blinded_path::payment::{Bolt12OfferContext, Bolt12RefundContext, PaymentContext, PaymentContextRef}; -use crate::sign::SpendableOutputDescriptor; +use crate::chain::transaction; use crate::ln::channelmanager::{InterceptId, PaymentId, RecipientOnionFields}; use crate::ln::channel::FUNDING_CONF_DEADLINE_BLOCKS; use crate::ln::features::ChannelTypeFeatures; use crate::ln::msgs; use crate::ln::types::{ChannelId, PaymentPreimage, PaymentHash, PaymentSecret}; -use crate::chain::transaction; +use crate::offers::invoice::Bolt12Invoice; +use crate::onion_message::messenger::Responder; use crate::routing::gossip::NetworkUpdate; +use crate::routing::router::{BlindedTail, Path, RouteHop, RouteParameters}; +use crate::sign::SpendableOutputDescriptor; use crate::util::errors::APIError; use crate::util::ser::{BigSize, FixedLengthReader, Writeable, Writer, MaybeReadable, Readable, RequiredWrapper, UpgradableRequired, WithoutLength}; use crate::util::string::UntrustedString; -use crate::routing::router::{BlindedTail, Path, RouteHop, RouteParameters}; use bitcoin::{Transaction, OutPoint}; use bitcoin::blockdata::locktime::absolute::LockTime; @@ -38,6 +40,7 @@ use bitcoin::blockdata::script::ScriptBuf; use bitcoin::hashes::Hash; use bitcoin::hashes::sha256::Hash as Sha256; use bitcoin::secp256k1::PublicKey; +use bitcoin::transaction::Version; use crate::io; use core::time::Duration; use core::ops::Deref; @@ -277,7 +280,21 @@ pub enum ClosureReason { /// Closure generated from [`ChannelManager::force_close_channel`], called by the user. /// /// [`ChannelManager::force_close_channel`]: crate::ln::channelmanager::ChannelManager::force_close_channel. - HolderForceClosed, + HolderForceClosed { + /// Whether or not the latest transaction was broadcasted when the channel was force + /// closed. + /// + /// Channels closed using [`ChannelManager::force_close_broadcasting_latest_txn`] will have + /// this field set to true, whereas channels closed using [`ChannelManager::force_close_without_broadcasting_txn`] + /// or force-closed prior to being funded will have this field set to false. + /// + /// This will be `None` for objects generated or written by LDK 0.0.123 and + /// earlier. + /// + /// [`ChannelManager::force_close_broadcasting_latest_txn`]: crate::ln::channelmanager::ChannelManager::force_close_broadcasting_latest_txn. + /// [`ChannelManager::force_close_without_broadcasting_txn`]: crate::ln::channelmanager::ChannelManager::force_close_without_broadcasting_txn. + broadcasted_latest_txn: Option + }, /// The channel was closed after negotiating a cooperative close and we've now broadcasted /// the cooperative close transaction. Note the shutdown may have been initiated by us. /// @@ -330,6 +347,21 @@ pub enum ClosureReason { FundingBatchClosure, /// One of our HTLCs timed out in a channel, causing us to force close the channel. HTLCsTimedOut, + /// Our peer provided a feerate which violated our required minimum (fetched from our + /// [`FeeEstimator`] either as [`ConfirmationTarget::MinAllowedAnchorChannelRemoteFee`] or + /// [`ConfirmationTarget::MinAllowedNonAnchorChannelRemoteFee`]). + /// + /// [`FeeEstimator`]: crate::chain::chaininterface::FeeEstimator + /// [`ConfirmationTarget::MinAllowedAnchorChannelRemoteFee`]: crate::chain::chaininterface::ConfirmationTarget::MinAllowedAnchorChannelRemoteFee + /// [`ConfirmationTarget::MinAllowedNonAnchorChannelRemoteFee`]: crate::chain::chaininterface::ConfirmationTarget::MinAllowedNonAnchorChannelRemoteFee + PeerFeerateTooLow { + /// The feerate on our channel set by our peer. + peer_feerate_sat_per_kw: u32, + /// The required feerate we enforce, from our [`FeeEstimator`]. + /// + /// [`FeeEstimator`]: crate::chain::chaininterface::FeeEstimator + required_feerate_sat_per_kw: u32, + }, } impl core::fmt::Display for ClosureReason { @@ -339,7 +371,14 @@ impl core::fmt::Display for ClosureReason { ClosureReason::CounterpartyForceClosed { peer_msg } => { f.write_fmt(format_args!("counterparty force-closed with message: {}", peer_msg)) }, - ClosureReason::HolderForceClosed => f.write_str("user force-closed the channel"), + ClosureReason::HolderForceClosed { broadcasted_latest_txn } => { + f.write_str("user force-closed the channel")?; + if let Some(brodcasted) = broadcasted_latest_txn { + write!(f, " and {} the latest transaction", if *brodcasted { "broadcasted" } else { "elected not to broadcast" }) + } else { + Ok(()) + } + }, ClosureReason::LegacyCooperativeClosure => f.write_str("the channel was cooperatively closed"), ClosureReason::CounterpartyInitiatedCooperativeClosure => f.write_str("the channel was cooperatively closed by our peer"), ClosureReason::LocallyInitiatedCooperativeClosure => f.write_str("the channel was cooperatively closed by us"), @@ -354,6 +393,11 @@ impl core::fmt::Display for ClosureReason { ClosureReason::CounterpartyCoopClosedUnfundedChannel => f.write_str("the peer requested the unfunded channel be closed"), ClosureReason::FundingBatchClosure => f.write_str("another channel in the same funding batch closed"), ClosureReason::HTLCsTimedOut => f.write_str("htlcs on the channel timed out"), + ClosureReason::PeerFeerateTooLow { peer_feerate_sat_per_kw, required_feerate_sat_per_kw } => + f.write_fmt(format_args!( + "peer provided a feerate ({} sat/kw) which was below our lower bound ({} sat/kw)", + peer_feerate_sat_per_kw, required_feerate_sat_per_kw, + )), } } } @@ -361,7 +405,7 @@ impl core::fmt::Display for ClosureReason { impl_writeable_tlv_based_enum_upgradable!(ClosureReason, (0, CounterpartyForceClosed) => { (1, peer_msg, required) }, (1, FundingTimedOut) => {}, - (2, HolderForceClosed) => {}, + (2, HolderForceClosed) => { (1, broadcasted_latest_txn, option) }, (6, CommitmentTxConfirmed) => {}, (4, LegacyCooperativeClosure) => {}, (8, ProcessingError) => { (1, err, required) }, @@ -372,6 +416,10 @@ impl_writeable_tlv_based_enum_upgradable!(ClosureReason, (17, CounterpartyInitiatedCooperativeClosure) => {}, (19, LocallyInitiatedCooperativeClosure) => {}, (21, HTLCsTimedOut) => {}, + (23, PeerFeerateTooLow) => { + (0, peer_feerate_sat_per_kw, required), + (2, required_feerate_sat_per_kw, required), + }, ); /// Intended destination of a failed HTLC as indicated in [`Event::HTLCHandlingFailed`]. @@ -690,6 +738,31 @@ pub enum Event { /// The `payment_id` to have been associated with payment for the requested invoice. payment_id: PaymentId, }, + /// Indicates a [`Bolt12Invoice`] in response to an [`InvoiceRequest`] or a [`Refund`] was + /// received. + /// + /// This event will only be generated if [`UserConfig::manually_handle_bolt12_invoices`] is set. + /// Use [`ChannelManager::send_payment_for_bolt12_invoice`] to pay the invoice or + /// [`ChannelManager::abandon_payment`] to abandon the associated payment. See those docs for + /// further details. + /// + /// [`InvoiceRequest`]: crate::offers::invoice_request::InvoiceRequest + /// [`Refund`]: crate::offers::refund::Refund + /// [`UserConfig::manually_handle_bolt12_invoices`]: crate::util::config::UserConfig::manually_handle_bolt12_invoices + /// [`ChannelManager::send_payment_for_bolt12_invoice`]: crate::ln::channelmanager::ChannelManager::send_payment_for_bolt12_invoice + /// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment + InvoiceReceived { + /// The `payment_id` associated with payment for the invoice. + payment_id: PaymentId, + /// The invoice to pay. + invoice: Bolt12Invoice, + /// A responder for replying with an [`InvoiceError`] if needed. + /// + /// `None` if the invoice wasn't sent with a reply path. + /// + /// [`InvoiceError`]: crate::offers::invoice_error::InvoiceError + responder: Option, + }, /// Indicates an outbound payment we made succeeded (i.e. it made it all the way to its target /// and we got back the payment preimage for it). /// @@ -716,6 +789,8 @@ pub enum Event { /// If the recipient or an intermediate node misbehaves and gives us free money, this may /// overstate the amount paid, though this is unlikely. /// + /// This is only `None` for payments initiated on LDK versions prior to 0.0.103. + /// /// [`Route::get_total_fees`]: crate::routing::router::Route::get_total_fees fee_paid_msat: Option, }, @@ -1446,7 +1521,15 @@ impl Writeable for Event { write_tlv_fields!(writer, { (0, peer_node_id, required), }); - } + }, + &Event::InvoiceReceived { ref payment_id, ref invoice, ref responder } => { + 41u8.write(writer)?; + write_tlv_fields!(writer, { + (0, payment_id, required), + (2, invoice, required), + (4, responder, option), + }) + }, // Note that, going forward, all new events must only write data inside of // `write_tlv_fields`. Versions 0.0.101+ will ignore odd-numbered events that write // data via `write_tlv_fields`. @@ -1670,7 +1753,7 @@ impl MaybeReadable for Event { 11u8 => { let mut f = || { let mut channel_id = ChannelId::new_zero(); - let mut transaction = Transaction{ version: 2, lock_time: LockTime::ZERO, input: Vec::new(), output: Vec::new() }; + let mut transaction = Transaction{ version: Version::TWO, lock_time: LockTime::ZERO, input: Vec::new(), output: Vec::new() }; read_tlv_fields!(reader, { (0, channel_id, required), (2, transaction, required), @@ -1883,6 +1966,21 @@ impl MaybeReadable for Event { }; f() }, + 41u8 => { + let mut f = || { + _init_and_read_len_prefixed_tlv_fields!(reader, { + (0, payment_id, required), + (2, invoice, required), + (4, responder, option), + }); + Ok(Some(Event::InvoiceReceived { + payment_id: payment_id.0.unwrap(), + invoice: invoice.0.unwrap(), + responder, + })) + }; + f() + }, // Versions prior to 0.0.100 did not ignore odd types, instead returning InvalidValue. // Version 0.0.100 failed to properly ignore odd types, possibly resulting in corrupt // reads.