Merge branch 'master' into 202008-utxo-info

Author: stevenroose

client/src/client.rs

@@ -285,8 +285,10 @@ pub trait RpcApi: Sized {
             opt_into_json(passphrase)?,
             opt_into_json(avoid_reuse)?,
         ];
-        self.call("createwallet", handle_defaults(
-            &mut args, &[false.into(), false.into(), into_json("")?, false.into()]))
+        self.call(
+            "createwallet",
+            handle_defaults(&mut args, &[false.into(), false.into(), into_json("")?, false.into()]),
+        )
     }
 
     fn list_wallets(&self) -> Result<Vec<String>> {
@@ -994,6 +996,23 @@ pub trait RpcApi: Sized {
     fn get_tx_out_set_info(&self) -> Result<json::GetTxOutSetInfoResult> {
         self.call("gettxoutsetinfo", &[])
     }
+
+    /// Returns information about network traffic, including bytes in, bytes out,
+    /// and current time.
+    fn get_net_totals(&self) -> Result<json::GetNetTotalsResult> {
+        self.call("getnettotals", &[])
+    }
+
+    /// Returns the estimated network hashes per second based on the last n blocks.
+    fn get_network_hash_ps(&self, nblocks: Option<u64>, height: Option<u64>) -> Result<f64> {
+        let mut args = [opt_into_json(nblocks)?, opt_into_json(height)?];
+        self.call("getnetworkhashps", handle_defaults(&mut args, &[null(), null()]))
+    }
+
+    /// Returns the total uptime of the server in seconds
+    fn uptime(&self) -> Result<u64> {
+        self.call("uptime", &[])
+    }
 }
 
 /// Client implements a JSON-RPC client for the Bitcoin Core daemon or compatible APIs.

integration_test/src/main.rs

@@ -148,6 +148,9 @@ fn main() {
     test_rescan_blockchain(&cl);
     test_create_wallet(&cl);
     test_get_tx_out_set_info(&cl);
+    test_get_net_totals(&cl);
+    test_get_network_hash_ps(&cl);
+    test_uptime(&cl);
     //TODO import_multi(
     //TODO verify_message(
     //TODO wait_for_new_block(&self, timeout: u64) -> Result<json::BlockRef> {
@@ -215,11 +218,13 @@ fn test_get_balance_generate_to_address(cl: &Client) {
 }
 
 fn test_get_balances_generate_to_address(cl: &Client) {
-    let initial = cl.get_balances().unwrap();
+    if version() >= 190000 {
+        let initial = cl.get_balances().unwrap();
 
-    let blocks = cl.generate_to_address(500, &cl.get_new_address(None, None).unwrap()).unwrap();
-    assert_eq!(blocks.len(), 500);
-    assert_ne!(cl.get_balances().unwrap(), initial);
+        let blocks = cl.generate_to_address(500, &cl.get_new_address(None, None).unwrap()).unwrap();
+        assert_eq!(blocks.len(), 500);
+        assert_ne!(cl.get_balances().unwrap(), initial);
+    }
 }
 
 fn test_get_best_block_hash(cl: &Client) {
@@ -827,44 +832,42 @@ fn test_create_wallet(cl: &Client) {
             blank: Some(true),
             passphrase: None,
             avoid_reuse: None,
-        }
+        },
     ];
 
     if version() >= 190000 {
-        wallet_params.push(
-            WalletParams {
-                name: wallet_names[3],
-                disable_private_keys: None,
-                blank: None,
-                passphrase: Some("pass"),
-                avoid_reuse: None,
-            }
-        );
-        wallet_params.push(
-            WalletParams {
-                name: wallet_names[4],
-                disable_private_keys: None,
-                blank: None,
-                passphrase: None,
-                avoid_reuse: Some(true),
-            }
-        );
+        wallet_params.push(WalletParams {
+            name: wallet_names[3],
+            disable_private_keys: None,
+            blank: None,
+            passphrase: Some("pass"),
+            avoid_reuse: None,
+        });
+        wallet_params.push(WalletParams {
+            name: wallet_names[4],
+            disable_private_keys: None,
+            blank: None,
+            passphrase: None,
+            avoid_reuse: Some(true),
+        });
     }
 
     for wallet_param in wallet_params {
         let result = cl
-        .create_wallet(
-            wallet_param.name,
-            wallet_param.disable_private_keys,
-            wallet_param.blank,
-            wallet_param.passphrase,
-            wallet_param.avoid_reuse,
-        )
-        .unwrap();
+            .create_wallet(
+                wallet_param.name,
+                wallet_param.disable_private_keys,
+                wallet_param.blank,
+                wallet_param.passphrase,
+                wallet_param.avoid_reuse,
+            )
+            .unwrap();
 
         assert_eq!(result.name, wallet_param.name);
         let expected_warning = match (wallet_param.passphrase, wallet_param.avoid_reuse) {
-            (None, Some(true)) => Some("Empty string given as passphrase, wallet will not be encrypted.".to_string()),
+            (None, Some(true)) => {
+                Some("Empty string given as passphrase, wallet will not be encrypted.".to_string())
+            }
             _ => Some("".to_string()),
         };
         assert_eq!(result.warning, expected_warning);
@@ -883,7 +886,8 @@ fn test_create_wallet(cl: &Client) {
         assert_eq!(wallet_info.avoid_reuse.unwrap_or(false), has_avoid_reuse);
         assert_eq!(
             wallet_info.scanning.unwrap_or(json::ScanningDetails::NotScanning(false)),
-            json::ScanningDetails::NotScanning(false));
+            json::ScanningDetails::NotScanning(false)
+        );
     }
 
     let mut wallet_list = cl.list_wallets().unwrap();
@@ -901,6 +905,18 @@ fn test_get_tx_out_set_info(cl: &Client) {
     cl.get_tx_out_set_info().unwrap();
 }
 
+fn test_get_net_totals(cl: &Client) {
+    cl.get_net_totals().unwrap();
+}
+
+fn test_get_network_hash_ps(cl: &Client) {
+    cl.get_network_hash_ps(None, None).unwrap();
+}
+
+fn test_uptime(cl: &Client) {
+    cl.uptime().unwrap();
+}
+
 fn test_stop(cl: Client) {
     println!("Stopping: '{}'", cl.stop().unwrap());
 }

json/src/lib.rs

@@ -157,7 +157,10 @@ pub struct GetWalletInfoResult {
 #[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
 #[serde(untagged)]
 pub enum ScanningDetails {
-    Scanning { duration: usize, progress: f32 },
+    Scanning {
+        duration: usize,
+        progress: f32,
+    },
     NotScanning(bool),
 }
 
@@ -394,6 +397,7 @@ pub struct WalletTxInfo {
     pub blockhash: Option<bitcoin::BlockHash>,
     pub blockindex: Option<usize>,
     pub blocktime: Option<u64>,
+    pub blockheight: Option<u32>,
     pub txid: bitcoin::Txid,
     pub time: u64,
     pub timereceived: u64,
@@ -1200,6 +1204,39 @@ pub struct GetTxOutSetInfoResult {
     pub total_amount: Amount,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
+pub struct GetNetTotalsResult {
+    /// Total bytes received
+    #[serde(rename = "totalbytesrecv")]
+    pub total_bytes_recv: u64,
+    /// Total bytes sent
+    #[serde(rename = "totalbytessent")]
+    pub total_bytes_sent: u64,
+    /// Current UNIX time in milliseconds
+    #[serde(rename = "timemillis")]
+    pub time_millis: u64,
+    /// Upload target statistics
+    #[serde(rename = "uploadtarget")]
+    pub upload_target: GetNetTotalsResultUploadTarget,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
+pub struct GetNetTotalsResultUploadTarget {
+    /// Length of the measuring timeframe in seconds
+    #[serde(rename = "timeframe")]
+    pub time_frame: u64,
+    /// Target in bytes
+    pub target: u64,
+    /// True if target is reached
+    pub target_reached: bool,
+    /// True if serving historical blocks
+    pub serve_historical_blocks: bool,
+    /// Bytes left in current time cycle
+    pub bytes_left_in_cycle: u64,
+    /// Seconds left in current time cycle
+    pub time_left_in_cycle: u64,
+}
+
 /// Used to represent an address type.
 #[derive(Copy, Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
 #[serde(rename_all = "kebab-case")]