Backport missing PRs from Bitcoin 0.14 - Part 6

.github/ISSUE_TEMPLATE.md

@@ -1,8 +1,10 @@
 <!--- Remove sections that do not apply -->
 
-This issue tracker is only for technical issues related to bitcoin-core.
+This issue tracker is only for technical issues related to Dash Core.
 
-General bitcoin questions and/or support requests and are best directed to the [Bitcoin StackExchange](https://bitcoin.stackexchange.com).
+General Dash questions and/or support requests and are best directed to the [Dashpay Reddit](https://www.reddit.com/r/dashpay/).
+
+To report critical security issues, email infosec@dash.org instead of creating Github issues.
 
 ### Describe the issue
 
@@ -21,7 +23,7 @@ Tell us what happens instead
 ### Screenshots.
 If the issue is related to the GUI, screenshots can be added to this issue via drag & drop.
 
-### What version of bitcoin-core are you using?
+### What version of Dash Core are you using?
 List the version number/commit ID, and if it is an official binary, self compiled or a distribution package such as PPA.
 
 ### Machine specs:

configure.ac

@@ -1135,3 +1135,28 @@ case ${OS} in
      mv qa/pull-tester/tests_config-2.py qa/pull-tester/tests_config.py
    ;;
 esac
+
+echo 
+echo "Options used to compile and link:"
+echo "  with wallet   = $enable_wallet"
+echo "  with gui / qt = $bitcoin_enable_qt"
+if test x$bitcoin_enable_qt != xno; then
+    echo "    qt version  = $bitcoin_qt_got_major_vers"
+    echo "    with qr     = $use_qr"
+fi
+echo "  with zmq      = $use_zmq"
+echo "  with test     = $use_tests"
+echo "  with bench    = $use_bench"
+echo "  with upnp     = $use_upnp"
+echo "  debug enabled = $enable_debug"
+echo 
+echo "  target os     = $TARGET_OS"
+echo "  build os      = $BUILD_OS"
+echo
+echo "  CC            = $CC"
+echo "  CFLAGS        = $CFLAGS"
+echo "  CPPFLAGS      = $CPPFLAGS"
+echo "  CXX           = $CXX"
+echo "  CXXFLAGS      = $CXXFLAGS"
+echo "  LDFLAGS       = $LDFLAGS"
+echo 

doc/benchmarking.md

@@ -4,7 +4,7 @@ Benchmarking
 Dash Core has an internal benchmarking framework, with benchmarks
 for cryptographic algorithms such as SHA1, SHA256, SHA512 and RIPEMD160. As well as the rolling bloom filter.
 
-After compiling dash-core, the benchmarks can be run with:
+After compiling Dash Core, the benchmarks can be run with:
 `src/bench/bench_dash`
 
 The output will look similar to:

doc/build-unix.md

@@ -96,13 +96,13 @@ pass `--with-incompatible-bdb` to configure.
 
 See the section "Disable-wallet mode" to build Dash Core without wallet.
 
-Optional:
+Optional (see --with-miniupnpc and --enable-upnp-default):
 
-    sudo apt-get install libminiupnpc-dev (see --with-miniupnpc and --enable-upnp-default)
+    sudo apt-get install libminiupnpc-dev
 
-ZMQ dependencies:
+ZMQ dependencies (provides ZMQ API 4.x):
 
-    sudo apt-get install libzmq3-dev (provides ZMQ API 4.x)
+    sudo apt-get install libzmq3-dev
 
 Dependencies for the GUI: Ubuntu & Debian
 -----------------------------------------

doc/developer-notes.md

@@ -334,6 +334,32 @@ Strings and formatting
 
   - *Rationale*: Dash Core uses tinyformat, which is type safe. Leave them out to avoid confusion
 
+Variable names
+--------------
+
+The shadowing warning (`-Wshadow`) is enabled by default. It prevents issues rising
+from using a different variable with the same name.
+
+Please name variables so that their names do not shadow variables defined in the source code.
+
+E.g. in member initializers, prepend `_` to the argument name shadowing the
+member name:
+
+```c++
+class AddressBookPage
+{
+    Mode mode;
+}
+
+AddressBookPage::AddressBookPage(Mode _mode) :
+      mode(_mode)
+...
+```
+
+When using nested cycles, do not name the inner cycle variable the same as in
+upper cycle etc.
+
+
 Threads and synchronization
 ----------------------------
 

qa/pull-tester/rpc-tests.py

@@ -255,14 +255,18 @@ def __init__(self, num_tests_parallel, test_list=None, flags=None):
         self.test_list = test_list
         self.flags = flags
         self.num_running = 0
+        # In case there is a graveyard of zombie bitcoinds, we can apply a
+        # pseudorandom offset to hopefully jump over them.
+        # (625 is PORT_RANGE/MAX_NODES)
+        self.portseed_offset = int(time.time() * 1000) % 625
         self.jobs = []
 
     def get_next(self):
         while self.num_running < self.num_jobs and self.test_list:
             # Add tests
             self.num_running += 1
             t = self.test_list.pop(0)
-            port_seed = ["--portseed=%s" % len(self.test_list)]
+            port_seed = ["--portseed={}".format(len(self.test_list) + self.portseed_offset)]
             log_stdout = tempfile.SpooledTemporaryFile(max_size=2**16)
             log_stderr = tempfile.SpooledTemporaryFile(max_size=2**16)
             self.jobs.append((t,

qa/rpc-tests/mempool_reorg.py

@@ -48,12 +48,12 @@ def run_test(self):
         # and make sure the mempool code behaves correctly.
         b = [ self.nodes[0].getblockhash(n) for n in range(101, 105) ]
         coinbase_txids = [ self.nodes[0].getblock(h)['tx'][0] for h in b ]
-        spend_101_raw = create_tx(self.nodes[0], coinbase_txids[1], node1_address, 500)
-        spend_102_raw = create_tx(self.nodes[0], coinbase_txids[2], node0_address, 500)
-        spend_103_raw = create_tx(self.nodes[0], coinbase_txids[3], node0_address, 500)
+        spend_101_raw = create_tx(self.nodes[0], coinbase_txids[1], node1_address, 499.9)
+        spend_102_raw = create_tx(self.nodes[0], coinbase_txids[2], node0_address, 499.9)
+        spend_103_raw = create_tx(self.nodes[0], coinbase_txids[3], node0_address, 499.9)
 
         # Create a block-height-locked transaction which will be invalid after reorg
-        timelock_tx = self.nodes[0].createrawtransaction([{"txid": coinbase_txids[0], "vout": 0}], {node0_address: 500})
+        timelock_tx = self.nodes[0].createrawtransaction([{"txid": coinbase_txids[0], "vout": 0}], {node0_address: 499.9})
         # Set the time lock
         timelock_tx = timelock_tx.replace("ffffffff", "11111111", 1)
         timelock_tx = timelock_tx[:-8] + hex(self.nodes[0].getblockcount() + 2)[2:] + "000000"
@@ -67,8 +67,8 @@ def run_test(self):
         assert_raises(JSONRPCException, self.nodes[0].sendrawtransaction, timelock_tx)
 
         # Create 102_1 and 103_1:
-        spend_102_1_raw = create_tx(self.nodes[0], spend_102_id, node1_address, 500)
-        spend_103_1_raw = create_tx(self.nodes[0], spend_103_id, node1_address, 500)
+        spend_102_1_raw = create_tx(self.nodes[0], spend_102_id, node1_address, 499.8)
+        spend_103_1_raw = create_tx(self.nodes[0], spend_103_id, node1_address, 499.8)
 
         # Broadcast and mine 103_1:
         spend_103_1_id = self.nodes[0].sendrawtransaction(spend_103_1_raw)

qa/rpc-tests/preciousblock.py

@@ -8,7 +8,12 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.util import (
+    assert_equal,
+    connect_nodes_bi,
+    sync_chain,
+    sync_blocks,
+)
 
 def unidirectional_node_sync_via_rpc(node_src, node_dest):
     blocks_to_copy = []
@@ -33,84 +38,82 @@ def node_sync_via_rpc(nodes):
             unidirectional_node_sync_via_rpc(node_src, node_dest)
 
 class PreciousTest(BitcoinTestFramework):
-    def setup_chain(self):
-        print("Initializing test directory "+self.options.tmpdir)
-        initialize_chain_clean(self.options.tmpdir, 3)
+    def __init__(self):
+        super().__init__()
+        self.setup_clean_chain = True
+        self.num_nodes = 3
+        self.extra_args = [["-debug"]] * self.num_nodes
 
     def setup_network(self):
-        self.nodes = []
-        self.is_network_split = False
-        self.nodes.append(start_node(0, self.options.tmpdir, ["-debug"]))
-        self.nodes.append(start_node(1, self.options.tmpdir, ["-debug"]))
-        self.nodes.append(start_node(2, self.options.tmpdir, ["-debug"]))
+        self.nodes = self.setup_nodes()
 
     def run_test(self):
         print("Ensure submitblock can in principle reorg to a competing chain")
         self.nodes[0].generate(1)
-        assert(self.nodes[0].getblockcount() == 1)
+        assert_equal(self.nodes[0].getblockcount(), 1)
         (hashY, hashZ) = self.nodes[1].generate(2)
-        assert(self.nodes[1].getblockcount() == 2)
+        assert_equal(self.nodes[1].getblockcount(), 2)
         node_sync_via_rpc(self.nodes[0:3])
-        assert(self.nodes[0].getbestblockhash() == hashZ)
+        assert_equal(self.nodes[0].getbestblockhash(), hashZ)
 
         print("Mine blocks A-B-C on Node 0")
         (hashA, hashB, hashC) = self.nodes[0].generate(3)
-        assert(self.nodes[0].getblockcount() == 5)
+        assert_equal(self.nodes[0].getblockcount(), 5)
         print("Mine competing blocks E-F-G on Node 1")
         (hashE, hashF, hashG) = self.nodes[1].generate(3)
-        assert(self.nodes[1].getblockcount() == 5)
+        assert_equal(self.nodes[1].getblockcount(), 5)
         assert(hashC != hashG)
         print("Connect nodes and check no reorg occurs")
         # Submit competing blocks via RPC so any reorg should occur before we proceed (no way to wait on inaction for p2p sync)
         node_sync_via_rpc(self.nodes[0:2])
         connect_nodes_bi(self.nodes,0,1)
-        assert(self.nodes[0].getbestblockhash() == hashC)
-        assert(self.nodes[1].getbestblockhash() == hashG)
+        assert_equal(self.nodes[0].getbestblockhash(), hashC)
+        assert_equal(self.nodes[1].getbestblockhash(), hashG)
         print("Make Node0 prefer block G")
         self.nodes[0].preciousblock(hashG)
-        assert(self.nodes[0].getbestblockhash() == hashG)
+        assert_equal(self.nodes[0].getbestblockhash(), hashG)
         print("Make Node0 prefer block C again")
         self.nodes[0].preciousblock(hashC)
-        assert(self.nodes[0].getbestblockhash() == hashC)
+        assert_equal(self.nodes[0].getbestblockhash(), hashC)
         print("Make Node1 prefer block C")
         self.nodes[1].preciousblock(hashC)
         sync_chain(self.nodes[0:2]) # wait because node 1 may not have downloaded hashC
-        assert(self.nodes[1].getbestblockhash() == hashC)
+        assert_equal(self.nodes[1].getbestblockhash(), hashC)
         print("Make Node1 prefer block G again")
         self.nodes[1].preciousblock(hashG)
-        assert(self.nodes[1].getbestblockhash() == hashG)
+        assert_equal(self.nodes[1].getbestblockhash(), hashG)
         print("Make Node0 prefer block G again")
         self.nodes[0].preciousblock(hashG)
-        assert(self.nodes[0].getbestblockhash() == hashG)
+        assert_equal(self.nodes[0].getbestblockhash(), hashG)
         print("Make Node1 prefer block C again")
         self.nodes[1].preciousblock(hashC)
-        assert(self.nodes[1].getbestblockhash() == hashC)
+        assert_equal(self.nodes[1].getbestblockhash(), hashC)
         print("Mine another block (E-F-G-)H on Node 0 and reorg Node 1")
         self.nodes[0].generate(1)
-        assert(self.nodes[0].getblockcount() == 6)
+        assert_equal(self.nodes[0].getblockcount(), 6)
         sync_blocks(self.nodes[0:2])
         hashH = self.nodes[0].getbestblockhash()
-        assert(self.nodes[1].getbestblockhash() == hashH)
+        assert_equal(self.nodes[1].getbestblockhash(), hashH)
         print("Node1 should not be able to prefer block C anymore")
         self.nodes[1].preciousblock(hashC)
-        assert(self.nodes[1].getbestblockhash() == hashH)
+        assert_equal(self.nodes[1].getbestblockhash(), hashH)
         print("Mine competing blocks I-J-K-L on Node 2")
         self.nodes[2].generate(4)
-        assert(self.nodes[2].getblockcount() == 6)
+        assert_equal(self.nodes[2].getblockcount(), 6)
         hashL = self.nodes[2].getbestblockhash()
         print("Connect nodes and check no reorg occurs")
         node_sync_via_rpc(self.nodes[0:3])
         connect_nodes_bi(self.nodes,1,2)
         connect_nodes_bi(self.nodes,0,2)
-        assert(self.nodes[0].getbestblockhash() == hashH)
-        assert(self.nodes[1].getbestblockhash() == hashH)
-        assert(self.nodes[2].getbestblockhash() == hashL)
+        assert_equal(self.nodes[0].getbestblockhash(), hashH)
+        assert_equal(self.nodes[1].getbestblockhash(), hashH)
+        assert_equal(self.nodes[2].getbestblockhash(), hashL)
         print("Make Node1 prefer block L")
         self.nodes[1].preciousblock(hashL)
-        assert(self.nodes[1].getbestblockhash() == hashL)
+        assert_equal(self.nodes[1].getbestblockhash(), hashL)
         print("Make Node2 prefer block H")
         self.nodes[2].preciousblock(hashH)
-        assert(self.nodes[2].getbestblockhash() == hashH)
+        assert_equal(self.nodes[2].getbestblockhash(), hashH)
 
 if __name__ == '__main__':
     PreciousTest().main()

qa/rpc-tests/proxy_test.py

@@ -4,10 +4,16 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 import socket
+import os
 
 from test_framework.socks5 import Socks5Configuration, Socks5Command, Socks5Server, AddressType
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.util import (
+    PORT_MIN,
+    PORT_RANGE,
+    start_nodes,
+    assert_equal,
+)
 from test_framework.netutil import test_ipv6_local
 '''
 Test plan:
@@ -33,6 +39,8 @@
 addnode connect to generic DNS name
 '''
 
+RANGE_BEGIN = PORT_MIN + 2 * PORT_RANGE  # Start after p2p and rpc ports
+
 
 class ProxyTest(BitcoinTestFramework):
     def __init__(self):
@@ -44,19 +52,19 @@ def __init__(self):
         # Create two proxies on different ports
         # ... one unauthenticated
         self.conf1 = Socks5Configuration()
-        self.conf1.addr = ('127.0.0.1', 13000 + (os.getpid() % 1000))
+        self.conf1.addr = ('127.0.0.1', RANGE_BEGIN + (os.getpid() % 1000))
         self.conf1.unauth = True
         self.conf1.auth = False
         # ... one supporting authenticated and unauthenticated (Tor)
         self.conf2 = Socks5Configuration()
-        self.conf2.addr = ('127.0.0.1', 14000 + (os.getpid() % 1000))
+        self.conf2.addr = ('127.0.0.1', RANGE_BEGIN + 1000 + (os.getpid() % 1000))
         self.conf2.unauth = True
         self.conf2.auth = True
         if self.have_ipv6:
             # ... one on IPv6 with similar configuration
             self.conf3 = Socks5Configuration()
             self.conf3.af = socket.AF_INET6
-            self.conf3.addr = ('::1', 15000 + (os.getpid() % 1000))
+            self.conf3.addr = ('::1', RANGE_BEGIN + 2000 + (os.getpid() % 1000))
             self.conf3.unauth = True
             self.conf3.auth = True
         else:

qa/rpc-tests/rawtransactions.py

@@ -2,11 +2,15 @@
 # Copyright (c) 2014-2016 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""rawtranscation RPCs QA test.
 
-#
-# Test re-org scenarios with a mempool that contains transactions
-# that spend (directly or indirectly) coinbase transactions.
-#
+# Tests the following RPCs:
+#    - createrawtransaction
+#    - signrawtransaction
+#    - sendrawtransaction
+#    - decoderawtransaction
+#    - getrawtransaction
+"""
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import *
@@ -138,6 +142,33 @@ def run_test(self):
         self.sync_all()
         assert_equal(self.nodes[0].getbalance(), bal+Decimal('500.00000000')+Decimal('2.19000000')) #block reward + tx
 
+        # getrawtransaction tests
+        # 1. valid parameters - only supply txid
+        txHash = rawTx["txid"]
+        assert_equal(self.nodes[0].getrawtransaction(txHash), rawTxSigned['hex'])
+
+        # 2. valid parameters - supply txid and 0 for non-verbose
+        assert_equal(self.nodes[0].getrawtransaction(txHash, 0), rawTxSigned['hex'])
+
+        # 3. valid parameters - supply txid and False for non-verbose
+        assert_equal(self.nodes[0].getrawtransaction(txHash, False), rawTxSigned['hex'])
+
+        # 4. valid parameters - supply txid and 1 for verbose.
+        # We only check the "hex" field of the output so we don't need to update this test every time the output format changes.
+        assert_equal(self.nodes[0].getrawtransaction(txHash, 1)["hex"], rawTxSigned['hex'])
+
+        # 5. valid parameters - supply txid and True for non-verbose
+        assert_equal(self.nodes[0].getrawtransaction(txHash, True)["hex"], rawTxSigned['hex'])
+
+        # 6. invalid parameters - supply txid and string "Flase"
+        assert_raises(JSONRPCException, self.nodes[0].getrawtransaction, txHash, "Flase")
+
+        # 7. invalid parameters - supply txid and empty array
+        assert_raises(JSONRPCException, self.nodes[0].getrawtransaction, txHash, [])
+
+        # 8. invalid parameters - supply txid and empty dict
+        assert_raises(JSONRPCException, self.nodes[0].getrawtransaction, txHash, {})
+
         inputs  = [ {'txid' : "1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000", 'vout' : 1, 'sequence' : 1000}]
         outputs = { self.nodes[0].getnewaddress() : 1 }
         rawtx   = self.nodes[0].createrawtransaction(inputs, outputs)