Merge branch 'master' into bump-0.25

Author: stevenroose

.travis.yml

@@ -1,32 +1,15 @@
 language: rust
 rust:
   - stable
-  - beta
   - nightly
-  - 1.24.0
+  - 1.29.0
 env:
   - BITCOINVERSION=0.18.0
   - BITCOINVERSION=0.18.1
   - BITCOINVERSION=0.19.0.1
   - BITCOINVERSION=0.19.1
-
-matrix:
-  allow_failures:
-    rust: 1.24.0
+  - BITCOINVERSION=0.20.0
+  - BITCOINVERSION=0.20.1
 
 script:
-  - |
-    if [[ "$TRAVIS_RUST_VERSION" == stable ]]
-    then
-      rustup component add rustfmt
-      cargo fmt --all -- --check
-    fi
-  - cargo build --verbose
-  - cargo test --verbose
-  - cargo build --verbose --examples
-  # Integration test
-  - wget https://bitcoincore.org/bin/bitcoin-core-$BITCOINVERSION/bitcoin-$BITCOINVERSION-x86_64-linux-gnu.tar.gz
-  - tar -xzvf bitcoin-$BITCOINVERSION-x86_64-linux-gnu.tar.gz
-  - export PATH=$PATH:$(pwd)/bitcoin-$BITCOINVERSION/bin
-  - (cd integration_test && ./run.sh)
-
+  - ./contrib/test.sh

README.md

