wip

Author: joostjager

lightning/src/chain/channelmonitor.rs

@@ -2776,21 +2776,24 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitor<Signer> {
 impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 	fn check_encoded_channel_consistency(&self, encoded: &[u8]) {
 		let encoded_channel_reader = &mut &encoded[..];
-		let check_data = read_check_data(encoded_channel_reader).unwrap();
-
-		assert!(
-			check_data.cur_holder_commitment_transaction_number
-				== self.get_cur_holder_commitment_number()
-		);
-		assert!(
-			check_data.revoked_counterparty_commitment_transaction_number
-				== self.get_min_seen_secret()
-		);
-		assert!(
-			check_data.cur_counterparty_commitment_transaction_number
-				== self.get_cur_counterparty_commitment_number()
-		);
-		assert!(check_data.latest_monitor_update_id == self.get_latest_update_id());
+		let check_res = read_check_data(encoded_channel_reader);
+		if let Ok(check_data) = check_res {
+			debug_assert!(
+				check_data.cur_holder_commitment_transaction_number
+					== self.get_cur_holder_commitment_number()
+			);
+			debug_assert!(
+				check_data.revoked_counterparty_commitment_transaction_number
+					== self.get_min_seen_secret()
+			);
+			debug_assert!(
+				check_data.cur_counterparty_commitment_transaction_number
+					== self.get_cur_counterparty_commitment_number()
+			);
+			debug_assert!(check_data.latest_monitor_update_id == self.get_latest_update_id());
+		} else {
+			debug_assert!(false, "Failed to read check data from encoded channel");
+		}
 	}
 
 	fn update_encoded_channel(&mut self, encoded: Vec<u8>) {

lightning/src/ln/channel.rs

@@ -2153,7 +2153,7 @@ where
 					// Not having a signing session implies they've already sent `splice_locked`,
 					// which must always come after the initial commitment signed is sent.
 					.unwrap_or(true);
-				let res: Result<(Option<ChannelMonitor<<<SP as Deref>::Target as SignerProvider>::EcdsaSigner>>, Option<ChannelMonitorUpdate>), ChannelError> = if has_negotiated_pending_splice && !session_received_commitment_signed {
+				let res = if has_negotiated_pending_splice && !session_received_commitment_signed {
 					funded_channel
 						.splice_initial_commitment_signed(msg, fee_estimator, logger)
 						.map(|monitor_update_opt| (None, monitor_update_opt))
@@ -8355,7 +8355,7 @@ where
 						// `ChannelMonitorUpdate` to the user, making this one redundant, however
 						// there's no harm in including the extra `ChannelMonitorUpdateStep` here.
 						// We do not bother to track and include `payment_info` here, however.
-						let fulfill: UpdateFulfillFetch = self.get_update_fulfill_htlc(
+						let fulfill = self.get_update_fulfill_htlc(
 							htlc_id,
 							*payment_preimage,
 							None,
@@ -15615,30 +15615,24 @@ pub fn read_check_data<R: io::Read>(reader: &mut R) -> Result<ChannelStateCheckD
 		return Err(DecodeError::UnknownVersion);
 	}
 
-	// `user_id` used to be a single u64 value. In order to remain backwards compatible with
-	// versions prior to 0.0.113, the u128 is serialized as two separate u64 values. We read
-	// the low bytes now and the high bytes later.
-	let user_id_low: u64 = Readable::read(reader)?;
+	let _user_id_low: u64 = Readable::read(reader)?;
 
-	let mut config = LegacyChannelConfig::default();
-	{
-		// Read the 8 bytes of backwards-compatibility ChannelConfig data.
-		let mut _val: u64 = Readable::read(reader)?;
-	}
+	let mut _config = LegacyChannelConfig::default();
+	let mut _val: u64 = Readable::read(reader)?;
 
-	let channel_id: ChannelId = Readable::read(reader)?;
+	let _channel_id: ChannelId = Readable::read(reader)?;
 	let channel_state =
 		ChannelState::from_u32(Readable::read(reader)?).map_err(|_| DecodeError::InvalidValue)?;
-	let channel_value_satoshis: u64 = Readable::read(reader)?;
+	let _channel_value_satoshis: u64 = Readable::read(reader)?;
 
 	let latest_monitor_update_id = Readable::read(reader)?;
 
 	// Read the old serialization for shutdown_pubkey, preferring the TLV field later if set.
-	let mut shutdown_scriptpubkey = match <PublicKey as Readable>::read(reader) {
+	let mut _shutdown_scriptpubkey = match <PublicKey as Readable>::read(reader) {
 		Ok(pubkey) => Some(ShutdownScript::new_p2wpkh_from_pubkey(pubkey)),
 		Err(_) => None,
 	};
-	let destination_script: ScriptBuf = Readable::read(reader)?;
+	let _destination_script: ScriptBuf = Readable::read(reader)?;
 
 	let holder_commitment_next_transaction_number: u64 = Readable::read(reader)?;
 	let counterparty_next_commitment_transaction_number: u64 = Readable::read(reader)?;