[move only] remove `is_wallet_compiled` checks

1 files changed, 127 insertions, 138 deletions

diff --git a/test/functional/interface_zmq.py b/test/functional/interface_zmq.py
index 6a8b5168df..7d8d10589b 100755
--- a/test/functional/interface_zmq.py
+++ b/test/functional/interface_zmq.py
@@ -103,8 +103,6 @@ class ZMQTestSetupBlock:
 class ZMQTest (BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
-        if self.is_wallet_compiled():
-            self.requires_wallet = True
         # This test isn't testing txn relay/timing, so set whitelist on the
         # peers for instant txn relay. This speeds up the test run time 2-3x.
         self.extra_args = [["-whitelist=noban@127.0.0.1"]] * self.num_nodes
@@ -215,26 +213,25 @@ class ZMQTest (BitcoinTestFramework):
             assert_equal([txid.hex()], self.nodes[1].getblock(hash)["tx"])
 
 
-        if self.is_wallet_compiled():
-            self.wallet.rescan_utxos()
-            self.log.info("Wait for tx from second node")
-            payment_tx = self.wallet.send_self_transfer(from_node=self.nodes[1])
-            payment_txid = payment_tx['txid']
-            self.sync_all()
-            # Should receive the broadcasted txid.
-            txid = hashtx.receive()
-            assert_equal(payment_txid, txid.hex())
+        self.wallet.rescan_utxos()
+        self.log.info("Wait for tx from second node")
+        payment_tx = self.wallet.send_self_transfer(from_node=self.nodes[1])
+        payment_txid = payment_tx['txid']
+        self.sync_all()
+        # Should receive the broadcasted txid.
+        txid = hashtx.receive()
+        assert_equal(payment_txid, txid.hex())
 
-            # Should receive the broadcasted raw transaction.
-            hex = rawtx.receive()
-            assert_equal(payment_tx['wtxid'], hash256_reversed(hex).hex())
+        # Should receive the broadcasted raw transaction.
+        hex = rawtx.receive()
+        assert_equal(payment_tx['wtxid'], hash256_reversed(hex).hex())
 
-            # Mining the block with this tx should result in second notification
-            # after coinbase tx notification
-            self.generatetoaddress(self.nodes[0], 1, ADDRESS_BCRT1_UNSPENDABLE)
-            hashtx.receive()
-            txid = hashtx.receive()
-            assert_equal(payment_txid, txid.hex())
+        # Mining the block with this tx should result in second notification
+        # after coinbase tx notification
+        self.generatetoaddress(self.nodes[0], 1, ADDRESS_BCRT1_UNSPENDABLE)
+        hashtx.receive()
+        txid = hashtx.receive()
+        assert_equal(payment_txid, txid.hex())
 
 
         self.log.info("Test the getzmqnotifications RPC")
@@ -248,9 +245,6 @@ class ZMQTest (BitcoinTestFramework):
         assert_equal(self.nodes[1].getzmqnotifications(), [])
 
     def test_reorg(self):
-        if not self.is_wallet_compiled():
-            self.log.info("Skipping reorg test because wallet is disabled")
-            return
 
         address = 'tcp://127.0.0.1:28333'
 
@@ -330,129 +324,124 @@ class ZMQTest (BitcoinTestFramework):
         assert_equal((self.nodes[1].getblockhash(block_count-1), "C", None), seq.receive_sequence())
         assert_equal((self.nodes[1].getblockhash(block_count), "C", None), seq.receive_sequence())
 
-        # Rest of test requires wallet functionality
-        if self.is_wallet_compiled():
-            self.log.info("Wait for tx from second node")
-            payment_tx = self.wallet.send_self_transfer(from_node=self.nodes[1])
-            payment_txid = payment_tx['txid']
-            self.sync_all()
-            self.log.info("Testing sequence notifications with mempool sequence values")
-
-            # Should receive the broadcasted txid.
-            assert_equal((payment_txid, "A", seq_num), seq.receive_sequence())
-            seq_num += 1
-
-            self.log.info("Testing RBF notification")
-            # Replace it to test eviction/addition notification
-            payment_tx['tx'].vout[0].nValue -= 1000
-            rbf_txid = self.nodes[1].sendrawtransaction(payment_tx['tx'].serialize().hex())
-            self.sync_all()
-            assert_equal((payment_txid, "R", seq_num), seq.receive_sequence())
-            seq_num += 1
-            assert_equal((rbf_txid, "A", seq_num), seq.receive_sequence())
-            seq_num += 1
-
-            # Doesn't get published when mined, make a block and tx to "flush" the possibility
-            # though the mempool sequence number does go up by the number of transactions
-            # removed from the mempool by the block mining it.
-            mempool_size = len(self.nodes[0].getrawmempool())
-            c_block = self.generatetoaddress(self.nodes[0], 1, ADDRESS_BCRT1_UNSPENDABLE)[0]
-            # Make sure the number of mined transactions matches the number of txs out of mempool
-            mempool_size_delta = mempool_size - len(self.nodes[0].getrawmempool())
-            assert_equal(len(self.nodes[0].getblock(c_block)["tx"])-1, mempool_size_delta)
-            seq_num += mempool_size_delta
-            payment_txid_2 = self.wallet.send_self_transfer(from_node=self.nodes[1])['txid']
-            self.sync_all()
-            assert_equal((c_block, "C", None), seq.receive_sequence())
-            assert_equal((payment_txid_2, "A", seq_num), seq.receive_sequence())
-            seq_num += 1
-
-            # Spot check getrawmempool results that they only show up when asked for
-            assert type(self.nodes[0].getrawmempool()) is list
-            assert type(self.nodes[0].getrawmempool(mempool_sequence=False)) is list
-            assert "mempool_sequence" not in self.nodes[0].getrawmempool(verbose=True)
-            assert_raises_rpc_error(-8, "Verbose results cannot contain mempool sequence values.", self.nodes[0].getrawmempool, True, True)
-            assert_equal(self.nodes[0].getrawmempool(mempool_sequence=True)["mempool_sequence"], seq_num)
-
-            self.log.info("Testing reorg notifications")
-            # Manually invalidate the last block to test mempool re-entry
-            # N.B. This part could be made more lenient in exact ordering
-            # since it greatly depends on inner-workings of blocks/mempool
-            # during "deep" re-orgs. Probably should "re-construct"
-            # blockchain/mempool state from notifications instead.
-            block_count = self.nodes[0].getblockcount()
-            best_hash = self.nodes[0].getbestblockhash()
-            self.nodes[0].invalidateblock(best_hash)
-            sleep(2)  # Bit of room to make sure transaction things happened
-
-            # Make sure getrawmempool mempool_sequence results aren't "queued" but immediately reflective
-            # of the time they were gathered.
-            assert self.nodes[0].getrawmempool(mempool_sequence=True)["mempool_sequence"] > seq_num
-
-            assert_equal((best_hash, "D", None), seq.receive_sequence())
-            assert_equal((rbf_txid, "A", seq_num), seq.receive_sequence())
-            seq_num += 1
-
-            # Other things may happen but aren't wallet-deterministic so we don't test for them currently
-            self.nodes[0].reconsiderblock(best_hash)
-            self.generatetoaddress(self.nodes[1], 1, ADDRESS_BCRT1_UNSPENDABLE)
-
-            self.log.info("Evict mempool transaction by block conflict")
-            orig_tx = self.wallet.send_self_transfer(from_node=self.nodes[0])
-            orig_txid = orig_tx['txid']
-
-            # More to be simply mined
-            more_tx = []
-            for _ in range(5):
-                more_tx.append(self.wallet.send_self_transfer(from_node=self.nodes[0]))
-
-            orig_tx['tx'].vout[0].nValue -= 1000
-            bump_txid = self.nodes[0].sendrawtransaction(orig_tx['tx'].serialize().hex())
-            # Mine the pre-bump tx
-            txs_to_add = [orig_tx['hex']] + [tx['hex'] for tx in more_tx]
-            block = create_block(int(self.nodes[0].getbestblockhash(), 16), create_coinbase(self.nodes[0].getblockcount()+1), txlist=txs_to_add)
-            add_witness_commitment(block)
-            block.solve()
-            assert_equal(self.nodes[0].submitblock(block.serialize().hex()), None)
-            tip = self.nodes[0].getbestblockhash()
-            assert_equal(int(tip, 16), block.sha256)
-            orig_txid_2 = self.wallet.send_self_transfer(from_node=self.nodes[0])['txid']
-
-            # Flush old notifications until evicted tx original entry
+        self.log.info("Wait for tx from second node")
+        payment_tx = self.wallet.send_self_transfer(from_node=self.nodes[1])
+        payment_txid = payment_tx['txid']
+        self.sync_all()
+        self.log.info("Testing sequence notifications with mempool sequence values")
+
+        # Should receive the broadcasted txid.
+        assert_equal((payment_txid, "A", seq_num), seq.receive_sequence())
+        seq_num += 1
+
+        self.log.info("Testing RBF notification")
+        # Replace it to test eviction/addition notification
+        payment_tx['tx'].vout[0].nValue -= 1000
+        rbf_txid = self.nodes[1].sendrawtransaction(payment_tx['tx'].serialize().hex())
+        self.sync_all()
+        assert_equal((payment_txid, "R", seq_num), seq.receive_sequence())
+        seq_num += 1
+        assert_equal((rbf_txid, "A", seq_num), seq.receive_sequence())
+        seq_num += 1
+
+        # Doesn't get published when mined, make a block and tx to "flush" the possibility
+        # though the mempool sequence number does go up by the number of transactions
+        # removed from the mempool by the block mining it.
+        mempool_size = len(self.nodes[0].getrawmempool())
+        c_block = self.generatetoaddress(self.nodes[0], 1, ADDRESS_BCRT1_UNSPENDABLE)[0]
+        # Make sure the number of mined transactions matches the number of txs out of mempool
+        mempool_size_delta = mempool_size - len(self.nodes[0].getrawmempool())
+        assert_equal(len(self.nodes[0].getblock(c_block)["tx"])-1, mempool_size_delta)
+        seq_num += mempool_size_delta
+        payment_txid_2 = self.wallet.send_self_transfer(from_node=self.nodes[1])['txid']
+        self.sync_all()
+        assert_equal((c_block, "C", None), seq.receive_sequence())
+        assert_equal((payment_txid_2, "A", seq_num), seq.receive_sequence())
+        seq_num += 1
+
+        # Spot check getrawmempool results that they only show up when asked for
+        assert type(self.nodes[0].getrawmempool()) is list
+        assert type(self.nodes[0].getrawmempool(mempool_sequence=False)) is list
+        assert "mempool_sequence" not in self.nodes[0].getrawmempool(verbose=True)
+        assert_raises_rpc_error(-8, "Verbose results cannot contain mempool sequence values.", self.nodes[0].getrawmempool, True, True)
+        assert_equal(self.nodes[0].getrawmempool(mempool_sequence=True)["mempool_sequence"], seq_num)
+
+        self.log.info("Testing reorg notifications")
+        # Manually invalidate the last block to test mempool re-entry
+        # N.B. This part could be made more lenient in exact ordering
+        # since it greatly depends on inner-workings of blocks/mempool
+        # during "deep" re-orgs. Probably should "re-construct"
+        # blockchain/mempool state from notifications instead.
+        block_count = self.nodes[0].getblockcount()
+        best_hash = self.nodes[0].getbestblockhash()
+        self.nodes[0].invalidateblock(best_hash)
+        sleep(2)  # Bit of room to make sure transaction things happened
+
+        # Make sure getrawmempool mempool_sequence results aren't "queued" but immediately reflective
+        # of the time they were gathered.
+        assert self.nodes[0].getrawmempool(mempool_sequence=True)["mempool_sequence"] > seq_num
+
+        assert_equal((best_hash, "D", None), seq.receive_sequence())
+        assert_equal((rbf_txid, "A", seq_num), seq.receive_sequence())
+        seq_num += 1
+
+        # Other things may happen but aren't wallet-deterministic so we don't test for them currently
+        self.nodes[0].reconsiderblock(best_hash)
+        self.generatetoaddress(self.nodes[1], 1, ADDRESS_BCRT1_UNSPENDABLE)
+
+        self.log.info("Evict mempool transaction by block conflict")
+        orig_tx = self.wallet.send_self_transfer(from_node=self.nodes[0])
+        orig_txid = orig_tx['txid']
+
+        # More to be simply mined
+        more_tx = []
+        for _ in range(5):
+            more_tx.append(self.wallet.send_self_transfer(from_node=self.nodes[0]))
+
+        orig_tx['tx'].vout[0].nValue -= 1000
+        bump_txid = self.nodes[0].sendrawtransaction(orig_tx['tx'].serialize().hex())
+        # Mine the pre-bump tx
+        txs_to_add = [orig_tx['hex']] + [tx['hex'] for tx in more_tx]
+        block = create_block(int(self.nodes[0].getbestblockhash(), 16), create_coinbase(self.nodes[0].getblockcount()+1), txlist=txs_to_add)
+        add_witness_commitment(block)
+        block.solve()
+        assert_equal(self.nodes[0].submitblock(block.serialize().hex()), None)
+        tip = self.nodes[0].getbestblockhash()
+        assert_equal(int(tip, 16), block.sha256)
+        orig_txid_2 = self.wallet.send_self_transfer(from_node=self.nodes[0])['txid']
+
+        # Flush old notifications until evicted tx original entry
+        (hash_str, label, mempool_seq) = seq.receive_sequence()
+        while hash_str != orig_txid:
             (hash_str, label, mempool_seq) = seq.receive_sequence()
-            while hash_str != orig_txid:
-                (hash_str, label, mempool_seq) = seq.receive_sequence()
-            mempool_seq += 1
+        mempool_seq += 1
 
-            # Added original tx
-            assert_equal(label, "A")
-            # More transactions to be simply mined
-            for i in range(len(more_tx)):
-                assert_equal((more_tx[i]['txid'], "A", mempool_seq), seq.receive_sequence())
-                mempool_seq += 1
-            # Bumped by rbf
-            assert_equal((orig_txid, "R", mempool_seq), seq.receive_sequence())
-            mempool_seq += 1
-            assert_equal((bump_txid, "A", mempool_seq), seq.receive_sequence())
+        # Added original tx
+        assert_equal(label, "A")
+        # More transactions to be simply mined
+        for i in range(len(more_tx)):
+            assert_equal((more_tx[i]['txid'], "A", mempool_seq), seq.receive_sequence())
             mempool_seq += 1
-            # Conflict announced first, then block
-            assert_equal((bump_txid, "R", mempool_seq), seq.receive_sequence())
-            mempool_seq += 1
-            assert_equal((tip, "C", None), seq.receive_sequence())
-            mempool_seq += len(more_tx)
-            # Last tx
-            assert_equal((orig_txid_2, "A", mempool_seq), seq.receive_sequence())
-            mempool_seq += 1
-            self.generatetoaddress(self.nodes[0], 1, ADDRESS_BCRT1_UNSPENDABLE)
-            self.sync_all()  # want to make sure we didn't break "consensus" for other tests
+        # Bumped by rbf
+        assert_equal((orig_txid, "R", mempool_seq), seq.receive_sequence())
+        mempool_seq += 1
+        assert_equal((bump_txid, "A", mempool_seq), seq.receive_sequence())
+        mempool_seq += 1
+        # Conflict announced first, then block
+        assert_equal((bump_txid, "R", mempool_seq), seq.receive_sequence())
+        mempool_seq += 1
+        assert_equal((tip, "C", None), seq.receive_sequence())
+        mempool_seq += len(more_tx)
+        # Last tx
+        assert_equal((orig_txid_2, "A", mempool_seq), seq.receive_sequence())
+        mempool_seq += 1
+        self.generatetoaddress(self.nodes[0], 1, ADDRESS_BCRT1_UNSPENDABLE)
+        self.sync_all()  # want to make sure we didn't break "consensus" for other tests
 
     def test_mempool_sync(self):
         """
         Use sequence notification plus getrawmempool sequence results to "sync mempool"
         """
-        if not self.is_wallet_compiled():
-            self.log.info("Skipping mempool sync test")
-            return
 
         self.log.info("Testing 'mempool sync' usage of sequence notifier")
         [seq] = self.setup_zmq_test([("sequence", "tcp://127.0.0.1:28333")])