failing at generation of address, says no available keys

Author: sandipndev

client/src/client.rs

@@ -264,7 +264,7 @@ pub trait RpcApi: Sized {
         self.call("loadwallet", &[wallet.into()])
     }
 
-    fn unload_wallet(&self, wallet: Option<&str>) -> Result<()> {
+    fn unload_wallet(&self, wallet: Option<&str>) -> Result<json::UnloadWalletResult> {
         let mut args = [opt_into_json(wallet)?];
         self.call("unloadwallet", handle_defaults(&mut args, &[null()]))
     }
@@ -295,25 +295,34 @@ pub trait RpcApi: Sized {
         )
     }
 
-    fn import_descriptors(&self, descriptor: &str, change_descriptor: &str) -> Result<bool> {
-        let ex_descriptor = json::DescriptorFormat {
-            descriptor: descriptor.to_string(),
-            timestamp: "now".to_string(),
+    fn import_descriptors(
+        &self,
+        descriptor: &str,
+        change_descriptor: &str,
+    ) -> Result<Vec<json::ImportDescriptorResult>> {
+        let ex_descriptor = json::ImportDescriptorRequest {
             active: true,
-            range: [0, 100],
+            descriptor: descriptor.to_string(),
+            range: [0, 1000],
+            next_index: 0,
+            timestamp: 1455191478,
             internal: false,
         };
 
-        let in_descriptor = json::DescriptorFormat {
-            descriptor: change_descriptor.to_string(),
-            timestamp: "now".to_string(),
+        let in_descriptor = json::ImportDescriptorRequest {
             active: true,
-            range: [0, 999],
+            descriptor: change_descriptor.to_string(),
+            range: [0, 1000],
+            next_index: 0,
+            timestamp: 1455191478,
             internal: true,
         };
 
-        let args = [into_json(ex_descriptor)?, into_json(in_descriptor)?];
-        self.call("importdescriptors", &args)
+        let arg = into_json([ex_descriptor, in_descriptor])?;
+        println!("arg: {}", arg);
+        let result = self.call("importdescriptors", &[arg]);
+        println!("result: {:?}", result);
+        result
     }
 
     fn list_wallets(&self) -> Result<Vec<String>> {
@@ -1162,8 +1171,10 @@ impl RpcApi for Client {
         if log_enabled!(Debug) {
             debug!(target: "bitcoincore_rpc", "JSON-RPC request: {} {}", cmd, serde_json::Value::from(args));
         }
-
+        println!("client req: {:?}", req);
         let resp = self.client.send_request(req).map_err(Error::from);
+        println!("client resp: {:?}", resp);
+        println!("client resp.result: {:?}", resp.as_ref().map(|r| r.result.as_ref()));
         log_response(cmd, &resp);
         Ok(resp?.result()?)
     }

integration_test/run.sh

@@ -47,6 +47,6 @@ RPC_URL=http://localhost:12349 \
 
 RESULT=$?
 
-kill -9 $PID1 $PID2
+# kill -9 $PID1 $PID2
 
 exit $RESULT

integration_test/src/main.rs

@@ -124,17 +124,18 @@ fn get_auth() -> bitcoincore_rpc::Auth {
 fn main() {
     log::set_logger(&LOGGER).map(|()| log::set_max_level(log::LevelFilter::max())).unwrap();
 
-    let rpc_url = format!("{}/wallet/testwallet", get_rpc_url());
+    let mut rpc_url = format!("{}/wallet/testdescriptorwallet", get_rpc_url());
     let auth = get_auth();
-
-    let cl = Client::new(&rpc_url, auth).unwrap();
+    let mut cl = Client::new(&rpc_url, auth).unwrap();
 
     test_get_network_info(&cl);
     unsafe { VERSION = cl.version().unwrap() };
     println!("Version: {}", version());
 
     test_import_descriptors(&cl);
 
+    rpc_url = format!("{}/wallet/testwallet", get_rpc_url());
+    cl = Client::new(&rpc_url, get_auth()).unwrap();
     cl.create_wallet("testwallet", None, None, None, None, None).unwrap();
 
     test_get_mining_info(&cl);
@@ -1008,14 +1009,20 @@ fn test_create_wallet(cl: &Client) {
 }
 
 fn test_import_descriptors(cl: &Client) {
-    cl.create_wallet("testwallet", Some(false), Some(true), Some(""), Some(false), Some(true))
-        .unwrap();
+    cl.create_wallet(
+        "testdescriptorwallet",
+        Some(false),
+        Some(true),
+        Some(""),
+        Some(false),
+        Some(true),
+    )
+    .unwrap();
 
     let descriptor = "wpkh(tprv8ZgxMBicQKsPeTNzU5evMToRhHA9h3UCxbpzrzjUWUd6TQktkhmY82dQx5f6QaFpSWMzZxKz16xQFGeW7ykPjYuTetU6ep9aFTpAt7jKhPU/44'/0'/0'/0/*)#w2lyh4jx";
-    let x = cl.import_descriptors(descriptor, descriptor);
-    x.unwrap();
+    cl.import_descriptors(descriptor, descriptor).unwrap();
     cl.get_new_address(None, Some(json::AddressType::Bech32m)).unwrap();
-    cl.unload_wallet(Some("testwallet")).unwrap();
+    cl.unload_wallet(Some("testdescriptorwallet")).unwrap();
 }
 
 fn test_get_tx_out_set_info(cl: &Client) {

json/src/lib.rs

@@ -130,6 +130,11 @@ pub struct LoadWalletResult {
     pub warning: Option<String>,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
+pub struct UnloadWalletResult {
+    pub warning: Option<String>,
+}
+
 #[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
 pub struct GetWalletInfoResult {
     #[serde(rename = "walletname")]
@@ -1066,7 +1071,7 @@ pub struct GetPeerInfoResult {
 }
 
 #[derive(Copy, Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
-#[serde(rename_all = "lowercase")]
+#[serde(rename_all = "snake_case")]
 pub enum GetPeerInfoResultNetwork {
     Ipv4,
     Ipv6,
@@ -1690,14 +1695,22 @@ where
     Ok(Some(res))
 }
 
-/// Descriptor Format
+/// Import Descriptor Request
 #[derive(Serialize, Clone, PartialEq, Eq, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct DescriptorFormat {
+pub struct ImportDescriptorRequest {
+    pub active: bool,
     #[serde(rename = "desc")]
     pub descriptor: String,
-    pub active: bool,
     pub range: [i64; 2],
-    pub timestamp: String,
+    pub next_index: i64,
+    pub timestamp: i64,
     pub internal: bool,
 }
+
+/// Imported Descriptor
+#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
+pub struct ImportDescriptorResult {
+    pub success: bool,
+    pub warnings: Option<Vec<String>>,
+    pub error: Option<String>,
+}