Increase the log level of several channelmonitor/onchain logs.

[rust-lightning] / lightning / src / chain / package.rs

diff --git a/lightning/src/chain/package.rs b/lightning/src/chain/package.rs
index a7339468991f93f462ab132ee6104b7860a4fb70..bda924d5565a0dcd15e7850854024d4ee582c2d9 100644 (file)
--- a/lightning/src/chain/package.rs
+++ b/lightning/src/chain/package.rs
@@ -404,65 +404,14 @@ impl PackageSolvingData {
        }
 }
 
-impl Writeable for PackageSolvingData {
-       fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
-               match self {
-                       PackageSolvingData::RevokedOutput(ref revoked_outp) => {
-                               0u8.write(writer)?;
-                               revoked_outp.write(writer)?;
-                       },
-                       PackageSolvingData::RevokedHTLCOutput(ref revoked_outp) => {
-                               1u8.write(writer)?;
-                               revoked_outp.write(writer)?;
-                       },
-                       PackageSolvingData::CounterpartyOfferedHTLCOutput(ref counterparty_outp) => {
-                               2u8.write(writer)?;
-                               counterparty_outp.write(writer)?;
-                       },
-                       PackageSolvingData::CounterpartyReceivedHTLCOutput(ref counterparty_outp) => {
-                               3u8.write(writer)?;
-                               counterparty_outp.write(writer)?;
-                       },
-                       PackageSolvingData::HolderHTLCOutput(ref holder_outp) => {
-                               4u8.write(writer)?;
-                               holder_outp.write(writer)?;
-                       },
-                       PackageSolvingData::HolderFundingOutput(ref funding_outp) => {
-                               5u8.write(writer)?;
-                               funding_outp.write(writer)?;
-                       }
-               }
-               Ok(())
-       }
-}
-
-impl Readable for PackageSolvingData {
-       fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
-               let byte = <u8 as Readable>::read(reader)?;
-               let solving_data = match byte {
-                       0 => {
-                               PackageSolvingData::RevokedOutput(Readable::read(reader)?)
-                       },
-                       1 => {
-                               PackageSolvingData::RevokedHTLCOutput(Readable::read(reader)?)
-                       },
-                       2 => {
-                               PackageSolvingData::CounterpartyOfferedHTLCOutput(Readable::read(reader)?)
-                       },
-                       3 => {
-                               PackageSolvingData::CounterpartyReceivedHTLCOutput(Readable::read(reader)?)
-                       },
-                       4 => {
-                               PackageSolvingData::HolderHTLCOutput(Readable::read(reader)?)
-                       },
-                       5 => {
-                               PackageSolvingData::HolderFundingOutput(Readable::read(reader)?)
-                       }
-                       _ => return Err(DecodeError::UnknownVersion)
-               };
-               Ok(solving_data)
-       }
-}
+impl_writeable_tlv_based_enum!(PackageSolvingData, ;
+       (0, RevokedOutput),
+       (1, RevokedHTLCOutput),
+       (2, CounterpartyOfferedHTLCOutput),
+       (3, CounterpartyReceivedHTLCOutput),
+       (4, HolderHTLCOutput),
+       (5, HolderFundingOutput),
+);
 
 /// A malleable package might be aggregated with other packages to save on fees.
 /// A untractable package has been counter-signed and aggregable will break cached counterparty
@@ -654,18 +603,18 @@ impl PackageTemplate {
                                        });
                                }
                                for (i, (outpoint, out)) in self.inputs.iter().enumerate() {
-                                       log_trace!(logger, "Adding claiming input for outpoint {}:{}", outpoint.txid, outpoint.vout);
+                                       log_debug!(logger, "Adding claiming input for outpoint {}:{}", outpoint.txid, outpoint.vout);
                                        if !out.finalize_input(&mut bumped_tx, i, onchain_handler) { return None; }
                                }
-                               log_trace!(logger, "Finalized transaction {} ready to broadcast", bumped_tx.txid());
+                               log_debug!(logger, "Finalized transaction {} ready to broadcast", bumped_tx.txid());
                                return Some(bumped_tx);
                        },
                        PackageMalleability::Untractable => {
                                debug_assert_eq!(value, 0, "value is ignored for non-malleable packages, should be zero to ensure callsites are correct");
                                if let Some((outpoint, outp)) = self.inputs.first() {
                                        if let Some(final_tx) = outp.get_finalized_tx(outpoint, onchain_handler) {
-                                               log_trace!(logger, "Adding claiming input for outpoint {}:{}", outpoint.txid, outpoint.vout);
-                                               log_trace!(logger, "Finalized transaction {} ready to broadcast", final_tx.txid());
+                                               log_debug!(logger, "Adding claiming input for outpoint {}:{}", outpoint.txid, outpoint.vout);
+                                               log_debug!(logger, "Finalized transaction {} ready to broadcast", final_tx.txid());
                                                return Some(final_tx);
                                        }
                                        return None;
@@ -845,13 +794,13 @@ fn feerate_bump<F: Deref, L: Deref>(predicted_weight: usize, input_amounts: u64,
                        // ...else just increase the previous feerate by 25% (because that's a nice number)
                        let new_fee = previous_feerate * (predicted_weight as u64) / 750;
                        if input_amounts <= new_fee {
-                               log_trace!(logger, "Can't 25% bump new claiming tx, amount {} is too small", input_amounts);
+                               log_warn!(logger, "Can't 25% bump new claiming tx, amount {} is too small", input_amounts);
                                return None;
                        }
                        new_fee
                }
        } else {
-               log_trace!(logger, "Can't new-estimation bump new claiming tx, amount {} is too small", input_amounts);
+               log_warn!(logger, "Can't new-estimation bump new claiming tx, amount {} is too small", input_amounts);
                return None;
        };