f get_channel_id -> channel_id

Author: dunxen

lightning-persister/src/fs_store.rs

@@ -450,7 +450,7 @@ mod tests {
 		check_closed_event!(nodes[1], 1, ClosureReason::HolderForceClosed, [nodes[0].node.get_our_node_id()], 100000);
 		let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap();
 		let update_map = nodes[1].chain_monitor.latest_monitor_update_id.lock().unwrap();
-		let update_id = update_map.get(&added_monitors[0].1.get_channel_id()).unwrap();
+		let update_id = update_map.get(&added_monitors[0].1.channel_id()).unwrap();
 
 		// Set the store's directory to read-only, which should result in
 		// returning an unrecoverable failure when we then attempt to persist a
@@ -489,7 +489,7 @@ mod tests {
 		check_closed_event!(nodes[1], 1, ClosureReason::HolderForceClosed, [nodes[0].node.get_our_node_id()], 100000);
 		let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap();
 		let update_map = nodes[1].chain_monitor.latest_monitor_update_id.lock().unwrap();
-		let update_id = update_map.get(&added_monitors[0].1.get_channel_id()).unwrap();
+		let update_id = update_map.get(&added_monitors[0].1.channel_id()).unwrap();
 
 		// Create the store with an invalid directory name and test that the
 		// channel fails to open because the directories fail to be created. There

lightning/src/chain/chainmonitor.rs

@@ -478,7 +478,7 @@ where C::Target: chain::Filter,
 	/// monitoring for on-chain state resolutions.
 	pub fn list_monitors(&self) -> Vec<(OutPoint, ChannelId)> {
 		self.monitors.read().unwrap().iter().map(|(outpoint, monitor_holder)| {
-			let channel_id = monitor_holder.monitor.get_channel_id();
+			let channel_id = monitor_holder.monitor.channel_id();
 			(*outpoint, channel_id)
 		}).collect()
 	}
@@ -546,7 +546,7 @@ where C::Target: chain::Filter,
 					// Completed event.
 					return Ok(());
 				}
-				let channel_id = monitor_data.monitor.get_channel_id();
+				let channel_id = monitor_data.monitor.channel_id();
 				self.pending_monitor_events.lock().unwrap().push((funding_txo, channel_id, vec![MonitorEvent::Completed {
 					funding_txo, channel_id,
 					monitor_update_id: monitor_data.monitor.get_latest_update_id(),
@@ -571,7 +571,7 @@ where C::Target: chain::Filter,
 	pub fn force_channel_monitor_updated(&self, funding_txo: OutPoint, monitor_update_id: u64) {
 		let monitors = self.monitors.read().unwrap();
 		let (counterparty_node_id, channel_id) = if let Some(m) = monitors.get(&funding_txo) {
-			(m.monitor.get_counterparty_node_id(), m.monitor.get_channel_id())
+			(m.monitor.get_counterparty_node_id(), m.monitor.channel_id())
 		} else {
 			(None, ChannelId::v1_from_funding_outpoint(funding_txo))
 		};
@@ -839,7 +839,7 @@ where C::Target: chain::Filter,
 				let monitor_events = monitor_state.monitor.get_and_clear_pending_monitor_events();
 				if monitor_events.len() > 0 {
 					let monitor_outpoint = monitor_state.monitor.get_funding_txo().0;
-					let monitor_channel_id = monitor_state.monitor.get_channel_id();
+					let monitor_channel_id = monitor_state.monitor.channel_id();
 					let counterparty_node_id = monitor_state.monitor.get_counterparty_node_id();
 					pending_monitor_events.push((monitor_outpoint, monitor_channel_id, monitor_events, counterparty_node_id));
 				}

lightning/src/chain/channelmonitor.rs

@@ -1165,7 +1165,7 @@ impl<'a, L: Deref> WithChannelMonitor<'a, L> where L::Target: Logger {
 
 	pub(crate) fn from_impl<S: WriteableEcdsaChannelSigner>(logger: &'a L, monitor_impl: &ChannelMonitorImpl<S>) -> Self {
 		let peer_id = monitor_impl.counterparty_node_id;
-		let channel_id = Some(monitor_impl.get_channel_id());
+		let channel_id = Some(monitor_impl.channel_id());
 		WithChannelMonitor {
 			logger, peer_id, channel_id,
 		}
@@ -1394,8 +1394,8 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 	}
 
 	/// Gets the channel_id of the channel this ChannelMonitor is monitoring for.
-	pub fn get_channel_id(&self) -> ChannelId {
-		self.inner.lock().unwrap().get_channel_id()
+	pub fn channel_id(&self) -> ChannelId {
+		self.inner.lock().unwrap().channel_id()
 	}
 
 	/// Gets a list of txids, with their output scripts (in the order they appear in the
@@ -2846,7 +2846,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 						self.queue_latest_holder_commitment_txn_for_broadcast(broadcaster, &bounded_fee_estimator, logger);
 					} else if !self.holder_tx_signed {
 						log_error!(logger, "WARNING: You have a potentially-unsafe holder commitment transaction available to broadcast");
-						log_error!(logger, "    in channel monitor for channel {}!", &self.get_channel_id());
+						log_error!(logger, "    in channel monitor for channel {}!", &self.channel_id());
 						log_error!(logger, "    Read the docs for ChannelMonitor::get_latest_holder_commitment_txn and take manual action!");
 					} else {
 						// If we generated a MonitorEvent::HolderForceClosed, the ChannelManager
@@ -2892,7 +2892,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 		&self.funding_info
 	}
 
-	pub fn get_channel_id(&self) -> ChannelId {
+	pub fn channel_id(&self) -> ChannelId {
 		self.channel_id
 	}
 
@@ -3658,7 +3658,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 				if prevout.txid == self.funding_info.0.txid && prevout.vout == self.funding_info.0.index as u32 {
 					let mut balance_spendable_csv = None;
 					log_info!(logger, "Channel {} closed by funding output spend in txid {}.",
-						&self.get_channel_id(), txid);
+						&self.channel_id(), txid);
 					self.funding_spend_seen = true;
 					let mut commitment_tx_to_counterparty_output = None;
 					if (tx.input[0].sequence.0 >> 8*3) as u8 == 0x80 && (tx.lock_time.to_consensus_u32() >> 8*3) as u8 == 0x20 {
@@ -3828,7 +3828,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 					log_debug!(logger, "Descriptor {} has got enough confirmations to be passed upstream", log_spendable!(descriptor));
 					self.pending_events.push(Event::SpendableOutputs {
 						outputs: vec![descriptor],
-						channel_id: Some(self.get_channel_id()),
+						channel_id: Some(self.channel_id()),
 					});
 					self.spendable_txids_confirmed.push(entry.txid);
 				},
@@ -5130,7 +5130,7 @@ mod tests {
 			&channel_parameters, ScriptBuf::new(), 46, 0, HolderCommitmentTransaction::dummy(&mut Vec::new()),
 			best_block, dummy_key, channel_id);
 
-		let chan_id = monitor.inner.lock().unwrap().get_channel_id();
+		let chan_id = monitor.inner.lock().unwrap().channel_id();
 		let context_logger = WithChannelMonitor::from(&logger, &monitor);
 		log_error!(context_logger, "This is an error");
 		log_warn!(context_logger, "This is an error");

lightning/src/ln/channelmanager.rs

@@ -10452,7 +10452,7 @@ where
 		for (funding_txo, monitor) in args.channel_monitors.iter() {
 			if !funding_txo_set.contains(funding_txo) {
 				let logger = WithChannelMonitor::from(&args.logger, monitor);
-				let channel_id = monitor.get_channel_id();
+				let channel_id = monitor.channel_id();
 				log_info!(logger, "Queueing monitor update to ensure missing channel {} is force closed",
 					&channel_id);
 				let monitor_update = ChannelMonitorUpdate {
@@ -10811,7 +10811,7 @@ where
 										if let HTLCForwardInfo::AddHTLC(htlc_info) = forward {
 											if pending_forward_matches_htlc(&htlc_info) {
 												log_info!(logger, "Removing pending to-forward HTLC with hash {} as it was forwarded to the closed channel {}",
-													&htlc.payment_hash, &monitor.get_channel_id());
+													&htlc.payment_hash, &monitor.channel_id());
 												false
 											} else { true }
 										} else { true }
@@ -10821,7 +10821,7 @@ where
 								pending_intercepted_htlcs.as_mut().unwrap().retain(|intercepted_id, htlc_info| {
 									if pending_forward_matches_htlc(&htlc_info) {
 										log_info!(logger, "Removing pending intercepted HTLC with hash {} as it was forwarded to the closed channel {}",
-											&htlc.payment_hash, &monitor.get_channel_id());
+											&htlc.payment_hash, &monitor.channel_id());
 										pending_events_read.retain(|(event, _)| {
 											if let Event::HTLCIntercepted { intercept_id: ev_id, .. } = event {
 												intercepted_id != ev_id
@@ -10845,7 +10845,7 @@ where
 									let compl_action =
 										EventCompletionAction::ReleaseRAAChannelMonitorUpdate {
 											channel_funding_outpoint: monitor.get_funding_txo().0,
-											channel_id: monitor.get_channel_id(),
+											channel_id: monitor.channel_id(),
 											counterparty_node_id: path.hops[0].pubkey,
 										};
 									pending_outbounds.claim_htlc(payment_id, preimage, session_priv,
@@ -10871,7 +10871,7 @@ where
 									// channel_id -> peer map entry).
 									counterparty_opt.is_none(),
 									counterparty_opt.cloned().or(monitor.get_counterparty_node_id()),
-									monitor.get_funding_txo().0, monitor.get_channel_id()))
+									monitor.get_funding_txo().0, monitor.channel_id()))
 							} else { None }
 						} else {
 							// If it was an outbound payment, we've handled it above - if a preimage

lightning/src/util/macro_logger.rs

@@ -55,7 +55,7 @@ impl<'a> core::fmt::Display for DebugFundingInfo<'a> {
 macro_rules! log_funding_info {
 	($key_storage: expr) => {
 		$crate::util::macro_logger::DebugFundingInfo(
-			&$key_storage.get_channel_id()
+			&$key_storage.channel_id()
 		)
 	}
 }

lightning/src/util/persist.rs

@@ -1052,9 +1052,9 @@ mod tests {
 		{
 			let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap();
 			let update_map = nodes[1].chain_monitor.latest_monitor_update_id.lock().unwrap();
-			let update_id = update_map.get(&added_monitors[0].1.get_channel_id()).unwrap();
+			let update_id = update_map.get(&added_monitors[0].1.channel_id()).unwrap();
 			let cmu_map = nodes[1].chain_monitor.monitor_updates.lock().unwrap();
-			let cmu = &cmu_map.get(&added_monitors[0].1.get_channel_id()).unwrap()[0];
+			let cmu = &cmu_map.get(&added_monitors[0].1.channel_id()).unwrap()[0];
 			let test_txo = OutPoint { txid: Txid::from_str("8984484a580b825b9972d7adb15050b3ab624ccd731946b3eeddb92f4e7ef6be").unwrap(), index: 0 };
 
 			let ro_persister = MonitorUpdatingPersister {

lightning/src/util/test_utils.rs

@@ -301,7 +301,7 @@ impl<'a> chain::Watch<TestChannelSigner> for TestChainMonitor<'a> {
 		let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<TestChannelSigner>)>::read(
 			&mut io::Cursor::new(&w.0), (self.keys_manager, self.keys_manager)).unwrap().1;
 		assert!(new_monitor == monitor);
-		self.latest_monitor_update_id.lock().unwrap().insert(monitor.get_channel_id(),
+		self.latest_monitor_update_id.lock().unwrap().insert(monitor.channel_id(),
 			(funding_txo, monitor.get_latest_update_id(), MonitorUpdateId::from_new_monitor(&monitor)));
 		self.added_monitors.lock().unwrap().push((funding_txo, monitor));
 		self.chain_monitor.watch_channel(funding_txo, new_monitor)