Implement version specific types

Author: GideonBature

client/src/client_sync/mod.rs

@@ -300,11 +300,13 @@ pub enum ScanAction {
     Status,
 }
 
-/// Represents the range for HD descriptor scanning.
+/// Represents the range for HD descriptor scanning (handles n or [n, n]).
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
 #[serde(untagged)]
 pub enum ScanRange {
+    /// Represents the end index (beginning is 0).
     Single(u64),
+    /// Array represents [begin, end] indexes
     Range([u64; 2]),
 }
 
@@ -314,15 +316,91 @@ fn default_scan_range() -> ScanRange {
     ScanRange::Single(1000)
 }
 
-/// Represents a scan object for scantxoutset, either a descriptor string
-/// or an object with descriptor and range.
+/// Represents a scan object for scantxoutset (descriptor string or object).
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
 #[serde(untagged)]
 pub enum ScanObject {
+    /// Plain descriptor string
     Descriptor(String),
+    /// Object containing descriptor and optional range
     WithRange {
         desc: String,
         #[serde(default = "default_scan_range")]
         range: ScanRange,
     },
 }
+
+/// Args for the `importmulti`
+///
+/// Represents the scriptPubKey field in an importmulti request.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(untagged)]
+pub enum ImportMultiScriptPubKey {
+    /// Script hex string
+    Script(String),
+    /// Address object
+    Address { address: String },
+}
+
+/// Represents the timestamp field in an importmulti request.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(untagged)]
+pub enum ImportMultiTimestamp {
+    /// Use current blockchain time
+    Now(String),
+    /// Specific UNIX epoch time
+    Time(u64),
+}
+
+impl Default for ImportMultiTimestamp {
+    fn default() -> Self { ImportMultiTimestamp::Now("now".to_string()) }
+}
+
+/// Represents a single request object within the importmulti call.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Default)]
+pub struct ImportMultiRequest {
+    /// Descriptor to import (optional, mutually exclusive with scriptPubKey/address etc.) (v18+)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub desc: Option<String>,
+    /// ScriptPubKey or address object (required unless desc is provided)
+    #[serde(rename = "scriptPubKey", skip_serializing_if = "Option::is_none")]
+    pub script_pub_key: Option<ImportMultiScriptPubKey>,
+    /// Creation time of the key
+    pub timestamp: ImportMultiTimestamp,
+    /// Redeem script (P2SH/P2SH-P2WSH only)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub redeemscript: Option<String>,
+    /// Witness script (P2WSH/P2SH-P2WSH only) (v18+)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub witnessscript: Option<String>,
+    /// Pubkeys to import (cannot be used with descriptor)
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub pubkeys: Vec<String>,
+    /// Private keys to import (WIF format)
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub keys: Vec<String>,
+    /// Range for ranged descriptors (v18+)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub range: Option<ScanRange>,
+    /// Treat matching outputs as change
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub internal: Option<bool>,
+    /// Treat matching outputs as watchonly
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub watchonly: Option<bool>,
+    /// Label for address (use "" for default)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub label: Option<String>,
+    /// Add pubkeys to keypool (only when private keys disabled) (v18+)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub keypool: Option<bool>,
+}
+
+/// Represents the optional options object for importmulti
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Default)]
+/// Rescan after import (default true)
+pub struct ImportMultiOptions {
+    /// Rescan after import (default true)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rescan: Option<bool>,
+}

client/src/client_sync/v17/blockchain.rs

@@ -370,3 +370,32 @@ macro_rules! impl_client_v17__verifychain {
         }
     };
 }
+
+/// Implements Bitcoin Core JSON-RPC API method `scantxoutset`
+#[macro_export]
+macro_rules! impl_client_v17__scantxoutset {
+    () => {
+        impl Client {
+            pub fn scan_tx_out_set(
+                &self,
+                action: ScanAction,
+                scan_objects: Option<&[ScanObject]>,
+            ) -> Result<ScanTxOutSet> {
+                let params = match action {
+                    ScanAction::Start => match scan_objects {
+                        Some(objects) =>
+                            vec![serde_json::to_value(action)?, serde_json::to_value(objects)?],
+                        None =>
+                            return Err(Error::Returned(
+                                "scan_objects required for 'start'".to_string(),
+                            )),
+                    },
+                    ScanAction::Abort | ScanAction::Status => {
+                        vec![serde_json::to_value(action)?]
+                    }
+                };
+                self.call("scantxoutset", &params)
+            }
+        }
+    };
+}

client/src/client_sync/v17/mod.rs

@@ -19,8 +19,10 @@ use bitcoin::address::{Address, NetworkChecked};
 use bitcoin::{Amount, Block, BlockHash, PublicKey, Txid};
 use serde::{Deserialize, Serialize};
 
-use crate::client_sync::into_json;
-use crate::client_sync::{AddNodeCommand, SetBanCommand};
+use crate::client_sync::{
+    into_json, AddNodeCommand, ImportMultiOptions, ImportMultiRequest, ScanAction, ScanObject,
+    SetBanCommand,
+};
 use crate::types::v17::*;
 
 #[rustfmt::skip]                // Keep public re-exports separate.
