turn TaggedHash into SignatureData enum

Author: orbitalturtle

lightning/src/offers/invoice.rs

@@ -24,6 +24,7 @@
 //! use bitcoin::secp256k1::{KeyPair, PublicKey, Secp256k1, SecretKey};
 //! use core::convert::{Infallible, TryFrom};
 //! use lightning::offers::invoice_request::InvoiceRequest;
+//! use lightning::offers::merkle::AsDigest;
 //! use lightning::offers::refund::Refund;
 //! use lightning::util::ser::Writeable;
 //!
@@ -87,7 +88,7 @@
 //!     .fallback_v0_p2wpkh(&wpubkey_hash)
 //!     .build()?
 //!     .sign::<_, Infallible>(
-//!         |message| Ok(secp_ctx.sign_schnorr_no_aux_rand(message.as_ref().as_digest(), &keys))
+//!         |message| Ok(secp_ctx.sign_schnorr_no_aux_rand(&message.as_ref().as_digest(), &keys))
 //!     )
 //!     .expect("failed verifying signature")
 //!     .write(&mut buffer)
@@ -115,7 +116,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, SignatureTlvStream, SignatureTlvStreamRef, TaggedHash, TlvStream, WithoutSignatures, self};
+use crate::offers::merkle::{AsDigest, RawData, SignError, SignatureData, 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};
@@ -149,6 +150,7 @@ pub struct InvoiceBuilder<'a, S: SigningPubkeyStrategy> {
 	invreq_bytes: &'a Vec<u8>,
 	invoice: InvoiceContents,
 	signing_pubkey_strategy: S,
+        raw_data: bool,
 }
 
 /// Indicates how [`Bolt12Invoice::signing_pubkey`] was set.
@@ -183,12 +185,12 @@ impl<'a> InvoiceBuilder<'a, ExplicitSigningPubkey> {
 			),
 		};
 
-		Self::new(&invoice_request.bytes, contents, ExplicitSigningPubkey {})
+		Self::new(&invoice_request.bytes, contents, ExplicitSigningPubkey {}, false)
 	}
 
 	pub(super) fn for_refund(
 		refund: &'a Refund, payment_paths: Vec<(BlindedPayInfo, BlindedPath)>, created_at: Duration,
-		payment_hash: PaymentHash, signing_pubkey: PublicKey
+		payment_hash: PaymentHash, signing_pubkey: PublicKey, 
 	) -> Result<Self, Bolt12SemanticError> {
 		let amount_msats = refund.amount_msats();
 		let contents = InvoiceContents::ForRefund {
@@ -198,7 +200,7 @@ impl<'a> InvoiceBuilder<'a, ExplicitSigningPubkey> {
 			),
 		};
 
-		Self::new(&refund.bytes, contents, ExplicitSigningPubkey {})
+		Self::new(&refund.bytes, contents, ExplicitSigningPubkey {}, false)
 	}
 }
 
@@ -216,12 +218,12 @@ impl<'a> InvoiceBuilder<'a, DerivedSigningPubkey> {
 			),
 		};
 
-		Self::new(&invoice_request.bytes, contents, DerivedSigningPubkey(keys))
+		Self::new(&invoice_request.bytes, contents, DerivedSigningPubkey(keys), false)
 	}
 
 	pub(super) fn for_refund_using_keys(
 		refund: &'a Refund, payment_paths: Vec<(BlindedPayInfo, BlindedPath)>, created_at: Duration,
-		payment_hash: PaymentHash, keys: KeyPair,
+		payment_hash: PaymentHash, keys: KeyPair
 	) -> Result<Self, Bolt12SemanticError> {
 		let amount_msats = refund.amount_msats();
 		let signing_pubkey = keys.public_key();
@@ -232,7 +234,7 @@ impl<'a> InvoiceBuilder<'a, DerivedSigningPubkey> {
 			),
 		};
 
-		Self::new(&refund.bytes, contents, DerivedSigningPubkey(keys))
+		Self::new(&refund.bytes, contents, DerivedSigningPubkey(keys), false)
 	}
 }
 
@@ -262,13 +264,14 @@ impl<'a, S: SigningPubkeyStrategy> InvoiceBuilder<'a, S> {
 	}
 
 	fn new(
-		invreq_bytes: &'a Vec<u8>, contents: InvoiceContents, signing_pubkey_strategy: S
+		invreq_bytes: &'a Vec<u8>, contents: InvoiceContents, signing_pubkey_strategy: S,
+                raw_data: bool,
 	) -> Result<Self, Bolt12SemanticError> {
 		if contents.fields().payment_paths.is_empty() {
 			return Err(Bolt12SemanticError::MissingPaths);
 		}
 
-		Ok(Self { invreq_bytes, invoice: contents, signing_pubkey_strategy })
+		Ok(Self { invreq_bytes, invoice: contents, signing_pubkey_strategy, raw_data })
 	}
 
 	/// Sets the [`Bolt12Invoice::relative_expiry`] as seconds since [`Bolt12Invoice::created_at`].
@@ -327,6 +330,13 @@ impl<'a, S: SigningPubkeyStrategy> InvoiceBuilder<'a, S> {
 		self.invoice.fields_mut().features.set_basic_mpp_optional();
 		self
 	}
