feat: add server.version, blockchain.silentpayments.subscribe and blockchain.silentpayments.unsubscribe

Author: sdmg15

Cargo.toml

@@ -21,6 +21,7 @@ tokio-util = { version = "0.7.15", features = ["compat"], optional = true }
 [features]
 default = ["tokio"]
 tokio = ["dep:tokio", "tokio-util"]
+frigate = []
 
 [dev-dependencies]
 async-std = "1.13.0"

src/notification.rs

@@ -5,13 +5,16 @@
 //!
 //! - [`Notification::Header`] for `"blockchain.headers.subscribe"`
 //! - [`Notification::ScriptHash`] for `"blockchain.scripthash.subscribe"`
+//! - [`Notification::SpSubscribe`] for `"blockchain.silentpayments.subscribe"`
 //! - [`Notification::Unknown`] for unrecognized or unsupported methods
 //!
 //! Each variant wraps a struct that contains the deserialized payload for that notification type.
 //! Use [`Notification::new`] to construct a typed [`Notification`] from a raw JSON-RPC notification.
 //!
 //! This is useful for higher-level consumers who want to match against known server-side events.
 
+#[cfg(feature = "frigate")]
+use bitcoin::{secp256k1::PublicKey, Txid};
 use serde::Deserialize;
 
 use crate::{response, ElectrumScriptHash, ElectrumScriptStatus, RawNotification};
@@ -32,6 +35,11 @@ pub enum Notification {
     /// status.
     ScriptHash(ScriptHashNotification),
 
+    /// A notification from `"blockchain.silentpayments.subscribe"` indicating a new history
+    /// of transactions
+    #[cfg(feature = "frigate")]
+    SpSubscribe(SpSubscribeNotification),
+
     /// A catch-all for notifications with unrecognized methods.
     ///
     /// The original [`RawNotification`] is preserved for downstream inspection.
@@ -52,6 +60,10 @@ impl Notification {
             "blockchain.scripthash.subscribe" => {
                 ScriptHashNotification::deserialize(params).map(Notification::ScriptHash)
             }
+            #[cfg(feature = "frigate")]
+            "blockchain.silentpayments.subscribe" => {
+                SpSubscribeNotification::deserialize(params).map(Notification::SpSubscribe)
+            }
             _ => Ok(Notification::Unknown(raw.clone())),
         }
     }
@@ -102,3 +114,43 @@ impl ScriptHashNotification {
         self.param_1
     }
 }
+
+#[cfg(feature = "frigate")]
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct Subscription {
+    pub address: String,
+    pub labels: Vec<u32>,
+    pub start_height: u32,
+}
+
+#[cfg(feature = "frigate")]
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct History {
+    pub height: u32,
+    pub tx_hash: Txid,
+    pub tweak_key: PublicKey,
+}
+
+/// A notification indicating new confirmed transactions
+///
+/// Corresponds to `"blockchain.silentpayments.subscribe"` Frigate Electrum notification method
+#[cfg(feature = "frigate")]
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct SpSubscribeNotification {
+    pub subscription: Subscription,
+    pub progress: f32,
+    pub history: Vec<History>,
+}
+
+#[cfg(feature = "frigate")]
+impl SpSubscribeNotification {
+    /// Returns the history from the notification
+    pub fn history(&self) -> &Vec<History> {
+        &self.history
+    }
+
+    /// Returns the progress of output scanning from notification
+    pub fn progress(&self) -> f32 {
+        self.progress
+    }
+}

src/pending_request.rs

@@ -265,6 +265,7 @@ macro_rules! gen_pending_request_types {
     };
 }
 