@@ -53,6 +55,7 @@ crate::impl_client_v17__verifytxoutproof!();
 crate::impl_client_v17__pruneblockchain!();
 crate::impl_client_v17__savemempool!();
 crate::impl_client_v17__verifychain!();
+crate::impl_client_v17__scantxoutset!();
 
 // == Control ==
 crate::impl_client_v17__getmemoryinfo!();
@@ -141,6 +144,7 @@ crate::impl_client_v17__settxfee!();
 crate::impl_client_v17__walletlock!();
 crate::impl_client_v17__walletpassphrase!();
 crate::impl_client_v17__walletpassphrasechange!();
+crate::impl_client_v17__importmulti!();
 
 /// Argument to the `Client::get_new_address_with_type` function.
 ///

client/src/client_sync/v17/network.rs

@@ -70,11 +70,8 @@ macro_rules! impl_client_v17__addnode {
                 match self.call("addnode", params) {
                     Ok(serde_json::Value::Null) => Ok(AddNode),
                     Ok(ref val) if val.is_null() => Ok(AddNode),
-                    Ok(other) => {
-                        Err(Error::Returned(format!(
-                            "addnode expected null, got: {}", other
-                        )))
-                    },
+                    Ok(other) =>
+                        Err(Error::Returned(format!("addnode expected null, got: {}", other))),
                     Err(e) => Err(e.into()),
                 }
             }
@@ -91,7 +88,8 @@ macro_rules! impl_client_v17__clearbanned {
                 match self.call("clearbanned", &[]) {
                     Ok(serde_json::Value::Null) => Ok(ClearBanned),
                     Ok(ref val) if val.is_null() => Ok(ClearBanned),
-                    Ok(other) => Err(Error::Returned(format!("clearbanned expected null, got: {}", other))),
+                    Ok(other) =>
+                        Err(Error::Returned(format!("clearbanned expected null, got: {}", other))),
                     Err(e) => Err(e.into()),
                 }
             }
@@ -111,7 +109,8 @@ macro_rules! impl_client_v17__setban {
                 bantime: Option<i64>,
                 absolute: Option<bool>,
             ) -> Result<SetBan> {
-                let mut params: Vec<serde_json::Value> = vec![subnet.into(), serde_json::to_value(command)?,];
+                let mut params: Vec<serde_json::Value> =
+                    vec![subnet.into(), serde_json::to_value(command)?];
 
                 if bantime.is_some() || absolute.is_some() {
                     params.push(bantime.map_or(serde_json::Value::Null, |t| t.into()));
@@ -124,9 +123,8 @@ macro_rules! impl_client_v17__setban {
                 match self.call("setban", &params) {
                     Ok(serde_json::Value::Null) => Ok(SetBan),
                     Ok(ref val) if val.is_null() => Ok(SetBan),
-                    Ok(other) => {
-                        Err(Error::Returned(format!("setban expected null, got: {}", other)))
-                    },
+                    Ok(other) =>
+                        Err(Error::Returned(format!("setban expected null, got: {}", other))),
                     Err(e) => Err(e.into()),
                 }
             }
@@ -139,9 +137,7 @@ macro_rules! impl_client_v17__setban {
 macro_rules! impl_client_v17__listbanned {
     () => {
         impl Client {
-            pub fn list_banned(&self) -> Result<ListBanned> {
-                self.call("listbanned", &[])
-            }
+            pub fn list_banned(&self) -> Result<ListBanned> { self.call("listbanned", &[]) }
         }
     };
 }
@@ -174,9 +170,10 @@ macro_rules! impl_client_v17__disconnectnode {
                 match self.call("disconnectnode", &params) {
                     Ok(serde_json::Value::Null) => Ok(DisconnectNode),
                     Ok(ref val) if val.is_null() => Ok(DisconnectNode),
-                    Ok(other) => {
-                        Err(Error::Returned(format!("disconnectnode expected null, got: {}", other)))
-                    }
+                    Ok(other) => Err(Error::Returned(format!(
+                        "disconnectnode expected null, got: {}",
+                        other
+                    ))),
                     Err(e) => Err(e.into()),
                 }
             }
@@ -205,9 +202,8 @@ macro_rules! impl_client_v17__ping {
                 match self.call("ping", &[]) {
                     Ok(serde_json::Value::Null) => Ok(Ping),
                     Ok(ref val) if val.is_null() => Ok(Ping),
-                    Ok(other) => {
-                        Err(Error::Returned(format!("ping expected null, got: {}", other)))
-                    }
+                    Ok(other) =>
+                        Err(Error::Returned(format!("ping expected null, got: {}", other))),
                     Err(e) => Err(e.into()),
                 }
             }
@@ -224,9 +220,10 @@ macro_rules! impl_client_v17__setnetworkactive {
                 match self.call("setnetworkactive", &[state.into()]) {
                     Ok(serde_json::Value::Null) => Ok(SetNetworkActive),
                     Ok(ref val) if val.is_null() => Ok(SetNetworkActive),
-                    Ok(other) => {
-                        Err(Error::Returned(format!("setnetworkactive expected null, got: {}", other)))
-                    }
+                    Ok(other) => Err(Error::Returned(format!(
+                        "setnetworkactive expected null, got: {}",
+                        other
+                    ))),
                     Err(e) => Err(e.into()),
                 }
             }