+
+        /// Indicates that instead of forming a fully formed tagged hash to sign when building and
+        /// UnsignedBolt12Invoice, we'd like to pass the signer function the raw data instead.
+        pub fn raw_data(mut self) -> Self {
+        	self.raw_data = true;
+		self
+        }
 }
 
 impl<'a> InvoiceBuilder<'a, ExplicitSigningPubkey> {
@@ -340,7 +350,7 @@ impl<'a> InvoiceBuilder<'a, ExplicitSigningPubkey> {
 		}
 
 		let InvoiceBuilder { invreq_bytes, invoice, .. } = self;
-		Ok(UnsignedBolt12Invoice::new(invreq_bytes, invoice))
+		Ok(UnsignedBolt12Invoice::new(invreq_bytes, invoice, self.raw_data))
 	}
 }
 
@@ -356,13 +366,13 @@ impl<'a> InvoiceBuilder<'a, DerivedSigningPubkey> {
 		}
 
 		let InvoiceBuilder {
-			invreq_bytes, invoice, signing_pubkey_strategy: DerivedSigningPubkey(keys)
+			invreq_bytes, invoice, signing_pubkey_strategy: DerivedSigningPubkey(keys), raw_data,
 		} = self;
-		let unsigned_invoice = UnsignedBolt12Invoice::new(invreq_bytes, invoice);
+		let unsigned_invoice = UnsignedBolt12Invoice::new(invreq_bytes, invoice, self.raw_data);
 
 		let invoice = unsigned_invoice
 			.sign::<_, Infallible>(
-				|message| Ok(secp_ctx.sign_schnorr_no_aux_rand(message.as_ref().as_digest(), &keys))
+				|message| Ok(secp_ctx.sign_schnorr_no_aux_rand(&message.as_ref().as_digest(), &keys))
 			)
 			.unwrap();
 		Ok(invoice)
@@ -378,11 +388,11 @@ impl<'a> InvoiceBuilder<'a, DerivedSigningPubkey> {
 pub struct UnsignedBolt12Invoice {
 	bytes: Vec<u8>,
 	contents: InvoiceContents,
-	tagged_hash: TaggedHash,
+        data_to_sign: SignatureData,
 }
 
 impl UnsignedBolt12Invoice {
-	fn new(invreq_bytes: &[u8], contents: InvoiceContents) -> Self {
+	fn new(invreq_bytes: &[u8], contents: InvoiceContents, raw_data: bool) -> Self {
 		// Use the invoice_request bytes instead of the invoice_request TLV stream as the latter may
 		// have contained unknown TLV records, which are not stored in `InvoiceRequestContents` or
 		// `RefundContents`.
@@ -393,14 +403,20 @@ impl UnsignedBolt12Invoice {
 		let mut bytes = Vec::new();
 		unsigned_tlv_stream.write(&mut bytes).unwrap();
 
-		let tagged_hash = TaggedHash::new(SIGNATURE_TAG, &bytes);
+                let mut data_to_sign = SignatureData::TaggedHash(TaggedHash::new(SIGNATURE_TAG, &bytes));
+                if raw_data {
+			data_to_sign = SignatureData::RawData(RawData::new(SIGNATURE_TAG, &bytes))
+                }
 
-		Self { bytes, contents, tagged_hash }
+		Self { bytes, contents, data_to_sign }
 	}
 
 	/// Returns the [`TaggedHash`] of the invoice to sign.
 	pub fn tagged_hash(&self) -> &TaggedHash {
-		&self.tagged_hash
+                match &self.data_to_sign {
+			SignatureData::TaggedHash(tagged_hash) => tagged_hash,
+                        SignatureData::RawData(_) => panic!("tagged hash doesn't exist"),
+                }
 	}
 
 	/// Signs the [`TaggedHash`] of the invoice using the given function.
@@ -429,10 +445,10 @@ impl UnsignedBolt12Invoice {
 	}
 }
 
-impl AsRef<TaggedHash> for UnsignedBolt12Invoice {
-	fn as_ref(&self) -> &TaggedHash {
-		&self.tagged_hash
-	}
+impl AsRef<SignatureData> for UnsignedBolt12Invoice {
+        fn as_ref(&self) -> &SignatureData {
+                &self.data_to_sign
+        }
 }
 
 /// A `Bolt12Invoice` is a payment request, typically corresponding to an [`Offer`] or a [`Refund`].
@@ -1042,9 +1058,9 @@ impl TryFrom<Vec<u8>> for UnsignedBolt12Invoice {
 			(payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream, invoice_tlv_stream)
 		)?;
 
-		let tagged_hash = TaggedHash::new(SIGNATURE_TAG, &bytes);
+		let data_to_sign = SignatureData::TaggedHash(TaggedHash::new(SIGNATURE_TAG, &bytes));
 
-		Ok(UnsignedBolt12Invoice { bytes, contents, tagged_hash })
+		Ok(UnsignedBolt12Invoice { bytes, contents, data_to_sign })
 	}
 }
 
@@ -1368,7 +1384,7 @@ mod tests {
 			Err(e) => panic!("error parsing unsigned invoice: {:?}", e),
 			Ok(parsed) => {
 				assert_eq!(parsed.bytes, unsigned_invoice.bytes);
-				assert_eq!(parsed.tagged_hash, unsigned_invoice.tagged_hash);
+				assert_eq!(parsed.tagged_hash(), unsigned_invoice.tagged_hash());
 			},
 		}