create runtime state

Author: joostjager

lightning/src/util/sweep.rs

@@ -350,7 +350,7 @@ where
 	L::Target: Logger,
 	O::Target: OutputSpender,
 {
-	sweeper_state: Mutex<SweeperState>,
+	sweeper_state: Mutex<RuntimeSweeperState>,
 	broadcaster: B,
 	fee_estimator: E,
 	chain_data_source: Option<F>,
@@ -497,7 +497,10 @@ where
 		output_spender: O, change_destination_source: D, kv_store: K, logger: L,
 	) -> Self {
 		let outputs = Vec::new();
-		let sweeper_state = Mutex::new(SweeperState { outputs, best_block, sweep_pending: false });
+		let sweeper_state = Mutex::new(RuntimeSweeperState {
+			persistent: SweeperState { outputs, best_block },
+			sweep_pending: false,
+		});
 		Self {
 			sweeper_state,
 			broadcaster,
@@ -541,7 +544,7 @@ where
 			return Ok(());
 		}
 
-		let mut state_lock = self.sweeper_state.lock().unwrap();
+		let state_lock = &mut self.sweeper_state.lock().unwrap().persistent;
 		for descriptor in relevant_descriptors {
 			let output_info = TrackedSpendableOutput {
 				descriptor,
@@ -558,20 +561,20 @@ where
 
 			state_lock.outputs.push(output_info);
 		}
-		self.persist_state(&*state_lock).map_err(|e| {
+		self.persist_state(&state_lock).map_err(|e| {
 			log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e);
 		})
 	}
 
 	/// Returns a list of the currently tracked spendable outputs.
 	pub fn tracked_spendable_outputs(&self) -> Vec<TrackedSpendableOutput> {
-		self.sweeper_state.lock().unwrap().outputs.clone()
+		self.sweeper_state.lock().unwrap().persistent.outputs.clone()
 	}
 
 	/// Gets the latest best block which was connected either via the [`Listen`] or
 	/// [`Confirm`] interfaces.
 	pub fn current_best_block(&self) -> BestBlock {
-		self.sweeper_state.lock().unwrap().best_block
+		self.sweeper_state.lock().unwrap().persistent.best_block
 	}
 
 	/// Regenerates and broadcasts the spending transaction for any outputs that are pending
@@ -604,8 +607,9 @@ where
 				return Ok(());
 			}
 
-			let cur_height = sweeper_state.best_block.height;
-			let has_respends = sweeper_state.outputs.iter().any(|o| filter_fn(o, cur_height));
+			let cur_height = sweeper_state.persistent.best_block.height;
+			let has_respends =
+				sweeper_state.persistent.outputs.iter().any(|o| filter_fn(o, cur_height));
 			if !has_respends {
 				return Ok(());
 			}
@@ -620,10 +624,12 @@ where
 
 		// Sweep the outputs.
 		{
-			let mut sweeper_state = self.sweeper_state.lock().unwrap();
+			let mut runtime_sweeper_state = self.sweeper_state.lock().unwrap();
 
 			// Always allow a new sweep after this spend, also in the error case.
-			sweeper_state.sweep_pending = false;
+			runtime_sweeper_state.sweep_pending = false;
+
+			let sweeper_state = &mut runtime_sweeper_state.persistent;
 
 			let change_destination_script = change_destination_script_result?;
 
@@ -643,7 +649,7 @@ where
 			}
 
 			let spending_tx = match self.spend_outputs(
-				&*sweeper_state,
+				sweeper_state,
 				&respend_descriptors,
 				change_destination_script,
 			) {
@@ -674,7 +680,7 @@ where
 				output_info.status.broadcast(cur_hash, cur_height, spending_tx.clone());
 			}
 
-			self.persist_state(&*sweeper_state).map_err(|e| {
+			self.persist_state(&sweeper_state).map_err(|e| {
 				log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e);
 			})?;
 
@@ -779,22 +785,22 @@ where
 	fn filtered_block_connected(
 		&self, header: &Header, txdata: &chain::transaction::TransactionData, height: u32,
 	) {
-		let mut state_lock = self.sweeper_state.lock().unwrap();
+		let state_lock = &mut self.sweeper_state.lock().unwrap().persistent;
 		assert_eq!(state_lock.best_block.block_hash, header.prev_blockhash,
 			"Blocks must be connected in chain-order - the connected header must build on the last connected header");
 		assert_eq!(state_lock.best_block.height, height - 1,
 			"Blocks must be connected in chain-order - the connected block height must be one greater than the previous height");
 
-		self.transactions_confirmed_internal(&mut *state_lock, header, txdata, height);
-		self.best_block_updated_internal(&mut *state_lock, header, height);
+		self.transactions_confirmed_internal(state_lock, header, txdata, height);
+		self.best_block_updated_internal(state_lock, header, height);
 
-		let _ = self.persist_state(&*state_lock).map_err(|e| {
+		let _ = self.persist_state(&state_lock).map_err(|e| {
 			log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e);
 		});
 	}
 
 	fn block_disconnected(&self, header: &Header, height: u32) {
-		let mut state_lock = self.sweeper_state.lock().unwrap();
+		let state_lock = &mut self.sweeper_state.lock().unwrap().persistent;
 
 		let new_height = height - 1;
 		let block_hash = header.block_hash();
@@ -832,15 +838,15 @@ where
 	fn transactions_confirmed(
 		&self, header: &Header, txdata: &chain::transaction::TransactionData, height: u32,
 	) {
-		let mut state_lock = self.sweeper_state.lock().unwrap();
-		self.transactions_confirmed_internal(&mut *state_lock, header, txdata, height);
-		self.persist_state(&*state_lock).unwrap_or_else(|e| {
+		let state_lock = &mut self.sweeper_state.lock().unwrap().persistent;
+		self.transactions_confirmed_internal(state_lock, header, txdata, height);
+		self.persist_state(state_lock).unwrap_or_else(|e| {
 			log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e);
 		});
 	}
 
 	fn transaction_unconfirmed(&self, txid: &Txid) {
-		let mut state_lock = self.sweeper_state.lock().unwrap();
+		let state_lock = &mut self.sweeper_state.lock().unwrap().persistent;
 
 		// Get what height was unconfirmed.
 		let unconf_height = state_lock
@@ -857,22 +863,22 @@ where
 				.filter(|o| o.status.confirmation_height() >= Some(unconf_height))
 				.for_each(|o| o.status.unconfirmed());
 
-			self.persist_state(&*state_lock).unwrap_or_else(|e| {
+			self.persist_state(state_lock).unwrap_or_else(|e| {
 				log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e);
 			});
 		}
 	}
 
 	fn best_block_updated(&self, header: &Header, height: u32) {
-		let mut state_lock = self.sweeper_state.lock().unwrap();
-		self.best_block_updated_internal(&mut *state_lock, header, height);
-		let _ = self.persist_state(&*state_lock).map_err(|e| {
+		let state_lock = &mut self.sweeper_state.lock().unwrap().persistent;
+		self.best_block_updated_internal(state_lock, header, height);
+		let _ = self.persist_state(state_lock).map_err(|e| {
 			log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e);
 		});
 	}
 
 	fn get_relevant_txids(&self) -> Vec<(Txid, u32, Option<BlockHash>)> {
-		let state_lock = self.sweeper_state.lock().unwrap();
+		let state_lock = &self.sweeper_state.lock().unwrap().persistent;
 		state_lock
 			.outputs
 			.iter()
@@ -893,19 +899,21 @@ where
 	}
 }
 
+#[derive(Debug, Clone)]
+struct RuntimeSweeperState {
+	persistent: SweeperState,
+	sweep_pending: bool,
+}
+
 #[derive(Debug, Clone)]
 struct SweeperState {
 	outputs: Vec<TrackedSpendableOutput>,
 	best_block: BestBlock,
-	sweep_pending: bool,
 }
 
 impl_writeable_tlv_based!(SweeperState, {
 	(0, outputs, required_vec),
 	(2, best_block, required),
-
-	// TODO: Do not persist this field.
-	(4, sweep_pending, required),
 });
 
 /// A `enum` signalling to the [`OutputSweeper`] that it should delay spending an output until a
@@ -959,7 +967,8 @@ where
 			}
 		}
 
-		let sweeper_state = Mutex::new(state);
+		let sweeper_state =
+			Mutex::new(RuntimeSweeperState { persistent: state, sweep_pending: false });
 		Ok(Self {
 			sweeper_state,
 			broadcaster,
@@ -1007,7 +1016,8 @@ where
 			}
 		}
 
-		let sweeper_state = Mutex::new(state);
+		let sweeper_state =
+			Mutex::new(RuntimeSweeperState { persistent: state, sweep_pending: false });
 		Ok((
 			best_block,
 			OutputSweeper {