Maintain order of yielded claim events

Since the claim events are stored internally within a HashMap, they will
be yielded in a random order once dispatched. Claim events may be
invalidated if a conflicting claim has confirmed on-chain and we need to
generate a new claim event; the randomized order could result in the
new claim event being handled prior to the previous. To maintain the
order in which the claim events are generated, we track them in a
separate sequence vector.

Author: wpaulino

lightning/src/chain/onchaintx.rs

@@ -247,8 +247,14 @@ pub struct OnchainTxHandler<ChannelSigner: Sign> {
 	pub(crate) pending_claim_requests: HashMap<PackageID, PackageTemplate>,
 	#[cfg(not(test))]
 	pending_claim_requests: HashMap<PackageID, PackageTemplate>,
+
+	// Used to track external events that need to be forwarded to the `ChainMonitor`. We
+	// additionally maintain an ordered sequence of the events as they occur, such that we don't
+	// rely on the HashMap's randomized iterations.
 	#[cfg(anchors)]
 	pending_claim_events: HashMap<PackageID, ClaimEvent>,
+	#[cfg(anchors)]
+	pending_claim_events_sequence: Vec<PackageID>,
 
 	// Used to link outpoints claimed in a connected block to a pending claim request.
 	// Key is outpoint than monitor parsing has detected we have keys/scripts to claim
@@ -409,6 +415,8 @@ impl<'a, K: KeysInterface> ReadableArgs<(&'a K, u64, [u8; 32])> for OnchainTxHan
 			onchain_events_awaiting_threshold_conf,
 			#[cfg(anchors)]
 			pending_claim_events: HashMap::new(),
+			#[cfg(anchors)]
+			pending_claim_events_sequence: Vec::new(),
 			secp_ctx,
 		})
 	}
@@ -430,7 +438,8 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 			onchain_events_awaiting_threshold_conf: Vec::new(),
 			#[cfg(anchors)]
 			pending_claim_events: HashMap::new(),
-
+			#[cfg(anchors)]
+			pending_claim_events_sequence: Vec::new(),
 			secp_ctx,
 		}
 	}
@@ -445,9 +454,19 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 
 	#[cfg(anchors)]
 	pub(crate) fn get_and_clear_pending_claim_events(&mut self) -> Vec<ClaimEvent> {
-		let mut ret = HashMap::new();
-		swap(&mut ret, &mut self.pending_claim_events);
-		ret.into_iter().map(|(_, event)| event).collect::<Vec<_>>()
+		let mut set = HashMap::new();
+		swap(&mut set, &mut self.pending_claim_events);
+		let mut sequence = Vec::new();
+		swap(&mut sequence, &mut self.pending_claim_events_sequence);
+
+		let mut pending_claim_events = Vec::with_capacity(set.len());
+		for package_id in &sequence {
+			if !set.contains_key(package_id) {
+				continue;
+			}
+			pending_claim_events.push(set.remove(package_id).unwrap());
+		}
+		pending_claim_events
 	}
 
 	/// Lightning security model (i.e being able to redeem/timeout HTLC or penalize counterparty
@@ -692,6 +711,7 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 							},
 						};
 						self.pending_claim_events.insert(package_id, claim_event);
+						self.pending_claim_events_sequence.push(package_id);
 						package_id
 					},
 				};
@@ -813,6 +833,8 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 								self.claimable_outpoints.remove(&outpoint);
 								#[cfg(anchors)]
 								self.pending_claim_events.remove(&package_id);
+								#[cfg(anchors)]
+								self.pending_claim_events_sequence.retain(|id| *id != package_id);
 							}
 						}
 					},
@@ -849,6 +871,7 @@ impl<ChannelSigner: Sign> OnchainTxHandler<ChannelSigner> {
 					OnchainClaim::Event(claim_event) => {
 						log_info!(logger, "Yielding RBF-bumped onchain event to spend inputs {:?}", request.outpoints());
 						self.pending_claim_events.insert(*first_claim_txid, claim_event);
+						self.pending_claim_events_sequence.push(*first_claim_txid);
 					},
 				}
 				if let Some(request) = self.pending_claim_requests.get_mut(first_claim_txid) {