f - type-specific sign function traits

Author: jkczyz

lightning/src/offers/invoice.rs

@@ -120,7 +120,7 @@ use crate::ln::features::{BlindedHopFeatures, Bolt12InvoiceFeatures, InvoiceRequ
 use crate::ln::inbound_payment::ExpandedKey;
 use crate::ln::msgs::DecodeError;
 use crate::offers::invoice_request::{INVOICE_REQUEST_PAYER_ID_TYPE, INVOICE_REQUEST_TYPES, IV_BYTES as INVOICE_REQUEST_IV_BYTES, InvoiceRequest, InvoiceRequestContents, InvoiceRequestTlvStream, InvoiceRequestTlvStreamRef};
-use crate::offers::merkle::{SignError, SignFunction, SignatureTlvStream, SignatureTlvStreamRef, TaggedHash, TlvStream, WithoutSignatures, self};
+use crate::offers::merkle::{SignError, SignFn, SignatureTlvStream, SignatureTlvStreamRef, TaggedHash, TlvStream, WithoutSignatures, self};
 use crate::offers::offer::{Amount, OFFER_TYPES, OfferTlvStream, OfferTlvStreamRef, Quantity};
 use crate::offers::parse::{Bolt12ParseError, Bolt12SemanticError, ParsedMessage};
 use crate::offers::payer::{PAYER_METADATA_TYPE, PayerTlvStream, PayerTlvStreamRef};
@@ -508,6 +508,37 @@ pub struct UnsignedBolt12Invoice {
 	tagged_hash: TaggedHash,
 }
 
+/// A function for signing an [`UnsignedBolt12Invoice`].
+pub trait SignBolt12InvoiceFn {
+	/// Error type returned by the function.
+	type Error;
+
+	/// Signs a [`TaggedHash`] computed over the merkle root of `message`'s TLV stream.
+	fn sign_invoice(&self, message: &UnsignedBolt12Invoice) -> Result<Signature, Self::Error>;
+}
+
+impl<F, E> SignBolt12InvoiceFn for F
+where
+	F: Fn(&UnsignedBolt12Invoice) -> Result<Signature, E>,
+{
+	type Error = E;
+
+	fn sign_invoice(&self, message: &UnsignedBolt12Invoice) -> Result<Signature, E> {
+		self(message)
+	}
+}
+
+impl<F, E> SignFn<UnsignedBolt12Invoice> for F
+where
+	F: SignBolt12InvoiceFn<Error = E>,
+{
+	type Error = E;
+
+	fn sign(&self, message: &UnsignedBolt12Invoice) -> Result<Signature, Self::Error> {
+		self.sign_invoice(message)
+	}
+}
+
 impl UnsignedBolt12Invoice {
 	fn new(invreq_bytes: &[u8], contents: InvoiceContents) -> Self {
 		// Use the invoice_request bytes instead of the invoice_request TLV stream as the latter may
@@ -535,12 +566,9 @@ macro_rules! unsigned_invoice_sign_method { ($self: ident, $self_type: ty $(, $s
 	/// Signs the [`TaggedHash`] of the invoice using the given function.
 	///
 	/// Note: The hash computation may have included unknown, odd TLV records.
-	pub fn sign<F>(
+	pub fn sign<F: SignBolt12InvoiceFn>(
 		$($self_mut)* $self: $self_type, sign: F
-	) -> Result<Bolt12Invoice, SignError<F::Error>>
-	where
-		F: SignFunction<Self>,
-	{
+	) -> Result<Bolt12Invoice, SignError<F::Error>> {
 		let pubkey = $self.contents.fields().signing_pubkey;
 		let signature = merkle::sign_message(sign, &$self, pubkey)?;
 

lightning/src/offers/invoice_request.rs

@@ -73,7 +73,7 @@ use crate::ln::features::InvoiceRequestFeatures;
 use crate::ln::inbound_payment::{ExpandedKey, IV_LEN, Nonce};
 use crate::ln::msgs::DecodeError;
 use crate::offers::invoice::BlindedPayInfo;
-use crate::offers::merkle::{SignError, SignFunction, SignatureTlvStream, SignatureTlvStreamRef, TaggedHash, self};
+use crate::offers::merkle::{SignError, SignFn, SignatureTlvStream, SignatureTlvStreamRef, TaggedHash, self};
 use crate::offers::offer::{Offer, OfferContents, OfferTlvStream, OfferTlvStreamRef};
 use crate::offers::parse::{Bolt12ParseError, ParsedMessage, Bolt12SemanticError};
 use crate::offers::payer::{PayerContents, PayerTlvStream, PayerTlvStreamRef};
@@ -494,6 +494,37 @@ pub struct UnsignedInvoiceRequest {
 	tagged_hash: TaggedHash,
 }
 
+/// A function for signing an [`UnsignedInvoiceRequest`].
+pub trait SignInvoiceRequestFn {
+	/// Error type returned by the function.
+	type Error;
+
+	/// Signs a [`TaggedHash`] computed over the merkle root of `message`'s TLV stream.
+	fn sign_invoice_request(&self, message: &UnsignedInvoiceRequest) -> Result<Signature, Self::Error>;
+}
+
+impl<F, E> SignInvoiceRequestFn for F
+where
+	F: Fn(&UnsignedInvoiceRequest) -> Result<Signature, E>,
+{
+	type Error = E;
+
+	fn sign_invoice_request(&self, message: &UnsignedInvoiceRequest) -> Result<Signature, E> {
+		self(message)
+	}
+}
+
+impl<F, E> SignFn<UnsignedInvoiceRequest> for F
+where
+	F: SignInvoiceRequestFn<Error = E>,
+{
+	type Error = E;
+
+	fn sign(&self, message: &UnsignedInvoiceRequest) -> Result<Signature, Self::Error> {
+		self.sign_invoice_request(message)
+	}
+}
+
 impl UnsignedInvoiceRequest {
 	fn new(offer: &Offer, contents: InvoiceRequestContents) -> Self {
 		// Use the offer bytes instead of the offer TLV stream as the offer may have contained
@@ -523,12 +554,9 @@ macro_rules! unsigned_invoice_request_sign_method { (
 	/// Signs the [`TaggedHash`] of the invoice request using the given function.
 	///
 	/// Note: The hash computation may have included unknown, odd TLV records.
-	pub fn sign<F>(
+	pub fn sign<F: SignInvoiceRequestFn>(
 		$($self_mut)* $self: $self_type, sign: F
-	) -> Result<InvoiceRequest, SignError<F::Error>>
-	where
-		F: SignFunction<Self>,
-	{
+	) -> Result<InvoiceRequest, SignError<F::Error>> {
 		let pubkey = $self.contents.payer_id;
 		let signature = merkle::sign_message(sign, &$self, pubkey)?;
 

lightning/src/offers/merkle.rs

@@ -84,22 +84,21 @@ pub enum SignError<E = ()> {
 }
 
 /// A function for signing a [`TaggedHash`].
-pub trait SignFunction<T: AsRef<TaggedHash>> {
+pub(super) trait SignFn<T: AsRef<TaggedHash>> {
 	/// Error type returned by the function.
 	type Error;
 
 	/// Signs a [`TaggedHash`] computed over the merkle root of `message`'s TLV stream.
 	fn sign(&self, message: &T) -> Result<Signature, Self::Error>;
 }
 
-impl<F, T, E> SignFunction<T> for F
+impl<F, E> SignFn<TaggedHash> for F
 where
-	F: Fn(&T) -> Result<Signature, E>,
-	T: AsRef<TaggedHash>,
+	F: Fn(&TaggedHash) -> Result<Signature, E>,
 {
 	type Error = E;
 
-	fn sign(&self, message: &T) -> Result<Signature, E> {
+	fn sign(&self, message: &TaggedHash) -> Result<Signature, E> {
 		self(message)
 	}
 }
@@ -117,7 +116,7 @@ pub(super) fn sign_message<F, T, E>(
 	f: F, message: &T, pubkey: PublicKey,
 ) -> Result<Signature, SignError<E>>
 where
-	F: SignFunction<T, Error = E>,
+	F: SignFn<T, Error = E>,
 	T: AsRef<TaggedHash>,
 {
 	let signature = f.sign(message).map_err(|e| SignError::Signing(e))?;