feat(silentpayments): add recipient label support

Author: nymius

secp256k1-sys/src/lib.rs

@@ -939,8 +939,34 @@ pub mod silentpayments {
             plain_seckeys: *const *const c_uchar,
             n_plain_seckeys: size_t,
         ) -> c_int;
+
+        #[cfg_attr(
+            not(rust_secp_no_symbol_renaming),
+            link_name = "rustsecp256k1_v0_13_silentpayments_recipient_create_label"
+        )]
+        pub fn secp256k1_silentpayments_recipient_create_label(
+            ctx: *const Context,
+            label: *mut PublicKey,
+            label_tweak32: *mut c_uchar,
+            scan_key32: *const c_uchar,
+            m: c_uint,
+        ) -> c_int;
+
+        #[cfg_attr(
+            not(rust_secp_no_symbol_renaming),
+            link_name = "rustsecp256k1_v0_13_silentpayments_recipient_create_labeled_spend_pubkey"
+        )]
+        pub fn secp256k1_silentpayments_recipient_create_labeled_spend_pubkey(
+            ctx: *const Context,
+            labeled_spend_pubkey: *mut PublicKey,
+            unlabeled_spend_pubkey: *const PublicKey,
+            label: *const PublicKey,
+        ) -> c_int;
     }
 
+    pub type LabelLookup =
+        Option<unsafe extern "C" fn(*const c_uchar, *const c_void) -> *const c_uchar>;
+
     #[repr(C)]
     #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
     pub struct Recipient {

src/silentpayments/mod.rs

@@ -1 +1,2 @@
+pub mod recipient;
 pub mod sender;

src/silentpayments/recipient.rs

@@ -0,0 +1,132 @@
+//! Provide all the binding functions and methods to be used from the perspective of the
+//! silentpayments recipient.
+use crate::ffi::{self, CPtr};
+use crate::{PublicKey, Secp256k1, SecretKey};
+
+/// Error creating label tweak.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
+pub struct LabelTweakCreationError;
+
+#[cfg(feature = "std")]
+impl std::error::Error for LabelTweakCreationError {}
+
+impl core::fmt::Display for LabelTweakCreationError {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
+        match self {
+            LabelTweakCreationError => write!(f, "Failed to create label tweak"),
+        }
+    }
+}
+
+/// Create Silent Payment label tweak and label.
+///
+/// Given a recipient's scan [`SecretKey`] and a label integer m, calculate the
+/// corresponding label tweak and label:
+///
+///     label_tweak = hash(scan_key || m)
+///           label = label_tweak * G
+///
+/// # Arguments
+/// * `scan_seckey` - the recipient's scan [`SecretKey`].
+/// * `m` - a label integer for the m-th label (0 is used for change outputs).
+///
+/// # Returns
+/// A tuple ([`PublicKey`], [u8; 32]) where the first element is the label public key and the
+/// second is the label tweak.
+///
+/// # Errors
+/// * [`LabelTweakCreationError`] - if label tweak is not a valid scalar (negligible probability per hash evaluation).
+pub fn create_label(
+    scan_seckey: &SecretKey,
+    m: u32,
+) -> Result<(PublicKey, [u8; 32]), LabelTweakCreationError> {
+    unsafe {
+        let mut label = ffi::PublicKey::new();
+        let mut label_tweak32 = [0u8; 32];
+
+        let res = crate::with_global_context(
+            |secp: &Secp256k1<crate::AllPreallocated>| {
+                ffi::silentpayments::secp256k1_silentpayments_recipient_create_label(
+                    secp.ctx().as_ptr(),
+                    &mut label,
+                    label_tweak32.as_mut_c_ptr(),
+                    scan_seckey.as_c_ptr(),
+                    m,
+                )
+            },
+            None,
+        );
+
+        if res == 1 {
+            let label = PublicKey::from(label);
+            Ok((label, label_tweak32))
+        } else {
+            Err(LabelTweakCreationError)
+        }
+    }
+}
+
+/// Failed to create labeled spend pubkey.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
+pub struct LabeledSpendPubkeyCreationError;
+
+#[cfg(feature = "std")]
+impl std::error::Error for LabeledSpendPubkeyCreationError {}
+
+impl core::fmt::Display for LabeledSpendPubkeyCreationError {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
+        match self {
+            LabeledSpendPubkeyCreationError => {
+                write!(f, "Failed to create labeled spend pubkey")
+            }
+        }
+    }
+}
+
+/// Create Silent Payment labeled spend public key.
+///
+/// Given a recipient's spend public key and a label, calculate the
+/// corresponding labeled spend public key:
+///
+///     labeled_spend_pubkey = unlabeled_spend_pubkey + label
+///
+/// The result is used by the recipient to create a Silent Payment address,
+/// consisting of the serialized and concatenated scan public key and
+/// (labeled) spend public key.
+///
+/// # Arguments:
+/// * `unlabeled_spend_pubkey` - the recipient's unlabeled spend public key to label.
+/// * `label` - the recipient's label public key.
+///
+/// # Returns
+/// The resulting labeled [`PublicKey`].
+///
+/// # Errors
+/// * [`LabeledSpendPubkeyCreationError`] - if spend pubkey and label sum to zero (negligible probability for labels created according to BIP352).
+pub fn create_labeled_spend_pubkey(
+    unlabeled_spend_pubkey: &PublicKey,
+    label: &PublicKey,
+) -> Result<PublicKey, LabeledSpendPubkeyCreationError> {
+    unsafe {
+        let mut pubkey = ffi::PublicKey::new();
+
+        let res = crate::with_global_context(
+            |secp: &Secp256k1<crate::AllPreallocated>| {
+                ffi::silentpayments::secp256k1_silentpayments_recipient_create_labeled_spend_pubkey(
+                    secp.ctx().as_ptr(),
+                    &mut pubkey,
+                    unlabeled_spend_pubkey.as_c_ptr(),
+                    label.as_c_ptr(),
+                )
+            },
+            None,
+        );
+
+        if res == 1 {
+            let pubkey = PublicKey::from(pubkey);
+            Ok(pubkey)
+        } else {
+            Err(LabeledSpendPubkeyCreationError)
+        }
+    }
+}