scripted-diff: test: rename CTransaction .getwtxid() -> wtxid_hex for consistency

-BEGIN VERIFY SCRIPT-

sed -i "s|def getwtxid|@Property\n    def wtxid_hex|g" ./test/functional/test_framework/messages.py
sed -i "s|getwtxid()|wtxid_hex|g" $(git grep -l getwtxid)

-END VERIFY SCRIPT-

Author: theStack

test/functional/feature_cltv.py

@@ -163,7 +163,7 @@ def run_test(self):
             # First we show that this tx is valid except for CLTV by getting it
             # rejected from the mempool for exactly that reason.
             spendtx_txid = spendtx.txid_hex
-            spendtx_wtxid = spendtx.getwtxid()
+            spendtx_wtxid = spendtx.wtxid_hex
             assert_equal(
                 [{
                     'txid': spendtx_txid,

test/functional/feature_dersig.py

@@ -115,7 +115,7 @@ def run_test(self):
         # First we show that this tx is valid except for DERSIG by getting it
         # rejected from the mempool for exactly that reason.
         spendtx_txid = spendtx.txid_hex
-        spendtx_wtxid = spendtx.getwtxid()
+        spendtx_wtxid = spendtx.wtxid_hex
         assert_equal(
             [{
                 'txid': spendtx_txid,

test/functional/feature_segwit.py

@@ -251,7 +251,7 @@ def run_test(self):
         tx1 = tx_from_hex(tx1_hex)
 
         # Check that wtxid is properly reported in mempool entry (txid1)
-        assert_equal(self.nodes[0].getmempoolentry(txid1)["wtxid"], tx1.getwtxid())
+        assert_equal(self.nodes[0].getmempoolentry(txid1)["wtxid"], tx1.wtxid_hex)
 
         # Check that weight and vsize are properly reported in mempool entry (txid1)
         assert_equal(self.nodes[0].getmempoolentry(txid1)["vsize"], tx1.get_vsize())
@@ -267,7 +267,7 @@ def run_test(self):
         assert not tx.wit.is_null()
 
         # Check that wtxid is properly reported in mempool entry (txid2)
-        assert_equal(self.nodes[0].getmempoolentry(txid2)["wtxid"], tx.getwtxid())
+        assert_equal(self.nodes[0].getmempoolentry(txid2)["wtxid"], tx.wtxid_hex)
 
         # Check that weight and vsize are properly reported in mempool entry (txid2)
         assert_equal(self.nodes[0].getmempoolentry(txid2)["vsize"], tx.get_vsize())
@@ -289,7 +289,7 @@ def run_test(self):
         assert txid3 in template_txids
 
         # Check that wtxid is properly reported in mempool entry (txid3)
-        assert_equal(self.nodes[0].getmempoolentry(txid3)["wtxid"], tx.getwtxid())
+        assert_equal(self.nodes[0].getmempoolentry(txid3)["wtxid"], tx.wtxid_hex)
 
         # Check that weight and vsize are properly reported in mempool entry (txid3)
         assert_equal(self.nodes[0].getmempoolentry(txid3)["vsize"], tx.get_vsize())

test/functional/mempool_accept.py

@@ -454,7 +454,7 @@ def run_test(self):
         anchor_spend.vout.append(CTxOut(anchor_value - int(fee*COIN), script_to_p2wsh_script(CScript([OP_TRUE]))))
         anchor_spend.wit.vtxinwit.append(CTxInWitness())
         # It's "segwit" but txid == wtxid since there is no witness data
-        assert_equal(anchor_spend.txid_hex, anchor_spend.getwtxid())
+        assert_equal(anchor_spend.txid_hex, anchor_spend.wtxid_hex)
 
         self.check_mempool_result(
             result_expected=[{'txid': anchor_spend.txid_hex, 'allowed': True, 'vsize': anchor_spend.get_vsize(), 'fees': { 'base': Decimal('0.00000700')}}],

test/functional/mempool_accept_wtxid.py

@@ -76,13 +76,13 @@ def run_test(self):
         child_one.vout.append(CTxOut(int(9.99996 * COIN), child_script_pubkey))
         child_one.wit.vtxinwit.append(CTxInWitness())
         child_one.wit.vtxinwit[0].scriptWitness.stack = [b'Preimage', b'\x01', witness_script]
-        child_one_wtxid = child_one.getwtxid()
+        child_one_wtxid = child_one.wtxid_hex
         child_one_txid = child_one.txid_hex
 
         # Create another identical transaction with witness solving second branch
         child_two = deepcopy(child_one)
         child_two.wit.vtxinwit[0].scriptWitness.stack = [b'', witness_script]
-        child_two_wtxid = child_two.getwtxid()
+        child_two_wtxid = child_two.wtxid_hex
         child_two_txid = child_two.txid_hex
 
         assert_equal(child_one_txid, child_two_txid)

test/functional/mempool_ephemeral_dust.py

@@ -40,11 +40,11 @@ def add_output_to_create_multi_result(self, result, output_value=0):
         result["new_utxos"][0]["value"] = Decimal(result["tx"].vout[0].nValue) / COIN
         new_txid = result["tx"].txid_hex
         result["txid"]  = new_txid
-        result["wtxid"] = result["tx"].getwtxid()
+        result["wtxid"] = result["tx"].wtxid_hex
         result["hex"] = result["tx"].serialize().hex()
         for new_utxo in result["new_utxos"]:
             new_utxo["txid"] = new_txid
-            new_utxo["wtxid"] = result["tx"].getwtxid()
+            new_utxo["wtxid"] = result["tx"].wtxid_hex
 
         result["new_utxos"].append({"txid": new_txid, "vout": len(result["tx"].vout) - 1, "value": Decimal(output_value) / COIN, "height": 0, "coinbase": False, "confirmations": 0})
 

test/functional/mempool_limit.py

@@ -379,7 +379,7 @@ def run_test(self):
 
         rich_parent_result = submitpackage_result["tx-results"][tx_rich["wtxid"]]
         poor_parent_result = submitpackage_result["tx-results"][tx_poor["wtxid"]]
-        child_result = submitpackage_result["tx-results"][tx_child["tx"].getwtxid()]
+        child_result = submitpackage_result["tx-results"][tx_child["tx"].wtxid_hex]
         assert_fee_amount(poor_parent_result["fees"]["base"], tx_poor["tx"].get_vsize(), relayfee)
         assert_equal(rich_parent_result["fees"]["base"], 0)
         assert_equal(child_result["fees"]["base"], DEFAULT_FEE)
@@ -392,11 +392,11 @@ def run_test(self):
         package_vsize = tx_poor["tx"].get_vsize() + tx_child["tx"].get_vsize()
         assert_fee_amount(package_fees, package_vsize, poor_parent_result["fees"]["effective-feerate"])
         assert_fee_amount(package_fees, package_vsize, child_result["fees"]["effective-feerate"])
-        assert_equal([tx_poor["wtxid"], tx_child["tx"].getwtxid()], poor_parent_result["fees"]["effective-includes"])
-        assert_equal([tx_poor["wtxid"], tx_child["tx"].getwtxid()], child_result["fees"]["effective-includes"])
+        assert_equal([tx_poor["wtxid"], tx_child["tx"].wtxid_hex], poor_parent_result["fees"]["effective-includes"])
+        assert_equal([tx_poor["wtxid"], tx_child["tx"].wtxid_hex], child_result["fees"]["effective-includes"])
 
         # The node will broadcast each transaction, still abiding by its peer's fee filter
-        peer.wait_for_broadcast([tx["tx"].getwtxid() for tx in package_txns])
+        peer.wait_for_broadcast([tx["tx"].wtxid_hex for tx in package_txns])
 
         self.log.info("Check a package that passes mempoolminfee but is evicted immediately after submission")
         mempoolmin_feerate = node.getmempoolinfo()["mempoolminfee"]

test/functional/mempool_package_onemore.py

@@ -60,8 +60,8 @@ def run_test(self):
         txns_hex = [tx.serialize().hex() for tx in txns]
         assert_equal(self.nodes[0].testmempoolaccept(txns_hex)[0]["reject-reason"], "too-long-mempool-chain")
         pkg_result = self.nodes[0].submitpackage(txns_hex)
-        assert "too-long-mempool-chain" in pkg_result["tx-results"][txns[0].getwtxid()]["error"]
-        assert_equal(pkg_result["tx-results"][txns[1].getwtxid()]["error"], "bad-txns-inputs-missingorspent")
+        assert "too-long-mempool-chain" in pkg_result["tx-results"][txns[0].wtxid_hex]["error"]
+        assert_equal(pkg_result["tx-results"][txns[1].wtxid_hex]["error"], "bad-txns-inputs-missingorspent")
         # But not if it chains directly off the first transaction
         self.nodes[0].sendrawtransaction(replaceable_tx["hex"])
         # and the second chain should work just fine

test/functional/mempool_reorg.py

@@ -73,7 +73,7 @@ def test_reorg_relay(self):
         # request very recent, unanounced transactions.
         assert_equal(len(peer1.get_invs()), 0)
         # It's too early to request these two transactions
-        requests_too_recent = msg_getdata([CInv(t=MSG_WTX, h=int(tx["tx"].getwtxid(), 16)) for tx in [tx_before_reorg, tx_child]])
+        requests_too_recent = msg_getdata([CInv(t=MSG_WTX, h=int(tx["tx"].wtxid_hex, 16)) for tx in [tx_before_reorg, tx_child]])
         peer1.send_and_ping(requests_too_recent)
         for _ in range(len(requests_too_recent.inv)):
             peer1.sync_with_ping()
@@ -82,15 +82,15 @@ def test_reorg_relay(self):
             assert "notfound" in peer1.last_message
 
         # Request the tx from the disconnected block
-        request_disconnected_tx = msg_getdata([CInv(t=MSG_WTX, h=int(tx_disconnected["tx"].getwtxid(), 16))])
+        request_disconnected_tx = msg_getdata([CInv(t=MSG_WTX, h=int(tx_disconnected["tx"].wtxid_hex, 16))])
         peer1.send_and_ping(request_disconnected_tx)
 
         # The tx from the disconnected block was never announced, and it entered the mempool later
         # than the transactions that are too recent.
         assert_equal(len(peer1.get_invs()), 0)
         with p2p_lock:
             # However, the node will answer requests for the tx from the recently-disconnected block.
-            assert_equal(peer1.last_message["tx"].tx.getwtxid(),tx_disconnected["tx"].getwtxid())
+            assert_equal(peer1.last_message["tx"].tx.wtxid_hex,tx_disconnected["tx"].wtxid_hex)
 
         self.nodes[1].setmocktime(int(time.time()) + 300)
         peer1.sync_with_ping()
@@ -102,7 +102,7 @@ def test_reorg_relay(self):
         last_tx_received = peer1.last_message["tx"]
 
         tx_after_reorg = self.wallet.send_self_transfer(from_node=self.nodes[1])
-        request_after_reorg = msg_getdata([CInv(t=MSG_WTX, h=int(tx_after_reorg["tx"].getwtxid(), 16))])
+        request_after_reorg = msg_getdata([CInv(t=MSG_WTX, h=int(tx_after_reorg["tx"].wtxid_hex, 16))])
         assert tx_after_reorg["txid"] in self.nodes[1].getrawmempool()
         peer1.send_and_ping(request_after_reorg)
         with p2p_lock:

test/functional/mempool_sigoplimit.py

@@ -168,7 +168,7 @@ def create_bare_multisig_tx(utxo_to_spend=None):
 
         # When we actually try to submit, the parent makes it into the mempool, but the child would exceed ancestor vsize limits
         res = self.nodes[0].submitpackage([tx_parent.serialize().hex(), tx_child.serialize().hex()])
-        assert "too-long-mempool-chain" in res["tx-results"][tx_child.getwtxid()]["error"]
+        assert "too-long-mempool-chain" in res["tx-results"][tx_child.wtxid_hex]["error"]
         assert tx_parent.txid_hex in self.nodes[0].getrawmempool()
 
         # Transactions are tiny in weight