@@ -35,3 +35,18 @@ fn main() {
 ```
 
 See `client/examples/` for more usage examples. 
+
+
+# Minimum Supported Rust Version (MSRV)
+This library should always compile with any combination of features on **Rust 1.29**.
+
+Because some dependencies have broken the build in minor/patch releases, to
+compile with 1.29.0 you will need to run the following version-pinning command:
+```
+cargo update --package "cc" --precise "1.0.41"
+cargo update --package "cfg-if" --precise "0.1.9"
+cargo update --package "unicode-normalization" --precise "0.1.9"
+cargo update --package "serde_json" --precise "1.0.39"
+cargo update --package "serde" --precise "1.0.98"
+cargo update --package "serde_derive" --precise "1.0.98"
+```

client/src/client.rs

@@ -25,11 +25,11 @@ use bitcoin::{
     Address, Amount, Block, BlockHeader, OutPoint, PrivateKey, PublicKey, Script, Transaction,
 };
 use log::Level::{Debug, Trace, Warn};
-use serde::{Deserialize, Serialize};
 
 use error::*;
 use json;
 use queryable;
+use serde_json::Value;
 
 /// Crate-specific Result type, shorthand for `std::result::Result` with our
 /// crate-specific Error type;
@@ -363,11 +363,15 @@ pub trait RpcApi: Sized {
             use Error::UnexpectedStructure as err;
 
             // First, remove both incompatible softfork fields.
-            let map = raw.as_object_mut().ok_or(err)?;
-            let bip9_softforks = map.remove("bip9_softforks").ok_or(err)?;
-            let old_softforks = map.remove("softforks").ok_or(err)?;
-            // Put back an empty "softforks" field.
-            map.insert("softforks".into(), serde_json::Map::new().into());
+            // We need to scope the mutable ref here for v1.29 borrowck.
+            let (bip9_softforks, old_softforks) = {
+                let map = raw.as_object_mut().ok_or(err)?;
+                let bip9_softforks = map.remove("bip9_softforks").ok_or(err)?;
+                let old_softforks = map.remove("softforks").ok_or(err)?;
+                // Put back an empty "softforks" field.
+                map.insert("softforks".into(), serde_json::Map::new().into());
+                (bip9_softforks, old_softforks)
+            };
             let mut ret: json::GetBlockchainInfoResult = serde_json::from_value(raw)?;
 
             // Then convert both softfork types and add them.
@@ -399,7 +403,7 @@ pub trait RpcApi: Sized {
                 }
                 let sf: OldBip9SoftFork = serde_json::from_value(sf.clone())?;
                 ret.softforks.insert(
-                    id.into(),
+                    id.clone(),
                     json::Softfork {
                         type_: json::SoftforkType::Bip9,
                         bip9: Some(json::Bip9SoftforkInfo {
@@ -1013,6 +1017,13 @@ pub trait RpcApi: Sized {
     fn uptime(&self) -> Result<u64> {
         self.call("uptime", &[])
     }
+
+    fn scan_tx_out_set_blocking(
+        &self,
+        descriptors: &[json::ScanTxOutRequest],
+    ) -> Result<json::ScanTxOutResult> {
+        self.call("scantxoutset", &["start".into(), into_json(descriptors)?])
+    }
 }
 
 /// Client implements a JSON-RPC client for the Bitcoin Core daemon or compatible APIs.

contrib/test.sh

@@ -0,0 +1,27 @@
+
+# Pin dependencies for Rust v1.29
+if [ "$TRAVIS_RUST_VERSION" = "1.29.0" ]; then
+    cargo generate-lockfile --verbose
+    cargo update --verbose --package "cc" --precise "1.0.41"
+    cargo update --verbose --package "cfg-if" --precise "0.1.9"
+    cargo update --verbose --package "unicode-normalization" --precise "0.1.9"
+    cargo update --verbose --package "serde_json" --precise "1.0.39"
+    cargo update --verbose --package "serde" --precise "1.0.98"
+    cargo update --verbose --package "serde_derive" --precise "1.0.98"
+fi
+
+if [ "$TRAVIS_RUST_VERSION" = "stable" ]; then
+  rustup component add rustfmt
+  cargo fmt --all -- --check
+fi
+
+cargo build --verbose
+cargo test --verbose
+cargo build --verbose --examples
+
+# Integration test
+wget https://bitcoincore.org/bin/bitcoin-core-$BITCOINVERSION/bitcoin-$BITCOINVERSION-x86_64-linux-gnu.tar.gz
+tar -xzvf bitcoin-$BITCOINVERSION-x86_64-linux-gnu.tar.gz
+export PATH=$PATH:$(pwd)/bitcoin-$BITCOINVERSION/bin
+(cd integration_test && ./run.sh)
+

integration_test/Cargo.toml

@@ -5,5 +5,6 @@ authors = ["Steven Roose <steven@stevenroose.org>"]
 
 [dependencies]
 bitcoincore-rpc = { path = "../client" }
-lazy_static = "1.4.0"
 bitcoin = { version = "0.25", features = [ "use-serde", "rand" ] }
+lazy_static = "1.4.0"
+log = "0.4"

integration_test/run.sh

@@ -19,11 +19,16 @@ PID1=$!
 sleep 3
 
 BLOCKFILTERARG=""
-if bitcoind -version | grep -q "0\.19"; then
+if bitcoind -version | grep -q "0\.19\|0\.20"; then
     BLOCKFILTERARG="-blockfilterindex=1"
 fi
 
-bitcoind -regtest $BLOCKFILTERARG \
+FALLBACKFEEARG=""
+if bitcoind -version | grep -q "0\.20"; then
+    FALLBACKFEEARG="-fallbackfee=0.00001000"
+fi
+
+bitcoind -regtest $BLOCKFILTERARG $FALLBACKFEEARG \
     -datadir=${TESTDIR}/2 \
     -connect=127.0.0.1:12348 \
     -rpcport=12349 \
@@ -34,7 +39,10 @@ PID2=$!
 # Let it connect to the other node.
 sleep 5
 
-RPC_URL=http://localhost:12349 RPC_COOKIE=${TESTDIR}/2/regtest/.cookie cargo run
+RPC_URL=http://localhost:12349 \
+    RPC_COOKIE=${TESTDIR}/2/regtest/.cookie \
+    cargo run
+
 RESULT=$?
 
 kill -9 $PID1 $PID2

integration_test/src/main.rs

@@ -14,6 +14,7 @@ extern crate bitcoin;
 extern crate bitcoincore_rpc;
 #[macro_use]
 extern crate lazy_static;
+extern crate log;
 
 use std::collections::HashMap;
 
@@ -29,6 +30,7 @@ use bitcoin::{
     Address, Amount, Network, OutPoint, PrivateKey, Script, SigHashType, SignedAmount, Transaction,
     TxIn, TxOut, Txid,
 };
+use bitcoincore_rpc::bitcoincore_rpc_json::ScanTxOutRequest;
 
 lazy_static! {
     static ref SECP: secp256k1::Secp256k1<secp256k1::All> = secp256k1::Secp256k1::new();
@@ -39,6 +41,24 @@ lazy_static! {
     static ref FEE: Amount = Amount::from_btc(0.001).unwrap();
 }
 
+struct StdLogger;
+
+impl log::Log for StdLogger {
+    fn enabled(&self, metadata: &log::Metadata) -> bool {
+        metadata.target().contains("jsonrpc") || metadata.target().contains("bitcoincore_rpc")
+    }
+
+    fn log(&self, record: &log::Record) {
+        if self.enabled(record.metadata()) {
+            println!("[{}][{}]: {}", record.level(), record.metadata().target(), record.args());
+        }
+    }
+
+    fn flush(&self) {}
+}
+
+static LOGGER: StdLogger = StdLogger;
+
 /// Assert that the call returns a "deprecated" error.
 macro_rules! assert_deprecated {
     ($call:expr) => {
@@ -89,6 +109,8 @@ fn get_auth() -> bitcoincore_rpc::Auth {
 }
 
 fn main() {
+    log::set_logger(&LOGGER).map(|()| log::set_max_level(log::LevelFilter::max())).unwrap();
+
     let rpc_url = get_rpc_url();
     let auth = get_auth();
 
@@ -137,6 +159,7 @@ fn main() {
     test_combine_psbt(&cl);
     test_finalize_psbt(&cl);
     test_list_received_by_address(&cl);
+    test_scantxoutset(&cl);
     test_import_public_key(&cl);
     test_import_priv_key(&cl);
     test_import_address(&cl);
@@ -279,16 +302,33 @@ fn test_get_address_info(cl: &Client) {
     assert!(!info.hex.unwrap().is_empty());
 }
 
+#[allow(deprecated)]
 fn test_set_label(cl: &Client) {
     let addr = cl.get_new_address(Some("label"), None).unwrap();
     let info = cl.get_address_info(&addr).unwrap();
-    assert_eq!(&info.label, "label");
-    assert_eq!(info.labels[0].name, "label");
+    if version() >= 0_20_00_00 {
+        assert!(info.label.is_none());
+        assert_eq!(info.labels[0], json::GetAddressInfoResultLabel::Simple("label".into()));
+    } else {
+        assert_eq!(info.label.as_ref().unwrap(), "label");
+        assert_eq!(info.labels[0], json::GetAddressInfoResultLabel::WithPurpose {
+            name: "label".into(),
+            purpose: json::GetAddressInfoResultLabelPurpose::Receive,
+        });
+    }
 
     cl.set_label(&addr, "other").unwrap();
     let info = cl.get_address_info(&addr).unwrap();
-    assert_eq!(&info.label, "other");
-    assert_eq!(info.labels[0].name, "other");
+    if version() >= 0_20_00_00 {
+        assert!(info.label.is_none());
+        assert_eq!(info.labels[0], json::GetAddressInfoResultLabel::Simple("other".into()));
+    } else {
+        assert_eq!(info.label.as_ref().unwrap(), "other");
+        assert_eq!(info.labels[0], json::GetAddressInfoResultLabel::WithPurpose {
+            name: "other".into(),
+            purpose: json::GetAddressInfoResultLabelPurpose::Receive,
+        });
+    }
 }
 
 fn test_send_to_address(cl: &Client) {
@@ -916,6 +956,20 @@ fn test_uptime(cl: &Client) {
     cl.uptime().unwrap();
 }
 
+fn test_scantxoutset(cl: &Client) {
+    let addr = cl.get_new_address(None, None).unwrap();
+
+    cl.generate_to_address(2, &addr).unwrap();
+    cl.generate_to_address(7, &cl.get_new_address(None, None).unwrap()).unwrap();
+
+    let utxos = cl
+        .scan_tx_out_set_blocking(&[ScanTxOutRequest::Single(format!("addr({})", addr))])
+        .unwrap();
+
+    assert_eq!(utxos.unspents.len(), 2);
+    assert_eq!(utxos.success, Some(true));
+}
+
 fn test_stop(cl: Client) {
     println!("Stopping: '{}'", cl.stop().unwrap());
 }

json/src/lib.rs

@@ -646,9 +646,13 @@ pub enum GetAddressInfoResultLabelPurpose {
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
-pub struct GetAddressInfoResultLabel {
-    pub name: String,
-    pub purpose: GetAddressInfoResultLabelPurpose,
+#[serde(untagged)]
+pub enum GetAddressInfoResultLabel {
+    Simple(String),
+    WithPurpose {
+        name: String,
+        purpose: GetAddressInfoResultLabelPurpose,
+    }
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
@@ -679,13 +683,15 @@ pub struct GetAddressInfoResult {
     pub embedded: Option<GetAddressInfoResultEmbedded>,
     #[serde(rename = "is_compressed")]
     pub is_compressed: Option<bool>,
-    pub label: String,
     pub timestamp: Option<u64>,
     #[serde(rename = "hdkeypath")]
     pub hd_key_path: Option<bip32::DerivationPath>,
     #[serde(rename = "hdseedid")]
     pub hd_seed_id: Option<bitcoin::XpubIdentifier>,
     pub labels: Vec<GetAddressInfoResultLabel>,
+    /// Deprecated in v0.20.0. See `labels` field instead.
+    #[deprecated(note = "since Core v0.20.0")]
+    pub label: Option<String>,
 }
 
 /// Models the result of "getblockchaininfo"
@@ -1253,6 +1259,47 @@ pub enum PubKeyOrAddress<'a> {
     PubKey(&'a PublicKey),
 }
 
+#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
+#[serde(untagged)]
+/// Start a scan of the UTXO set for an [output descriptor](https://github.com/bitcoin/bitcoin/blob/master/doc/descriptors.md).
+pub enum ScanTxOutRequest {
+    /// Scan for a single descriptor
+    Single(String),
+    /// Scan for a descriptor with xpubs
+    Extended {
+        /// Descriptor
+        desc: String,
+        /// Range of the xpub derivations to scan
+        range: (u64, u64),
+    },
+}
+
+#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
+pub struct ScanTxOutResult {
+    pub success: Option<bool>,
+    #[serde(rename = "txouts")]
+    pub tx_outs: Option<u64>,
+    pub height: Option<u64>,
+    #[serde(rename = "bestblock")]
+    pub best_block_hash: Option<bitcoin::BlockHash>,
+    pub unspents: Vec<Utxo>,
+    #[serde(with = "bitcoin::util::amount::serde::as_btc")]
+    pub total_amount: bitcoin::Amount,
+}
+
+#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Utxo {
+    pub txid: bitcoin::Txid,
+    pub vout: u32,
+    pub script_pub_key: bitcoin::Script,
+    #[serde(rename = "desc")]
+    pub descriptor: String,
+    #[serde(with = "bitcoin::util::amount::serde::as_btc")]
+    pub amount: bitcoin::Amount,
+    pub height: u64,
+}
+
 impl<'a> serde::Serialize for PubKeyOrAddress<'a> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where