feat(silentpayments): add receiving support

Co-authored-by: Antoni Spaanderman <[email protected]>

Author: nymius

secp256k1-sys/src/lib.rs

@@ -962,6 +962,101 @@ pub mod silentpayments {
             unlabeled_spend_pubkey: *const PublicKey,
             label: *const PublicKey,
         ) -> c_int;
+
+        #[cfg_attr(
+            not(rust_secp_no_symbol_renaming),
+            link_name = "rustsecp256k1_v0_13_silentpayments_recipient_prevouts_summary_create"
+        )]
+        pub fn secp256k1_silentpayments_recipient_prevouts_summary_create(
+            ctx: *const Context,
+            prevouts_summary: *mut PrevoutsSummary,
+            outpoint_smallest36: *const c_uchar,
+            xonly_pubkeys: *const *const XOnlyPublicKey,
+            n_xonly_pubkeys: size_t,
+            plain_pubkeys: *const *const PublicKey,
+            n_plain_pubkeys: size_t,
+        ) -> c_int;
+
+        #[cfg_attr(
+            not(rust_secp_no_symbol_renaming),
+            link_name = "rustsecp256k1_v0_13_silentpayments_recipient_scan_outputs"
+        )]
+        pub fn secp256k1_silentpayments_recipient_scan_outputs(
+            ctx: *const Context,
+            found_outputs: *mut *mut FoundOutput,
+            n_found_outputs: *mut size_t,
+            tx_outputs: *const *const XOnlyPublicKey,
+            n_tx_outputs: size_t,
+            scan_key32: *const c_uchar,
+            prevouts_summary: *const PrevoutsSummary,
+            unlabeled_spend_pubkey: *const PublicKey,
+            label_lookup: LabelLookup,
+            label_context: *const c_void,
+        ) -> c_int;
+
+        #[cfg_attr(
+            not(rust_secp_no_symbol_renaming),
+            link_name = "rustsecp256k1_v0_13_silentpayments_recipient_create_output_pubkeys"
+        )]
+        pub fn secp256k1_silentpayments_recipient_create_output_pubkeys(
+            ctx: *const Context,
+            outputs_xonly: *mut *mut XOnlyPublicKey,
+            scan_key32: *const c_uchar,
+            prevouts_summary: *const PrevoutsSummary,
+            spend_pubkeys: *const *mut PublicKey,
+            n_spend_pubkeys: size_t,
+        ) -> c_int;
+    }
+
+    #[repr(C)]
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    pub struct FoundOutput {
+        pub output: XOnlyPublicKey,
+        pub tweak: [c_uchar; 32],
+        pub found_with_label: c_int,
+        pub label: PublicKey,
+    }
+
+    impl Default for FoundOutput {
+        fn default() -> Self {
+            Self {
+                output: unsafe { XOnlyPublicKey::new() },
+                tweak: [0u8; 32],
+                found_with_label: 0i32,
+                label: unsafe { PublicKey::new() },
+            }
+        }
+    }
+
+    #[repr(C)]
+    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    pub struct PrevoutsSummary {
+        data: [u8; 101],
+    }
+
+    impl PrevoutsSummary {
+        pub fn from_array(arr: [u8; 101]) -> Self { Self { data: arr } }
+        pub fn to_array(self) -> [u8; 101] { self.data }
+    }
+
+    impl core::fmt::Debug for PrevoutsSummary {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            write!(f, "magic: {{")?;
+            for magic_byte in &self.data[..3] {
+                write!(f, "0x{magic_byte:02x}, ")?;
+            }
+            writeln!(f, "0x{:02x}}}", &self.data[3])?;
+            write!(f, "x: 0x")?;
+            for x_byte in &self.data[4..36] {
+                write!(f, "{x_byte:02x}")?;
+            }
+            writeln!(f)?;
+            write!(f, "y: 0x")?;
+            for y_byte in &self.data[36..68] {
+                write!(f, "{y_byte:02x}")?;
+            }
+            Ok(())
+        }
     }
 
     pub type LabelLookup =

src/silentpayments/mod.rs

@@ -1,2 +1,20 @@
+//! This module implements high-level Rust bindings for the libsecp256k1 implementation for Silent
+//! Payments, as specified in BIP352.
+//!
+//! This particularly involves the creation of input tweak data by summing up secret or public keys
+//! and the derivation of a shared secret using Elliptic Curve Diffie-Hellman. Combined are either:
+//!
+//!   - spender's secret keys and recipient's public key (a * B, sender side)
+//!   - spender's public keys and recipient's secret key (A * b, recipient side)
+//!
+//! With this result, the necessary key material for ultimately creating/scanning
+//! or spending Silent Payment outputs can be determined.
+//!
+//! Note that the underlying module this crate is binding is _not_ a full implementation of BIP352,
+//! as it inherently doesn't deal with higher-level concepts like addresses, output script types or
+//! transactions. The intent is to provide bindings to the libsecp256k1 module for abstracting away
+//! the elliptic-curve operations required for the protocol. For any wallet software already using
+//! this crate, this API should provide all the functions needed for a Silent Payments
+//! implementation without requiring any further elliptic-curve operations from the wallet.
 pub mod recipient;
 pub mod sender;