fix: use bool for getrawtransaction verbose param in Dash tests

The RPC type checking backported in this PR (bitcoin#26039) enforces
strict type checking for RPC parameters. The getrawtransaction
'verbose' parameter is declared as RPCArg::Type::BOOL, so passing
integer 1 instead of True now raises a type error.

Fix all 29 occurrences across 13 test files where getrawtransaction
was called with integer 1 instead of boolean True.

Author: thepastaclaw

test/functional/feature_asset_locks.py

@@ -285,7 +285,7 @@ def test_asset_locks(self, node_wallet, node, pubkey):
         self.check_mempool_result(tx=asset_lock_tx, result_expected={'allowed': True, 'fees': {'base': Decimal(str(tiny_amount / COIN))}})
         self.validate_credit_pool_balance(0)
         txid_in_block = self.send_tx(asset_lock_tx)
-        rpc_tx = node.getrawtransaction(txid_in_block, 1)
+        rpc_tx = node.getrawtransaction(txid_in_block, True)
         assert_equal(len(rpc_tx["assetLockTx"]["creditOutputs"]), 2)
         assert_equal(rpc_tx["assetLockTx"]["creditOutputs"][0]["valueSat"] + rpc_tx["assetLockTx"]["creditOutputs"][1]["valueSat"], locked_1)
         assert_equal(rpc_tx["assetLockTx"]["creditOutputs"][0]["scriptPubKey"]["hex"], key_to_p2pkh_script(pubkey).hex())
@@ -395,8 +395,8 @@ def test_asset_unlocks(self, node_wallet, node, pubkey):
         for node in self.nodes:
             self.wait_for_instantlock(is_id, node)
 
-        rawtx = node.getrawtransaction(txid, 1)
-        rawtx_is = node.getrawtransaction(is_id, 1)
+        rawtx = node.getrawtransaction(txid, True)
+        rawtx_is = node.getrawtransaction(is_id, True)
         assert_equal(rawtx["instantlock"], False)
         assert_equal(rawtx_is["instantlock"], True)
         assert_equal(rawtx["chainlock"], False)
@@ -406,20 +406,20 @@ def test_asset_unlocks(self, node_wallet, node, pubkey):
         self.log.info("Reset IS spork")
         self.set_sporks()
 
-        assert "assetUnlockTx" in node.getrawtransaction(txid, 1)
+        assert "assetUnlockTx" in node.getrawtransaction(txid, True)
 
         self.mempool_size += 2
         self.check_mempool_size()
         self.validate_credit_pool_balance(locked)
         self.generate(node, 1)
         assert_equal(rawtx["instantlock"], False)
         assert_equal(rawtx["chainlock"], False)
-        rawtx = node.getrawtransaction(txid, 1)
+        rawtx = node.getrawtransaction(txid, True)
         assert_equal(rawtx["confirmations"], 1)
         self.validate_credit_pool_balance(locked - COIN)
         self.mempool_size -= 2
         self.check_mempool_size()
-        block_asset_unlock = node.getrawtransaction(asset_unlock_tx.rehash(), 1)['blockhash']
+        block_asset_unlock = node.getrawtransaction(asset_unlock_tx.rehash(), True)['blockhash']
         self.log.info("Checking rpc `getblock` and `getblockstats` succeeds as they use own fee calculation mechanism")
         assert_equal(node.getblockstats(node.getblockcount())['maxfee'], tiny_amount)
         node.getblock(block_asset_unlock, 2)

test/functional/feature_dip3_deterministicmns.py

@@ -181,7 +181,7 @@ def run_test(self):
             self.generate(self.nodes[0], 1)
             if expected_payee == multisig:
                 block = self.nodes[0].getblock(self.nodes[0].getbestblockhash())
-                cbtx = self.nodes[0].getrawtransaction(block['tx'][0], 1)
+                cbtx = self.nodes[0].getrawtransaction(block['tx'][0], True)
                 for out in cbtx['vout']:
                     if 'address' in out['scriptPubKey']:
                         if expected_payee in out['scriptPubKey']['address'] and out['valueSat'] == expected_amount:

test/functional/feature_dip3_v19.py

@@ -135,12 +135,12 @@ def test_revoke_protx(self, node_idx, revoke_mn: MasternodeInfo):
         fund_txid = self.nodes[0].sendtoaddress(funds_address, 1)
         self.bump_mocktime(10 * 60 + 1) # to make tx safe to include in block
         tip = self.generate(self.nodes[0], 1)[0]
-        assert_equal(self.nodes[0].getrawtransaction(fund_txid, 1, tip)['confirmations'], 1)
+        assert_equal(self.nodes[0].getrawtransaction(fund_txid, True, tip)['confirmations'], 1)
 
         protx_result = revoke_mn.revoke(self.nodes[0], submit=True, reason=1, fundsAddr=funds_address)
         self.bump_mocktime(10 * 60 + 1) # to make tx safe to include in block
         tip = self.generate(self.nodes[0], 1, sync_fun=self.no_op)[0]
-        assert_equal(self.nodes[0].getrawtransaction(protx_result, 1, tip)['confirmations'], 1)
+        assert_equal(self.nodes[0].getrawtransaction(protx_result, True, tip)['confirmations'], 1)
         # Revoking a MN results in disconnects. Wait for disconnects to actually happen
         # and then reconnect the corresponding node back to let sync_blocks finish correctly.
         self.wait_until(lambda: self.nodes[node_idx].getconnectioncount() == 0)
@@ -156,12 +156,12 @@ def test_update_service_protx(self, mn: MasternodeInfo):
         fund_txid = self.nodes[0].sendtoaddress(mn.fundsAddr, 1)
         self.bump_mocktime(10 * 60 + 1) # to make tx safe to include in block
         tip = self.generate(self.nodes[0], 1)[0]
-        assert_equal(self.nodes[0].getrawtransaction(fund_txid, 1, tip)['confirmations'], 1)
+        assert_equal(self.nodes[0].getrawtransaction(fund_txid, True, tip)['confirmations'], 1)
 
         protx_result = mn.update_service(self.nodes[0], submit=True, addrs_core_p2p=[f'127.0.0.2:{mn.nodePort}'])
         self.bump_mocktime(10 * 60 + 1) # to make tx safe to include in block
         tip = self.generate(self.nodes[0], 1)[0]
-        assert_equal(self.nodes[0].getrawtransaction(protx_result, 1, tip)['confirmations'], 1)
+        assert_equal(self.nodes[0].getrawtransaction(protx_result, True, tip)['confirmations'], 1)
 
         for node in self.nodes:
             protx_info = node.protx('info', mn.proTxHash)

test/functional/feature_llmq_chainlocks.py

@@ -208,7 +208,7 @@ def run_test(self):
         self.log.info("Assert that after block generation these TXs are NOT included (as they are \"unsafe\")")
         node0_tip = self.generate(self.nodes[0], 1, sync_fun=self.no_op)[-1]
         for txid in txs:
-            tx = self.nodes[0].getrawtransaction(txid, 1)
+            tx = self.nodes[0].getrawtransaction(txid, True)
             assert "confirmations" not in tx
 
         def test_cb(self):
@@ -226,7 +226,7 @@ def test_cb(self):
         self.nodes[0].sporkupdate("SPORK_2_INSTANTSEND_ENABLED", 0)
         self.log.info("Assert that TXs got included now")
         for txid in txs:
-            tx = self.nodes[0].getrawtransaction(txid, 1)
+            tx = self.nodes[0].getrawtransaction(txid, True)
             assert "confirmations" in tx and tx["confirmations"] > 0
         # Enable network on first node again, which will cause the blocks to propagate and IS locks to happen retroactively
         # for the mined TXs, which will then allow the network to create a CLSIG
@@ -256,7 +256,7 @@ def test_cb(self):
 
     def create_chained_txs(self, node, amount):
         txid = node.sendtoaddress(node.getnewaddress(), amount)
-        tx = node.getrawtransaction(txid, 1)
+        tx = node.getrawtransaction(txid, True)
         inputs = []
         valueIn = 0
         for txout in tx["vout"]:

test/functional/feature_mnehf.py

@@ -99,7 +99,7 @@ def check_fork(self, expected):
 
     def ensure_tx_is_not_mined(self, tx_id):
         try:
-            assert_equal(self.nodes[0].getrawtransaction(tx_id, 1)['height'], -1)
+            assert_equal(self.nodes[0].getrawtransaction(tx_id, True)['height'], -1)
             raise AssertionError("Transaction should not be mined")
         except KeyError:
             # KeyError is expected

test/functional/feature_spentindex.py

@@ -97,13 +97,13 @@ def run_test(self):
         self.log.info("Testing getrawtransaction method...")
 
         # Check that verbose raw transaction includes spent info
-        txVerbose = self.nodes[3].getrawtransaction(unspent[0]["txid"], 1)
+        txVerbose = self.nodes[3].getrawtransaction(unspent[0]["txid"], True)
         assert_equal(txVerbose["vout"][unspent[0]["vout"]]["spentTxId"], txid)
         assert_equal(txVerbose["vout"][unspent[0]["vout"]]["spentIndex"], 0)
         assert_equal(txVerbose["vout"][unspent[0]["vout"]]["spentHeight"], 106)
 
         # Check that verbose raw transaction includes input values
-        txVerbose2 = self.nodes[3].getrawtransaction(txid, 1)
+        txVerbose2 = self.nodes[3].getrawtransaction(txid, True)
         assert_equal(txVerbose2["vin"][0]["value"], Decimal(unspent[0]["amount"]))
         assert_equal(txVerbose2["vin"][0]["valueSat"] - tx_fee_sat, amount)
 
@@ -121,15 +121,15 @@ def run_test(self):
 
         # Check the mempool index
         self.sync_all()
-        txVerbose3 = self.nodes[1].getrawtransaction(txid2, 1)
+        txVerbose3 = self.nodes[1].getrawtransaction(txid2, True)
         assert_equal(txVerbose3["vin"][0]["address"], address2)
         assert_equal(txVerbose3["vin"][0]["value"], Decimal(unspent[0]["amount"]) - tx_fee)
         assert_equal(txVerbose3["vin"][0]["valueSat"], amount)
 
         # Check the database index
         self.generate(self.nodes[0], 1)
 
-        txVerbose4 = self.nodes[3].getrawtransaction(txid2, 1)
+        txVerbose4 = self.nodes[3].getrawtransaction(txid2, True)
         assert_equal(txVerbose4["vin"][0]["address"], address2)
         assert_equal(txVerbose4["vin"][0]["value"], Decimal(unspent[0]["amount"]) - tx_fee)
         assert_equal(txVerbose4["vin"][0]["valueSat"], amount)

test/functional/feature_txindex.py

@@ -69,7 +69,7 @@ def run_test(self):
         self.generate(self.nodes[0], 1)
 
         # Check verbose raw transaction results
-        verbose = self.nodes[3].getrawtransaction(txid, 1)
+        verbose = self.nodes[3].getrawtransaction(txid, True)
         assert_equal(verbose["vout"][0]["valueSat"], 50000000000 - tx_fee_sat)
         assert_equal(verbose["vout"][0]["value"] * 100000000, 50000000000 - tx_fee_sat)
 

test/functional/p2p_instantsend.py

@@ -69,11 +69,11 @@ def test_block_doublespend(self):
         # generate block on isolated node with doublespend transaction
         self.bump_mocktime(599)
         wrong_early_block = self.generate(isolated, 1, sync_fun=self.no_op)[0]
-        assert not "confirmation" in isolated.getrawtransaction(dblspnd_txid, 1)
+        assert not "confirmation" in isolated.getrawtransaction(dblspnd_txid, True)
         isolated.invalidateblock(wrong_early_block)
         self.bump_mocktime(1)
         wrong_block = self.generate(isolated, 1, sync_fun=self.no_op)[0]
-        assert_equal(isolated.getrawtransaction(dblspnd_txid, 1)["confirmations"], 1)
+        assert_equal(isolated.getrawtransaction(dblspnd_txid, True)["confirmations"], 1)
         # connect isolated block to network
         self.reconnect_isolated_node(self.isolated_idx, 0)
         # check doublespend block is rejected by other nodes

test/functional/test_framework/test_framework.py

@@ -1183,7 +1183,7 @@ class MasternodeInfo:
 
     def bury_tx(self, test: BitcoinTestFramework, genIdx: int, txid: str, depth: int):
         chain_tip = test.generate(test.nodes[genIdx], depth)[0]
-        assert_equal(test.nodes[genIdx].getrawtransaction(txid, 1, chain_tip)['confirmations'], depth)
+        assert_equal(test.nodes[genIdx].getrawtransaction(txid, True, chain_tip)['confirmations'], depth)
 
     def generate_addresses(self, node: TestNode, force_all: bool = False):
         if not self.collateral_address or force_all:
@@ -1205,7 +1205,7 @@ def get_collateral_value(self) -> int:
         return EVONODE_COLLATERAL if self.evo else MASTERNODE_COLLATERAL
 
     def get_collateral_vout(self, node: TestNode, txid: str, should_throw: bool = True) -> int:
-        for txout in node.getrawtransaction(txid, 1)['vout']:
+        for txout in node.getrawtransaction(txid, True)['vout']:
             if txout['value'] == self.get_collateral_value():
                 return txout['n']
         if should_throw:

test/functional/test_framework/util.py

@@ -585,7 +585,7 @@ def find_output(node, txid, amount, *, blockhash=None):
     Return index to output of txid with value amount
     Raises exception if there is none.
     """
-    txdata = node.getrawtransaction(txid, 1, blockhash)
+    txdata = node.getrawtransaction(txid, True, blockhash)
     for i in range(len(txdata["vout"])):
         if txdata["vout"][i]["value"] == amount:
             return i