removes vector of u32

Author: SWvheerden

src/ln/channelmanager.rs

@@ -703,7 +703,9 @@ impl ChannelManager {
 
 	/// Force closes a channel, immediately broadcasting the latest local commitment transaction to
 	/// the chain and rejecting new HTLCs on the given channel.
-	pub fn force_close_channel(&self, channel_id: &[u8; 32], store_closed : bool) {
+	/// delay_tx_broadcast parameter is there to stop the immediate broadcast of the channel TX. This is delayed by one week.
+	/// Look in bolt spec under data loss protect.
+	pub fn force_close_channel(&self, channel_id: &[u8; 32], delay_tx_broadcast : bool) {
 		let _ = self.total_consistency_lock.read().unwrap();
 
 		let mut chan = {
@@ -720,7 +722,7 @@ impl ChannelManager {
 		};
 		log_trace!(self, "Force-closing channel {}", log_bytes!(channel_id[..]));
 		let mut shutdown_result = chan.force_shutdown();
-		if store_closed{
+		if delay_tx_broadcast{
 			shutdown_result.2 = false;
 			self.finish_force_close_channel(shutdown_result);
 			let mut chan_monitor = chan.get_channel_monitor();
@@ -3017,7 +3019,7 @@ impl<'a, R : ::std::io::Read> ReadableArgs<R, ChannelManagerReadArgs<'a>> for (S
 			claimable_htlcs.insert(payment_hash, previous_hops);
 		}
 
-		let mut channel_manager = ChannelManager {
+		let channel_manager = ChannelManager {
 			genesis_hash,
 			fee_estimator: args.fee_estimator,
 			monitor: args.monitor,

src/ln/channelmonitor.rs

@@ -394,9 +394,9 @@ pub struct ChannelMonitor {
 	pub(crate) last_block_hash: Sha256dHash,
 	secp_ctx: Secp256k1<secp256k1::All>, //TODO: dedup this a bit...
 
-	//this is all channels transactions that failed in the data_loss_protect protocol
-	//The first index is the height that we attempt to claim it at, this claimed height is by default one week later, and it is there to claim if the other party did not claim
-	transactions_awaiting_claiming : Vec<u32>,
+	//This is the block height blocks the finishing transactions from being claimed till the chain reaches the mentioned block height.
+	//If this is set to 0, it is not used at that moment.
+	blockheight_block : u32,
 
 	logger: Arc<Logger>,
 }
@@ -472,7 +472,7 @@ impl ChannelMonitor {
 
 			last_block_hash: Default::default(),
 			secp_ctx: Secp256k1::new(),
-			transactions_awaiting_claiming : Vec::new(),
+			blockheight_block : 0,
 			logger,
 		}
 	}
@@ -969,10 +969,7 @@ impl ChannelMonitor {
 
 		self.last_block_hash.write(writer)?;
 		self.destination_script.write(writer)?;
-		writer.write_all(&byte_utils::be64_to_array(self.transactions_awaiting_claiming.len() as u64))?;
-		for transaction in self.transactions_awaiting_claiming.iter(){
-			writer.write_all(&byte_utils::be32_to_array(*transaction))?;
-		};
+		writer.write_all(&byte_utils::be32_to_array(self.blockheight_block))?;
 
 		Ok(())
 	}
@@ -1701,22 +1698,18 @@ impl ChannelMonitor {
 
 	///this is used by the channel manager to add transactions that should only be broadcasted at a much later height
 	pub fn broadcast_transaction_at_height(&mut self, broadcast_height: u32) {
-		self.transactions_awaiting_claiming.push(broadcast_height);
+		self.blockheight_block = broadcast_height;
 	}
 
 	fn block_connected(&mut self, txn_matched: &[&Transaction], height: u32, block_hash: &Sha256dHash, broadcaster: &BroadcasterInterface)-> (Vec<(Sha256dHash, Vec<TxOut>)>, Vec<SpendableOutputDescriptor>, Vec<(HTLCSource, Option<PaymentPreimage>, PaymentHash)>) {
-		if !self.transactions_awaiting_claiming.is_empty() {
-			for i in 0..self.transactions_awaiting_claiming.len(){
-				if self.transactions_awaiting_claiming[i] >= height
-				{
-					let transactions = self.get_latest_local_commitment_txn();
-					let mut ref_transactions = Vec::new();
-					for trans in transactions.iter(){ref_transactions.push(trans)};
-					self.block_connected_logic(&ref_transactions[..], height, block_hash, broadcaster);
-					self.transactions_awaiting_claiming.remove(i);
-				};
-			};
-		}
+		if self.blockheight_block >= height //we dont need to check for 0, because if blockheight_block > height, 0 will be too
+		{
+			let transactions = self.get_latest_local_commitment_txn();
+			let mut ref_transactions = Vec::new();
+			for trans in transactions.iter(){ref_transactions.push(trans)};
+			self.block_connected_logic(&ref_transactions[..], height, block_hash, broadcaster);
+			self.blockheight_block = 0;
+		};
 		self.block_connected_logic(txn_matched, height, block_hash, broadcaster)
 	}
 
@@ -2199,12 +2192,7 @@ impl<R: ::std::io::Read> ReadableArgs<R, Arc<Logger>> for (Sha256dHash, ChannelM
 
 		let last_block_hash: Sha256dHash = Readable::read(reader)?;
 		let destination_script = Readable::read(reader)?;
-		let mut transactions_awaiting_claiming = Vec::new();
-		let transactions_awaiting_claiming_len: u64 = Readable::read(reader)?;
-		for _ in 0..transactions_awaiting_claiming_len {
-			let transaction: u32 = Readable::read(reader)?;
-			transactions_awaiting_claiming.push(transaction);
-		}
+		let blockheight_block: u32 = Readable::read(reader)?;
 
 		Ok((last_block_hash.clone(), ChannelMonitor {
 			commitment_transaction_number_obscure_factor,
@@ -2231,7 +2219,7 @@ impl<R: ::std::io::Read> ReadableArgs<R, Arc<Logger>> for (Sha256dHash, ChannelM
 			destination_script,
 			last_block_hash,
 			secp_ctx,
-			transactions_awaiting_claiming,
+			blockheight_block,
 			logger,
 		}))
 	}