Rename PaymentClaimed to PaymentReceived

Author: tnull

fuzz/src/chanmon_consistency.rs

@@ -870,7 +870,7 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out) {
 							}
 						},
 						events::Event::PaymentSent { .. } => {},
-						events::Event::PaymentClaimed { .. } => {},
+						events::Event::PaymentReceived { .. } => {},
 						events::Event::PaymentPathSuccessful { .. } => {},
 						events::Event::PaymentPathFailed { .. } => {},
 						events::Event::ProbeSuccessful { .. } | events::Event::ProbeFailed { .. } => {

lightning/src/chain/chainmonitor.rs

@@ -788,7 +788,7 @@ mod tests {
 	use bitcoin::{BlockHeader, TxMerkleNode};
 	use bitcoin::hashes::Hash;
 	use crate::{check_added_monitors, check_closed_broadcast, check_closed_event};
-	use crate::{expect_payment_sent, expect_payment_claimed, expect_payment_sent_without_paths, expect_payment_path_successful, get_event_msg};
+	use crate::{expect_payment_sent, expect_payment_received, expect_payment_sent_without_paths, expect_payment_path_successful, get_event_msg};
 	use crate::{get_htlc_update_msgs, get_local_commitment_txn, get_revoke_commit_msgs, get_route_and_payment_hash, unwrap_send_err};
 	use crate::chain::{ChannelMonitorUpdateStatus, Confirm, Watch};
 	use crate::chain::channelmonitor::LATENCY_GRACE_PERIOD_BLOCKS;
@@ -818,10 +818,10 @@ mod tests {
 
 		nodes[1].node.claim_funds(payment_preimage_1);
 		check_added_monitors!(nodes[1], 1);
-		expect_payment_claimed!(nodes[1], payment_hash_1, 1_000_000);
+		expect_payment_received!(nodes[1], payment_hash_1, 1_000_000);
 		nodes[1].node.claim_funds(payment_preimage_2);
 		check_added_monitors!(nodes[1], 1);
-		expect_payment_claimed!(nodes[1], payment_hash_2, 1_000_000);
+		expect_payment_received!(nodes[1], payment_hash_2, 1_000_000);
 
 		chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
 
@@ -908,7 +908,7 @@ mod tests {
 		// First route a payment that we will claim on chain and give the recipient the preimage.
 		let (payment_preimage, payment_hash, _) = route_payment(&nodes[0], &[&nodes[1]], 1_000_000);
 		nodes[1].node.claim_funds(payment_preimage);
-		expect_payment_claimed!(nodes[1], payment_hash, 1_000_000);
+		expect_payment_received!(nodes[1], payment_hash, 1_000_000);
 		nodes[1].node.get_and_clear_pending_msg_events();
 		check_added_monitors!(nodes[1], 1);
 		let remote_txn = get_local_commitment_txn!(nodes[1], channel.2);

lightning/src/ln/chanmon_update_fail_tests.rs

@@ -133,7 +133,7 @@ fn test_monitor_and_persister_update_fail() {
 
 	// Try to update ChannelMonitor
 	nodes[1].node.claim_funds(preimage);
-	expect_payment_claimed!(nodes[1], payment_hash, 9_000_000);
+	expect_payment_received!(nodes[1], payment_hash, 9_000_000);
 	check_added_monitors!(nodes[1], 1);
 
 	let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
@@ -298,7 +298,7 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
 	// but nodes[0] won't respond since it is frozen.
 	nodes[1].node.claim_funds(payment_preimage_1);
 	check_added_monitors!(nodes[1], 1);
-	expect_payment_claimed!(nodes[1], payment_hash_1, 1_000_000);
+	expect_payment_received!(nodes[1], payment_hash_1, 1_000_000);
 
 	let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
 	assert_eq!(events_2.len(), 1);
@@ -1106,7 +1106,7 @@ fn test_monitor_update_fail_reestablish() {
 
 	nodes[2].node.claim_funds(payment_preimage);
 	check_added_monitors!(nodes[2], 1);
-	expect_payment_claimed!(nodes[2], payment_hash, 1_000_000);
+	expect_payment_received!(nodes[2], payment_hash, 1_000_000);
 
 	let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
 	assert!(updates.update_add_htlcs.is_empty());
@@ -1311,7 +1311,7 @@ fn claim_while_disconnected_monitor_update_fail() {
 
 	nodes[1].node.claim_funds(payment_preimage_1);
 	check_added_monitors!(nodes[1], 1);
-	expect_payment_claimed!(nodes[1], payment_hash_1, 1_000_000);
+	expect_payment_received!(nodes[1], payment_hash_1, 1_000_000);
 
 	nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: channelmanager::provided_init_features(), remote_network_address: None }).unwrap();
 	nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: channelmanager::provided_init_features(), remote_network_address: None }).unwrap();
@@ -1590,7 +1590,7 @@ fn test_monitor_update_fail_claim() {
 
 	chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress);
 	nodes[1].node.claim_funds(payment_preimage_1);
-	expect_payment_claimed!(nodes[1], payment_hash_1, 1_000_000);
+	expect_payment_received!(nodes[1], payment_hash_1, 1_000_000);
 	assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 	check_added_monitors!(nodes[1], 1);
 
@@ -1785,7 +1785,7 @@ fn monitor_update_claim_fail_no_response() {
 
 	chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress);
 	nodes[1].node.claim_funds(payment_preimage_1);
-	expect_payment_claimed!(nodes[1], payment_hash_1, 1_000_000);
+	expect_payment_received!(nodes[1], payment_hash_1, 1_000_000);
 	check_added_monitors!(nodes[1], 1);
 
 	assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
@@ -2103,7 +2103,7 @@ fn test_fail_htlc_on_broadcast_after_claim() {
 
 	nodes[2].node.claim_funds(payment_preimage);
 	check_added_monitors!(nodes[2], 1);
-	expect_payment_claimed!(nodes[2], payment_hash, 2000);
+	expect_payment_received!(nodes[2], payment_hash, 2000);
 
 	let cs_updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
 	nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &cs_updates.update_fulfill_htlcs[0]);
@@ -2271,7 +2271,7 @@ fn do_channel_holding_cell_serialize(disconnect: bool, reload_a: bool) {
 	chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress);
 	nodes[0].node.claim_funds(payment_preimage_0);
 	check_added_monitors!(nodes[0], 1);
-	expect_payment_claimed!(nodes[0], payment_hash_0, 100_000);
+	expect_payment_received!(nodes[0], payment_hash_0, 100_000);
 
 	nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send.msgs[0]);
 	nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &send.commitment_msg);
@@ -2455,7 +2455,7 @@ fn do_test_reconnect_dup_htlc_claims(htlc_status: HTLCStatusAtDupClaim, second_f
 	} else {
 		nodes[2].node.claim_funds(payment_preimage);
 		check_added_monitors!(nodes[2], 1);
-		expect_payment_claimed!(nodes[2], payment_hash, 100_000);
+		expect_payment_received!(nodes[2], payment_hash, 100_000);
 
 		let cs_updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
 		assert_eq!(cs_updates.update_fulfill_htlcs.len(), 1);
@@ -2632,15 +2632,15 @@ fn double_temp_error() {
 	// `claim_funds` results in a ChannelMonitorUpdate.
 	nodes[1].node.claim_funds(payment_preimage_1);
 	check_added_monitors!(nodes[1], 1);
-	expect_payment_claimed!(nodes[1], payment_hash_1, 1_000_000);
+	expect_payment_received!(nodes[1], payment_hash_1, 1_000_000);
 	let (funding_tx, latest_update_1, _) = nodes[1].chain_monitor.latest_monitor_update_id.lock().unwrap().get(&channel_id).unwrap().clone();
 
 	chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress);
 	// Previously, this would've panicked due to a double-call to `Channel::monitor_update_failed`,
 	// which had some asserts that prevented it from being called twice.
 	nodes[1].node.claim_funds(payment_preimage_2);
 	check_added_monitors!(nodes[1], 1);
-	expect_payment_claimed!(nodes[1], payment_hash_2, 1_000_000);
+	expect_payment_received!(nodes[1], payment_hash_2, 1_000_000);
 	chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
 
 	let (_, latest_update_2, _) = nodes[1].chain_monitor.latest_monitor_update_id.lock().unwrap().get(&channel_id).unwrap().clone();

lightning/src/ln/channelmanager.rs

@@ -3887,7 +3887,7 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F
 	///
 	/// While LDK will never claim a payment automatically on your behalf (i.e. without you calling
 	/// [`ChannelManager::claim_funds`]), you should still monitor for
-	/// [`events::Event::PaymentClaimed`] events even for payments you intend to fail, especially on
+	/// [`events::Event::PaymentReceived`] events even for payments you intend to fail, especially on
 	/// startup during which time claims that were in-progress at shutdown may be replayed.
 	pub fn fail_htlc_backwards(&self, payment_hash: &PaymentHash) {
 		let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(&self.total_consistency_lock, &self.persistence_notifier);
@@ -4175,7 +4175,7 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F
 	/// [`MessageSendEvent`]s needed to claim the payment.
 	///
 	/// Note that calling this method does *not* guarantee that the payment has been claimed. You
-	/// *must* wait for an [`Event::PaymentClaimed`] event which upon a successful claim will be
+	/// *must* wait for an [`Event::PaymentReceived`] event which upon a successful claim will be
 	/// provided to your [`EventHandler`] when [`process_pending_events`] is next called.
 	///
 	/// Note that if you did not set an `amount_msat` when calling [`create_inbound_payment`] or
@@ -4184,7 +4184,7 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F
 	/// the sender "proof-of-payment" when they did not fulfill the full expected payment.
 	///
 	/// [`Event::PaymentClaimable`]: crate::util::events::Event::PaymentClaimable
-	/// [`Event::PaymentClaimed`]: crate::util::events::Event::PaymentClaimed
+	/// [`Event::PaymentReceived`]: crate::util::events::Event::PaymentReceived
 	/// [`process_pending_events`]: EventsProvider::process_pending_events
 	/// [`create_inbound_payment`]: Self::create_inbound_payment
 	/// [`create_inbound_payment_for_hash`]: Self::create_inbound_payment_for_hash
@@ -4302,7 +4302,7 @@ impl<M: Deref, T: Deref, K: Deref, F: Deref, L: Deref> ChannelManager<M, T, K, F
 			}
 
 			if claimed_any_htlcs {
-				self.pending_events.lock().unwrap().push(events::Event::PaymentClaimed {
+				self.pending_events.lock().unwrap().push(events::Event::PaymentReceived {
 					receiver_node_id,
 					payment_hash,
 					purpose: payment_purpose,
@@ -7736,7 +7736,7 @@ impl<'a, M: Deref, T: Deref, K: Deref, F: Deref, L: Deref>
 							previous_hop_monitor.provide_payment_preimage(&payment_hash, &payment_preimage, &args.tx_broadcaster, &bounded_fee_estimator, &args.logger);
 						}
 					}
-					pending_events_read.push(events::Event::PaymentClaimed {
+					pending_events_read.push(events::Event::PaymentReceived {
 						receiver_node_id,
 						payment_hash,
 						purpose: payment_purpose,
@@ -7959,7 +7959,7 @@ mod tests {
 		// payment to be put in the holding cell, which confuses the test utilities. So we exchange the
 		// lightning messages manually.
 		nodes[1].node.claim_funds(payment_preimage);
-		expect_payment_claimed!(nodes[1], our_payment_hash, 200_000);
+		expect_payment_received!(nodes[1], our_payment_hash, 200_000);
 		check_added_monitors!(nodes[1], 2);
 
 		let bs_first_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
@@ -8542,7 +8542,7 @@ pub mod bench {
 				expect_pending_htlcs_forwardable!(NodeHolder { node: &$node_b });
 				expect_payment_claimable!(NodeHolder { node: &$node_b }, payment_hash, payment_secret, 10_000);
 				$node_b.claim_funds(payment_preimage);
-				expect_payment_claimed!(NodeHolder { node: &$node_b }, payment_hash, 10_000);
+				expect_payment_received!(NodeHolder { node: &$node_b }, payment_hash, 10_000);
 
 				match $node_b.get_and_clear_pending_msg_events().pop().unwrap() {
 					MessageSendEvent::UpdateHTLCs { node_id, updates } => {

lightning/src/ln/functional_test_utils.rs

@@ -1498,12 +1498,12 @@ macro_rules! expect_payment_claimable {
 
 #[macro_export]
 #[cfg(any(test, feature = "_bench_unstable", feature = "_test_utils"))]
-macro_rules! expect_payment_claimed {
+macro_rules! expect_payment_received {
 	($node: expr, $expected_payment_hash: expr, $expected_recv_value: expr) => {
 		let events = $node.node.get_and_clear_pending_events();
 		assert_eq!(events.len(), 1);
 		match events[0] {
-			$crate::util::events::Event::PaymentClaimed { ref payment_hash, amount_msat, .. } => {
+			$crate::util::events::Event::PaymentReceived { ref payment_hash, amount_msat, .. } => {
 				assert_eq!($expected_payment_hash, *payment_hash);
 				assert_eq!($expected_recv_value, amount_msat);
 			},
@@ -1838,10 +1838,10 @@ pub fn do_claim_payment_along_route<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>,
 	let claim_event = expected_paths[0].last().unwrap().node.get_and_clear_pending_events();
 	assert_eq!(claim_event.len(), 1);
 	match claim_event[0] {
-		Event::PaymentClaimed { purpose: PaymentPurpose::SpontaneousPayment(preimage), .. }|
-		Event::PaymentClaimed { purpose: PaymentPurpose::InvoicePayment { payment_preimage: Some(preimage), ..}, .. } =>
+		Event::PaymentReceived { purpose: PaymentPurpose::SpontaneousPayment(preimage), .. }|
+		Event::PaymentReceived { purpose: PaymentPurpose::InvoicePayment { payment_preimage: Some(preimage), ..}, .. } =>
 			assert_eq!(preimage, our_payment_preimage),
-		Event::PaymentClaimed { purpose: PaymentPurpose::InvoicePayment { .. }, payment_hash, .. } =>
+		Event::PaymentReceived { purpose: PaymentPurpose::InvoicePayment { .. }, payment_hash, .. } =>
 			assert_eq!(&payment_hash.0, &Sha256::hash(&our_payment_preimage.0)[..]),
 		_ => panic!(),
 	}