Merge pull request #2595 from TheBlueMatt/2023-09-117-bindings-part1

Various cleanups to make bindings generation simpler

Author: TheBlueMatt

fuzz/src/chanmon_consistency.rs

@@ -155,7 +155,7 @@ impl chain::Watch<TestChannelSigner> for TestChainMonitor {
 		};
 		let deserialized_monitor = <(BlockHash, channelmonitor::ChannelMonitor<TestChannelSigner>)>::
 			read(&mut Cursor::new(&map_entry.get().1), (&*self.keys, &*self.keys)).unwrap().1;
-		deserialized_monitor.update_monitor(update, &&TestBroadcaster{}, &FuzzEstimator { ret_val: atomic::AtomicU32::new(253) }, &self.logger).unwrap();
+		deserialized_monitor.update_monitor(update, &&TestBroadcaster{}, &&FuzzEstimator { ret_val: atomic::AtomicU32::new(253) }, &self.logger).unwrap();
 		let mut ser = VecWriter(Vec::new());
 		deserialized_monitor.write(&mut ser).unwrap();
 		map_entry.insert((update.update_id, ser.0));

lightning-background-processor/src/lib.rs

@@ -1181,7 +1181,7 @@ mod tests {
 			let network_graph = Arc::new(NetworkGraph::new(network, logger.clone()));
 			let scorer = Arc::new(Mutex::new(TestScorer::new()));
 			let seed = [i as u8; 32];
-			let router = Arc::new(DefaultRouter::new(network_graph.clone(), logger.clone(), seed, scorer.clone(), ()));
+			let router = Arc::new(DefaultRouter::new(network_graph.clone(), logger.clone(), seed, scorer.clone(), Default::default()));
 			let chain_source = Arc::new(test_utils::TestChainSource::new(Network::Bitcoin));
 			let kv_store = Arc::new(FilesystemStore::new(format!("{}_persister_{}", &persist_dir, i).into()));
 			let now = Duration::from_secs(genesis_block.header.time as u64);

lightning-invoice/src/payment.rs

@@ -9,7 +9,8 @@
 
 //! Convenient utilities for paying Lightning invoices.
 
-use crate::{Bolt11Invoice, Vec};
+use crate::Bolt11Invoice;
+use crate::prelude::*;
 
 use bitcoin_hashes::Hash;
 

lightning/src/chain/chainmonitor.rs

@@ -324,7 +324,6 @@ where C::Target: chain::Filter,
 				if self.update_monitor_with_chain_data(header, best_height, txdata, &process, funding_outpoint, &monitor_state).is_err() {
 					// Take the monitors lock for writing so that we poison it and any future
 					// operations going forward fail immediately.
-					core::mem::drop(monitor_state);
 					core::mem::drop(monitor_lock);
 					let _poison = self.monitors.write().unwrap();
 					log_error!(self.logger, "{}", err_str);
@@ -767,7 +766,7 @@ where C::Target: chain::Filter,
 			Some(monitor_state) => {
 				let monitor = &monitor_state.monitor;
 				log_trace!(self.logger, "Updating ChannelMonitor for channel {}", log_funding_info!(monitor));
-				let update_res = monitor.update_monitor(update, &self.broadcaster, &*self.fee_estimator, &self.logger);
+				let update_res = monitor.update_monitor(update, &self.broadcaster, &self.fee_estimator, &self.logger);
 
 				let update_id = MonitorUpdateId::from_monitor_update(update);
 				let mut pending_monitor_updates = monitor_state.pending_monitor_updates.lock().unwrap();

lightning/src/chain/channelmonitor.rs

@@ -1311,7 +1311,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitor<Signer> {
 		&self,
 		updates: &ChannelMonitorUpdate,
 		broadcaster: &B,
-		fee_estimator: F,
+		fee_estimator: &F,
 		logger: &L,
 	) -> Result<(), ()>
 	where
@@ -2615,7 +2615,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 		self.pending_monitor_events.push(MonitorEvent::HolderForceClosed(self.funding_info.0));
 	}
 
-	pub fn update_monitor<B: Deref, F: Deref, L: Deref>(&mut self, updates: &ChannelMonitorUpdate, broadcaster: &B, fee_estimator: F, logger: &L) -> Result<(), ()>
+	pub fn update_monitor<B: Deref, F: Deref, L: Deref>(&mut self, updates: &ChannelMonitorUpdate, broadcaster: &B, fee_estimator: &F, logger: &L) -> Result<(), ()>
 	where B::Target: BroadcasterInterface,
 		F::Target: FeeEstimator,
 		L::Target: Logger,
@@ -2655,7 +2655,7 @@ impl<Signer: WriteableEcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 			panic!("Attempted to apply ChannelMonitorUpdates out of order, check the update_id before passing an update to update_monitor!");
 		}
 		let mut ret = Ok(());
-		let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&*fee_estimator);
+		let bounded_fee_estimator = LowerBoundedFeeEstimator::new(&**fee_estimator);
 		for update in updates.updates.iter() {
 			match update {
 				ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs, claimed_htlcs, nondust_htlc_sources } => {
@@ -4581,7 +4581,7 @@ mod tests {
 
 		let broadcaster = TestBroadcaster::with_blocks(Arc::clone(&nodes[1].blocks));
 		assert!(
-			pre_update_monitor.update_monitor(&replay_update, &&broadcaster, &chanmon_cfgs[1].fee_estimator, &nodes[1].logger)
+			pre_update_monitor.update_monitor(&replay_update, &&broadcaster, &&chanmon_cfgs[1].fee_estimator, &nodes[1].logger)
 			.is_err());
 		// Even though we error'd on the first update, we should still have generated an HTLC claim
 		// transaction

lightning/src/ln/channelmanager.rs

@@ -840,6 +840,9 @@ pub type SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, M, T, F, L> =
 	>;
 
 /// A trivial trait which describes any [`ChannelManager`].
+///
+/// This is not exported to bindings users as general cover traits aren't useful in other
+/// languages.
 pub trait AChannelManager {
 	/// A type implementing [`chain::Watch`].
 	type Watch: chain::Watch<Self::Signer> + ?Sized;

lightning/src/ln/outbound_payment.rs

@@ -594,10 +594,26 @@ impl RecipientOnionFields {
 	/// Note that if this field is non-empty, it will contain strictly increasing TLVs, each
 	/// represented by a `(u64, Vec<u8>)` for its type number and serialized value respectively.
 	/// This is validated when setting this field using [`Self::with_custom_tlvs`].
+	#[cfg(not(c_bindings))]
 	pub fn custom_tlvs(&self) -> &Vec<(u64, Vec<u8>)> {
 		&self.custom_tlvs
 	}
 
+	/// Gets the custom TLVs that will be sent or have been received.
+	///
+	/// Custom TLVs allow sending extra application-specific data with a payment. They provide
+	/// additional flexibility on top of payment metadata, as while other implementations may
+	/// require `payment_metadata` to reflect metadata provided in an invoice, custom TLVs
+	/// do not have this restriction.
+	///
+	/// Note that if this field is non-empty, it will contain strictly increasing TLVs, each
+	/// represented by a `(u64, Vec<u8>)` for its type number and serialized value respectively.
+	/// This is validated when setting this field using [`Self::with_custom_tlvs`].
+	#[cfg(c_bindings)]
+	pub fn custom_tlvs(&self) -> Vec<(u64, Vec<u8>)> {
+		self.custom_tlvs.clone()
+	}
+
 	/// When we have received some HTLC(s) towards an MPP payment, as we receive further HTLC(s) we
 	/// have to make sure that some fields match exactly across the parts. For those that aren't
 	/// required to match, if they don't match we should remove them so as to not expose data

lightning/src/ln/payment_tests.rs

@@ -3781,7 +3781,7 @@ fn test_retry_custom_tlvs() {
 		payment_hash, Some(payment_secret), events.pop().unwrap(), true, None).unwrap();
 	match payment_claimable {
 		Event::PaymentClaimable { onion_fields, .. } => {
-			assert_eq!(onion_fields.unwrap().custom_tlvs(), &custom_tlvs);
+			assert_eq!(&onion_fields.unwrap().custom_tlvs()[..], &custom_tlvs[..]);
 		},
 		_ => panic!("Unexpected event"),
 	};

lightning/src/offers/offer.rs

@@ -366,7 +366,7 @@ macro_rules! offer_accessors { ($self: ident, $contents: expr) => {
 	/// The chains that may be used when paying a requested invoice (e.g., bitcoin mainnet).
 	/// Payments must be denominated in units of the minimal lightning-payable unit (e.g., msats)
 	/// for the selected chain.
-	pub fn chains(&$self) -> Vec<$crate::bitcoin::blockdata::constants::ChainHash> {
+	pub fn chains(&$self) -> Vec<bitcoin::blockdata::constants::ChainHash> {
 		$contents.chains()
 	}
 
@@ -418,7 +418,7 @@ macro_rules! offer_accessors { ($self: ident, $contents: expr) => {
 	}
 
 	/// The public key used by the recipient to sign invoices.
-	pub fn signing_pubkey(&$self) -> $crate::bitcoin::secp256k1::PublicKey {
+	pub fn signing_pubkey(&$self) -> bitcoin::secp256k1::PublicKey {
 		$contents.signing_pubkey()
 	}
 } }

lightning/src/onion_message/messenger.rs

@@ -246,6 +246,64 @@ pub trait CustomOnionMessageHandler {
 	fn read_custom_message<R: io::Read>(&self, message_type: u64, buffer: &mut R) -> Result<Option<Self::CustomMessage>, msgs::DecodeError>;
 }
 
+
+/// Create an onion message with contents `message` to the destination of `path`.
+/// Returns (introduction_node_id, onion_msg)
+pub fn create_onion_message<ES: Deref, NS: Deref, T: CustomOnionMessageContents>(
+	entropy_source: &ES, node_signer: &NS, secp_ctx: &Secp256k1<secp256k1::All>,
+	path: OnionMessagePath, message: OnionMessageContents<T>, reply_path: Option<BlindedPath>,
+) -> Result<(PublicKey, msgs::OnionMessage), SendError>
+where
+	ES::Target: EntropySource,
+	NS::Target: NodeSigner,
+{
+	let OnionMessagePath { intermediate_nodes, mut destination } = path;
+	if let Destination::BlindedPath(BlindedPath { ref blinded_hops, .. }) = destination {
+		if blinded_hops.len() < 2 {
+			return Err(SendError::TooFewBlindedHops);
+		}
+	}
+
+	if message.tlv_type() < 64 { return Err(SendError::InvalidMessage) }
+
+	// If we are sending straight to a blinded path and we are the introduction node, we need to
+	// advance the blinded path by 1 hop so the second hop is the new introduction node.
+	if intermediate_nodes.len() == 0 {
+		if let Destination::BlindedPath(ref mut blinded_path) = destination {
+			let our_node_id = node_signer.get_node_id(Recipient::Node)
+				.map_err(|()| SendError::GetNodeIdFailed)?;
+			if blinded_path.introduction_node_id == our_node_id {
+				advance_path_by_one(blinded_path, node_signer, &secp_ctx)
+					.map_err(|()| SendError::BlindedPathAdvanceFailed)?;
+			}
+		}
+	}
+
+	let blinding_secret_bytes = entropy_source.get_secure_random_bytes();
+	let blinding_secret = SecretKey::from_slice(&blinding_secret_bytes[..]).expect("RNG is busted");
+	let (introduction_node_id, blinding_point) = if intermediate_nodes.len() != 0 {
+		(intermediate_nodes[0], PublicKey::from_secret_key(&secp_ctx, &blinding_secret))
+	} else {
+		match destination {
+			Destination::Node(pk) => (pk, PublicKey::from_secret_key(&secp_ctx, &blinding_secret)),
+			Destination::BlindedPath(BlindedPath { introduction_node_id, blinding_point, .. }) =>
+				(introduction_node_id, blinding_point),
+		}
+	};
+	let (packet_payloads, packet_keys) = packet_payloads_and_keys(
+		&secp_ctx, &intermediate_nodes, destination, message, reply_path, &blinding_secret)
+		.map_err(|e| SendError::Secp256k1(e))?;
+
+	let prng_seed = entropy_source.get_secure_random_bytes();
+	let onion_routing_packet = construct_onion_message_packet(
+		packet_payloads, packet_keys, prng_seed).map_err(|()| SendError::TooBigPacket)?;
+
+	Ok((introduction_node_id, msgs::OnionMessage {
+		blinding_point,
+		onion_routing_packet
+	}))
+}
+
 impl<ES: Deref, NS: Deref, L: Deref, MR: Deref, OMH: Deref, CMH: Deref>
 OnionMessenger<ES, NS, L, MR, OMH, CMH>
 where
@@ -283,13 +341,9 @@ where
 		&self, path: OnionMessagePath, message: OnionMessageContents<T>,
 		reply_path: Option<BlindedPath>
 	) -> Result<(), SendError> {
-		let (introduction_node_id, onion_msg) = Self::create_onion_message(
-			&self.entropy_source, 
-			&self.node_signer, 
-			&self.secp_ctx, 
-			path, 
-			message, 
-			reply_path
+		let (introduction_node_id, onion_msg) = create_onion_message(
+			&self.entropy_source, &self.node_signer, &self.secp_ctx,
+			path, message, reply_path
 		)?;
 
 		let mut pending_per_peer_msgs = self.pending_messages.lock().unwrap();
@@ -303,63 +357,6 @@ where
 		}
 	}
 
-	/// Create an onion message with contents `message` to the destination of `path`.
-	/// Returns (introduction_node_id, onion_msg)
-	pub fn create_onion_message<T: CustomOnionMessageContents>(
-		entropy_source: &ES, 
-		node_signer: &NS,
-		secp_ctx: &Secp256k1<secp256k1::All>,
-		path: OnionMessagePath, 
-		message: OnionMessageContents<T>,
-		reply_path: Option<BlindedPath>, 
-	) -> Result<(PublicKey, msgs::OnionMessage), SendError> {
-		let OnionMessagePath { intermediate_nodes, mut destination } = path;
-		if let Destination::BlindedPath(BlindedPath { ref blinded_hops, .. }) = destination {
-			if blinded_hops.len() < 2 {
-				return Err(SendError::TooFewBlindedHops);
-			}
-		}
-
-		if message.tlv_type() < 64 { return Err(SendError::InvalidMessage) }
-
-		// If we are sending straight to a blinded path and we are the introduction node, we need to
-		// advance the blinded path by 1 hop so the second hop is the new introduction node.
-		if intermediate_nodes.len() == 0 {
-			if let Destination::BlindedPath(ref mut blinded_path) = destination {
-				let our_node_id = node_signer.get_node_id(Recipient::Node)
-					.map_err(|()| SendError::GetNodeIdFailed)?;
-				if blinded_path.introduction_node_id == our_node_id {
-					advance_path_by_one(blinded_path, node_signer, &secp_ctx)
-						.map_err(|()| SendError::BlindedPathAdvanceFailed)?;
-				}
-			}
-		}
-
-		let blinding_secret_bytes = entropy_source.get_secure_random_bytes();
-		let blinding_secret = SecretKey::from_slice(&blinding_secret_bytes[..]).expect("RNG is busted");
-		let (introduction_node_id, blinding_point) = if intermediate_nodes.len() != 0 {
-			(intermediate_nodes[0], PublicKey::from_secret_key(&secp_ctx, &blinding_secret))
-		} else {
-			match destination {
-				Destination::Node(pk) => (pk, PublicKey::from_secret_key(&secp_ctx, &blinding_secret)),
-				Destination::BlindedPath(BlindedPath { introduction_node_id, blinding_point, .. }) =>
-					(introduction_node_id, blinding_point),
-			}
-		};
-		let (packet_payloads, packet_keys) = packet_payloads_and_keys(
-			&secp_ctx, &intermediate_nodes, destination, message, reply_path, &blinding_secret)
-			.map_err(|e| SendError::Secp256k1(e))?;
-
-		let prng_seed = entropy_source.get_secure_random_bytes();
-		let onion_routing_packet = construct_onion_message_packet(
-			packet_payloads, packet_keys, prng_seed).map_err(|()| SendError::TooBigPacket)?;
-
-		Ok((introduction_node_id, msgs::OnionMessage {
-			blinding_point,
-			onion_routing_packet
-		}))
-	}
-
 	fn respond_with_onion_message<T: CustomOnionMessageContents>(
 		&self, response: OnionMessageContents<T>, path_id: Option<[u8; 32]>,
 		reply_path: Option<BlindedPath>

lightning/src/routing/router.rs

@@ -112,12 +112,12 @@ pub trait Router {
 /// [`find_route`].
 ///
 /// [`ScoreLookUp`]: crate::routing::scoring::ScoreLookUp
-pub struct ScorerAccountingForInFlightHtlcs<'a, SP: Sized, Sc: 'a + ScoreLookUp<ScoreParams = SP>, S: Deref<Target = Sc>> {
+pub struct ScorerAccountingForInFlightHtlcs<'a, S: Deref> where S::Target: ScoreLookUp {
 	scorer: S,
 	// Maps a channel's short channel id and its direction to the liquidity used up.
 	inflight_htlcs: &'a InFlightHtlcs,
 }
-impl<'a, SP: Sized, Sc: ScoreLookUp<ScoreParams = SP>, S: Deref<Target = Sc>> ScorerAccountingForInFlightHtlcs<'a, SP, Sc, S> {
+impl<'a, S: Deref> ScorerAccountingForInFlightHtlcs<'a, S> where S::Target: ScoreLookUp {
 	/// Initialize a new `ScorerAccountingForInFlightHtlcs`.
 	pub fn new(scorer: S, inflight_htlcs: &'a InFlightHtlcs) -> Self {
 		ScorerAccountingForInFlightHtlcs {
@@ -127,13 +127,8 @@ impl<'a, SP: Sized, Sc: ScoreLookUp<ScoreParams = SP>, S: Deref<Target = Sc>> Sc
 	}
 }
 
-#[cfg(c_bindings)]
-impl<'a, SP: Sized, Sc: ScoreLookUp<ScoreParams = SP>, S: Deref<Target = Sc>> Writeable for ScorerAccountingForInFlightHtlcs<'a, SP, Sc, S> {
-	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.scorer.write(writer) }
-}
-
-impl<'a, SP: Sized, Sc: 'a + ScoreLookUp<ScoreParams = SP>, S: Deref<Target = Sc>> ScoreLookUp for ScorerAccountingForInFlightHtlcs<'a, SP, Sc, S> {
-	type ScoreParams = Sc::ScoreParams;
+impl<'a, S: Deref> ScoreLookUp for ScorerAccountingForInFlightHtlcs<'a, S> where S::Target: ScoreLookUp {
+	type ScoreParams = <S::Target as ScoreLookUp>::ScoreParams;
 	fn channel_penalty_msat(&self, short_channel_id: u64, source: &NodeId, target: &NodeId, usage: ChannelUsage, score_params: &Self::ScoreParams) -> u64 {
 		if let Some(used_liquidity) = self.inflight_htlcs.used_liquidity_msat(
 			source, target, short_channel_id