+#[cfg(not(feature = "frigate"))]
 gen_pending_request_types! {
     Header,
     HeaderWithProof,
@@ -289,6 +290,32 @@ gen_pending_request_types! {
     Custom
 }
 
+#[cfg(feature = "frigate")]
+gen_pending_request_types! {
+    Header,
+    HeaderWithProof,
+    Headers,
+    HeadersWithCheckpoint,
+    EstimateFee,
+    HeadersSubscribe,
+    GetBalance,
+    GetHistory,
+    GetMempool,
+    ListUnspent,
+    ScriptHashSubscribe,
+    ScriptHashUnsubscribe,
+    BroadcastTx,
+    GetTx,
+    GetTxMerkle,
+    GetTxidFromPos,
+    GetFeeHistogram,
+    Banner,
+    Ping,
+    Version,
+    Subscribe,
+    UnSubscribe
+}
+
 impl<A: PendingRequest> PendingRequest for Box<A> {
     fn to_method_and_params(&self) -> MethodAndParams {
         self.as_ref().to_method_and_params()

src/request.rs

@@ -18,6 +18,9 @@
 
 use bitcoin::{consensus::Encodable, hex::DisplayHex, Script, Txid};
 
+#[cfg(feature = "frigate")]
+use bitcoin::secp256k1::{PublicKey, SecretKey};
+
 use crate::{
     response, CowStr, ElectrumScriptHash, ElectrumScriptStatus, MethodAndParams, RawRequest,
     ResponseError,
@@ -656,3 +659,93 @@ impl Request for Ping {
         ("server.ping".into(), vec![])
     }
 }
+
+/// A request to establish connection with Frigate Electrum client
+///
+/// This corresponds to the `"server.version"` Frigate Electrum RPC method
+///
+/// See: https://github.com/sparrowwallet/frigate
+#[cfg(feature = "frigate")]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Version {
+    pub client_name: CowStr,
+    pub version: CowStr,
+}
+
+#[cfg(feature = "frigate")]
+impl Request for Version {
+    type Response = Vec<String>;
+
+    fn to_method_and_params(&self) -> MethodAndParams {
+        (
+            "server.version".into(),
+            vec![self.client_name.clone().into(), self.version.clone().into()],
+        )
+    }
+}
+
+/// A request to subscribe to payment outputs belonging to the provided keys
+///
+/// This corresponds to the `"blockchain.silentpayments.subscribe"` Frigate Electrum RPC method.
+/// It returns The silent payment address that has been subscribed.
+///
+/// See: https://github.com/sparrowwallet/frigate#blockchainsilentpaymentssubscribe
+#[cfg(feature = "frigate")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Subscribe {
+    pub scan_priv_key: SecretKey,
+    pub scan_pub_key: PublicKey,
+    pub start_height: Option<u32>,
+    pub labels: Option<Vec<u32>>,
+}
+
+#[cfg(feature = "frigate")]
+impl Request for Subscribe {
+    type Response = String;
+
+    fn to_method_and_params(&self) -> MethodAndParams {
+        let mut params = vec![
+            serde_json::json!(self.scan_priv_key),
+            serde_json::json!(self.scan_pub_key),
+        ];
+
+        if let Some(start_height) = self.start_height {
+            params.push(start_height.into());
+        }
+
+        if let Some(labels) = &self.labels {
+            params.push(labels.clone().into());
+        }
+
+        ("blockchain.silentpayments.subscribe".into(), params)
+    }
+}
+
+/// A request to unsubscribe to payment outputs belonging to the provided keys
+///
+/// This corresponds to the `"blockchain.silentpayments.unsubscribe"` Frigate Electrum RPC method.
+/// It returns The silent payment address that has been subscribed.This should cancel any scans that
+/// may be currently running for this address.
+///
+/// See: https://github.com/sparrowwallet/frigate#blockchainsilentpaymentsunsubscribe
+#[cfg(feature = "frigate")]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct UnSubscribe {
+    pub scan_priv_key: SecretKey,
+    pub scan_pub_key: PublicKey,
+}
+
+#[cfg(feature = "frigate")]
+impl Request for UnSubscribe {
+    type Response = String;
+
+    fn to_method_and_params(&self) -> MethodAndParams {
+        (
+            "blockchain.silentpayments.unsubscribe".into(),
+            vec![
+                serde_json::json!(self.scan_priv_key),
+                serde_json::json!(self.scan_pub_key),
+            ],
+        )
+    }
+}