Impl Clone and PartialEq for ChannelMonitor

lightning/src/chain/chainmonitor.rs

@@ -556,6 +556,25 @@ where C::Target: chain::Filter,
 	}
 }
 
+impl<ChannelSigner: WriteableEcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref> ChainMonitor<ChannelSigner, C, T, F, L, P>
+	where C::Target: chain::Filter,
+	      T::Target: BroadcasterInterface,
+	      F::Target: FeeEstimator,
+	      L::Target: Logger,
+	      P::Target: Persist<ChannelSigner>,
+	      ChannelSigner: Clone
+{
+	/// Gets all the funding outpoints with each [`ChannelMonitor`] being monitored.
+	///
+	/// Note that [`ChannelMonitor`]s are not removed when a channel is closed as they are always
+	/// monitoring for on-chain state resolutions.
+	pub fn get_monitors(&self) -> HashMap<OutPoint, ChannelMonitor<ChannelSigner>> {
+		self.monitors.read().unwrap().iter().map(|(outpoint, holder)| {
+			(*outpoint, holder.monitor.clone())
+		}).collect()
+	}
+}
+
 impl<ChannelSigner: WriteableEcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref>
 chain::Listen for ChainMonitor<ChannelSigner, C, T, F, L, P>
 where

lightning/src/chain/channelmonitor.rs

@@ -284,7 +284,7 @@ impl HolderSignedTx {
 
 /// We use this to track static counterparty commitment transaction data and to generate any
 /// justice or 2nd-stage preimage/timeout transactions.
-#[derive(PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq)]
 struct CounterpartyCommitmentParameters {
 	counterparty_delayed_payment_base_key: PublicKey,
 	counterparty_htlc_base_key: PublicKey,
@@ -338,7 +338,7 @@ impl Readable for CounterpartyCommitmentParameters {
 /// observed, as well as the transaction causing it.
 ///
 /// Used to determine when the on-chain event can be considered safe from a chain reorganization.
-#[derive(PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq)]
 struct OnchainEventEntry {
 	txid: Txid,
 	height: u32,
@@ -381,7 +381,7 @@ type CommitmentTxCounterpartyOutputInfo = Option<(u32, u64)>;
 
 /// Upon discovering of some classes of onchain tx by ChannelMonitor, we may have to take actions on it
 /// once they mature to enough confirmations (ANTI_REORG_DELAY)
-#[derive(PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq)]
 enum OnchainEvent {
 	/// An outbound HTLC failing after a transaction is confirmed. Used
 	///  * when an outbound HTLC output is spent by us after the HTLC timed out
@@ -652,7 +652,7 @@ pub enum Balance {
 }
 
 /// An HTLC which has been irrevocably resolved on-chain, and has reached ANTI_REORG_DELAY.
-#[derive(PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq)]
 struct IrrevocablyResolvedHTLC {
 	commitment_tx_output_idx: Option<u32>,
 	/// The txid of the transaction which resolved the HTLC, this may be a commitment (if the HTLC
@@ -725,7 +725,14 @@ pub struct ChannelMonitor<Signer: WriteableEcdsaChannelSigner> {
 	inner: Mutex<ChannelMonitorImpl<Signer>>,
 }
 
-#[derive(PartialEq)]
+impl<Signer: WriteableEcdsaChannelSigner> Clone for ChannelMonitor<Signer> where Signer: Clone {
+	fn clone(&self) -> Self {
+		let inner = self.inner.lock().unwrap().clone();
+		ChannelMonitor { inner: Mutex::new(inner) }
+	}
+}
+
+#[derive(Clone, PartialEq)]
 pub(crate) struct ChannelMonitorImpl<Signer: WriteableEcdsaChannelSigner> {
 	latest_update_id: u64,
 	commitment_transaction_number_obscure_factor: u64,
@@ -879,6 +886,18 @@ impl<Signer: WriteableEcdsaChannelSigner> PartialEq for ChannelMonitor<Signer> w
 	}
 }
 
+impl<Signer: WriteableEcdsaChannelSigner> PartialOrd for ChannelMonitor<Signer> where Signer: PartialEq {
+	fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+		let inner = self.inner.lock().unwrap();
+		let other_inner = other.inner.lock().unwrap();
+		if inner.get_funding_txo() != other_inner.get_funding_txo() {
+			return None;
+		}
+
+		inner.latest_update_id.partial_cmp(&other_inner.latest_update_id)
+	}
+}
+
 impl<Signer: WriteableEcdsaChannelSigner> Writeable for ChannelMonitor<Signer> {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
 		self.inner.lock().unwrap().write(writer)

lightning/src/chain/onchaintx.rs

@@ -56,7 +56,7 @@ const MAX_ALLOC_SIZE: usize = 64*1024;
 /// transaction causing it.
 ///
 /// Used to determine when the on-chain event can be considered safe from a chain reorganization.
-#[derive(PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq)]
 struct OnchainEventEntry {
 	txid: Txid,
 	height: u32,
@@ -76,7 +76,7 @@ impl OnchainEventEntry {
 
 /// Events for claims the [`OnchainTxHandler`] has generated. Once the events are considered safe
 /// from a chain reorg, the [`OnchainTxHandler`] will act accordingly.
-#[derive(PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq)]
 enum OnchainEvent {
 	/// A pending request has been claimed by a transaction spending the exact same set of outpoints
 	/// as the request. This claim can either be ours or from the counterparty. Once the claiming
@@ -179,6 +179,7 @@ impl Writeable for Option<Vec<Option<(usize, Signature)>>> {
 
 #[cfg(anchors)]
 /// The claim commonly referred to as the pre-signed second-stage HTLC transaction.
+#[derive(Clone, PartialEq, Eq)]
 pub(crate) struct ExternalHTLCClaim {
 	pub(crate) commitment_txid: Txid,
 	pub(crate) per_commitment_number: u64,
@@ -190,6 +191,7 @@ pub(crate) struct ExternalHTLCClaim {
 // Represents the different types of claims for which events are yielded externally to satisfy said
 // claims.
 #[cfg(anchors)]
+#[derive(Clone, PartialEq, Eq)]
 pub(crate) enum ClaimEvent {
 	/// Event yielded to signal that the commitment transaction fee must be bumped to claim any
 	/// encumbered funds and proceed to HTLC resolution, if any HTLCs exist.
@@ -223,6 +225,7 @@ type PackageID = [u8; 32];
 
 /// OnchainTxHandler receives claiming requests, aggregates them if it's sound, broadcast and
 /// do RBF bumping if possible.
+#[derive(Clone)]
 pub struct OnchainTxHandler<ChannelSigner: WriteableEcdsaChannelSigner> {
 	destination_script: Script,
 	holder_commitment: HolderCommitmentTransaction,