[tests] Change feature_block.py to use BitcoinTestFramework

1 files changed, 234 insertions, 243 deletions

diff --git a/test/functional/feature_block.py b/test/functional/feature_block.py
index ad6b9eb218..181c7f3369 100755
--- a/test/functional/feature_block.py
+++ b/test/functional/feature_block.py
@@ -8,11 +8,9 @@ import struct
 import time
 
 from test_framework.blocktools import create_block, create_coinbase, create_transaction, get_legacy_sigopcount_block
-from test_framework.comptool import RejectResult, TestInstance, TestManager
 from test_framework.key import CECKey
 from test_framework.messages import (
     CBlock,
-    CBlockHeader,
     COIN,
     COutPoint,
     CTransaction,
@@ -22,7 +20,7 @@ from test_framework.messages import (
     uint256_from_compact,
     uint256_from_str,
 )
-from test_framework.mininode import network_thread_start
+from test_framework.mininode import P2PDataStore, network_thread_start, network_thread_join
 from test_framework.script import (
     CScript,
     MAX_SCRIPT_ELEMENT_SIZE,
@@ -44,14 +42,8 @@ from test_framework.script import (
     SignatureHash,
     hash160,
 )
-from test_framework.test_framework import ComparisonTestFramework
-from test_framework.util import *
-from test_framework.comptool import TestManager, TestInstance, RejectResult
-from test_framework.blocktools import *
-import time
-from test_framework.key import CECKey
-from test_framework.script import *
-import struct
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal
 
 MAX_BLOCK_SIGOPS = 20000
 
@@ -63,9 +55,6 @@ class PreviousSpendableOutput():
 #  Use this class for tests that require behavior other than normal "mininode" behavior.
 #  For now, it is used to serialize a bloated varint (b64).
 class CBrokenBlock(CBlock):
-    def __init__(self, header=None):
-        super(CBrokenBlock, self).__init__(header)
-
     def initialize(self, base_block):
         self.vtx = copy.deepcopy(base_block.vtx)
         self.hashMerkleRoot = self.calc_merkle_root()
@@ -82,46 +71,43 @@ class CBrokenBlock(CBlock):
         return r
 
     def normal_serialize(self):
-        r = b""
-        r += super(CBrokenBlock, self).serialize()
-        return r
+        return super().serialize()
 
-class FullBlockTest(ComparisonTestFramework):
-    # Can either run this test as 1 node with expected answers, or two and compare them.
-    # Change the "outcome" variable from each TestInstance object to only do the comparison.
+class FullBlockTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.setup_clean_chain = True
+        self.extra_args = [[]]
+
+    def run_test(self):
+        node = self.nodes[0]  # convenience reference to the node
+
+        # reconnect_p2p() expects the network thread to be running
+        network_thread_start()
+
+        self.reconnect_p2p()
+
         self.block_heights = {}
         self.coinbase_key = CECKey()
         self.coinbase_key.set_secretbytes(b"horsebattery")
         self.coinbase_pubkey = self.coinbase_key.get_pubkey()
         self.tip = None
         self.blocks = {}
-
-    def run_test(self):
-        self.test = TestManager(self, self.options.tmpdir)
-        self.test.add_all_connections(self.nodes)
-        network_thread_start()
-        self.test.run()
-
-    def get_tests(self):
         self.genesis_hash = int(self.nodes[0].getbestblockhash(), 16)
         self.block_heights[self.genesis_hash] = 0
         self.spendable_outputs = []
 
         # Create a new block
-        self.next_block(0)
+        b0 = self.next_block(0)
         self.save_spendable_output()
-        yield self.accepted()
+        self.sync_blocks([b0])
 
-        #  Now we need that block to mature so we can spend the coinbase.
-        test = TestInstance(sync_every_block=False)
+        # Allow the block to mature
+        blocks = []
         for i in range(99):
-            self.next_block(5000 + i)
-            test.blocks_and_transactions.append([self.tip, True])
+            blocks.append(self.next_block(5000 + i))
             self.save_spendable_output()
-        yield test
+        self.sync_blocks(blocks)
 
         # collect spendable outputs now to avoid cluttering the code later on
         out = []
@@ -131,15 +117,15 @@ class FullBlockTest(ComparisonTestFramework):
         # Start by building a couple of blocks on top (which output is spent is
         # in parentheses):
         #     genesis -> b1 (0) -> b2 (1)
-        self.next_block(1, spend=out[0])
+        b1 = self.next_block(1, spend=out[0])
         self.save_spendable_output()
-        yield self.accepted()
 
-        self.next_block(2, spend=out[1])
-        yield self.accepted()
+        b2 = self.next_block(2, spend=out[1])
         self.save_spendable_output()
 
-        # so fork like this:
+        self.sync_blocks([b1, b2])
+
+        # Fork like this:
         #
         #     genesis -> b1 (0) -> b2 (1)
         #                      \-> b3 (1)
@@ -149,27 +135,27 @@ class FullBlockTest(ComparisonTestFramework):
         self.move_tip(1)
         b3 = self.next_block(3, spend=out[1])
         txout_b3 = PreviousSpendableOutput(b3.vtx[1], 0)
-        yield self.rejected()
+        self.sync_blocks([b3], False)
 
         # Now we add another block to make the alternative chain longer.
         #
         #     genesis -> b1 (0) -> b2 (1)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Reorg to a longer chain")
-        self.next_block(4, spend=out[2])
-        yield self.accepted()
+        b4 = self.next_block(4, spend=out[2])
+        self.sync_blocks([b4])
 
         # ... and back to the first chain.
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
         #                      \-> b3 (1) -> b4 (2)
         self.move_tip(2)
-        self.next_block(5, spend=out[2])
+        b5 = self.next_block(5, spend=out[2])
         self.save_spendable_output()
-        yield self.rejected()
+        self.sync_blocks([b5], False)
 
         self.log.info("Reorg back to the original chain")
-        self.next_block(6, spend=out[3])
-        yield self.accepted()
+        b6 = self.next_block(6, spend=out[3])
+        self.sync_blocks([b6], True)
 
         # Try to create a fork that double-spends
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
@@ -177,11 +163,11 @@ class FullBlockTest(ComparisonTestFramework):
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Reject a chain with a double spend, even if it is longer")
         self.move_tip(5)
-        self.next_block(7, spend=out[2])
-        yield self.rejected()
+        b7 = self.next_block(7, spend=out[2])
+        self.sync_blocks([b7], False)
 
-        self.next_block(8, spend=out[4])
-        yield self.rejected()
+        b8 = self.next_block(8, spend=out[4])
+        self.sync_blocks([b8], False, reconnect=True)
 
         # Try to create a block that has too much fee
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
@@ -189,8 +175,8 @@ class FullBlockTest(ComparisonTestFramework):
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Reject a block where the miner creates too much coinbase reward")
         self.move_tip(6)
-        self.next_block(9, spend=out[4], additional_coinbase_value=1)
-        yield self.rejected(RejectResult(16, b'bad-cb-amount'))
+        b9 = self.next_block(9, spend=out[4], additional_coinbase_value=1)
+        self.sync_blocks([b9], False, 16, b'bad-cb-amount', reconnect=True)
 
         # Create a fork that ends in a block with too much fee (the one that causes the reorg)
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
@@ -198,33 +184,27 @@ class FullBlockTest(ComparisonTestFramework):
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Reject a chain where the miner creates too much coinbase reward, even if the chain is longer")
         self.move_tip(5)
-        self.next_block(10, spend=out[3])
-        yield self.rejected()
+        b10 = self.next_block(10, spend=out[3])
+        self.sync_blocks([b10], False)
 
-        self.next_block(11, spend=out[4], additional_coinbase_value=1)
-        yield self.rejected(RejectResult(16, b'bad-cb-amount'))
+        b11 = self.next_block(11, spend=out[4], additional_coinbase_value=1)
+        self.sync_blocks([b11], False, 16, b'bad-cb-amount', reconnect=True)
 
         # Try again, but with a valid fork first
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b14 (5)
-        #                                              (b12 added last)
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Reject a chain where the miner creates too much coinbase reward, even if the chain is longer (on a forked chain)")
         self.move_tip(5)
         b12 = self.next_block(12, spend=out[3])
         self.save_spendable_output()
         b13 = self.next_block(13, spend=out[4])
-        # Deliver the block header for b12, and the block b13.
-        # b13 should be accepted but the tip won't advance until b12 is delivered.
-        yield TestInstance([[CBlockHeader(b12), None], [b13, False]])
-
         self.save_spendable_output()
-        # b14 is invalid, but the node won't know that until it tries to connect
-        # Tip still can't advance because b12 is missing
-        self.next_block(14, spend=out[5], additional_coinbase_value=1)
-        yield self.rejected()
+        b14 = self.next_block(14, spend=out[5], additional_coinbase_value=1)
+        self.sync_blocks([b12, b13, b14], False, 16, b'bad-cb-amount', reconnect=True)
 
-        yield TestInstance([[b12, True, b13.sha256]])  # New tip should be b13.
+        # New tip should be b13.
+        assert_equal(node.getbestblockhash(), b13.hash)
 
         # Add a block with MAX_BLOCK_SIGOPS and one with one more sigop
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
@@ -233,14 +213,14 @@ class FullBlockTest(ComparisonTestFramework):
         self.log.info("Accept a block with lots of checksigs")
         lots_of_checksigs = CScript([OP_CHECKSIG] * (MAX_BLOCK_SIGOPS - 1))
         self.move_tip(13)
-        self.next_block(15, spend=out[5], script=lots_of_checksigs)
-        yield self.accepted()
+        b15 = self.next_block(15, spend=out[5], script=lots_of_checksigs)
         self.save_spendable_output()
+        self.sync_blocks([b15], True)
 
         self.log.info("Reject a block with too many checksigs")
         too_many_checksigs = CScript([OP_CHECKSIG] * (MAX_BLOCK_SIGOPS))
-        self.next_block(16, spend=out[6], script=too_many_checksigs)
-        yield self.rejected(RejectResult(16, b'bad-blk-sigops'))
+        b16 = self.next_block(16, spend=out[6], script=too_many_checksigs)
+        self.sync_blocks([b16], False, 16, b'bad-blk-sigops', reconnect=True)
 
         # Attempt to spend a transaction created on a different fork
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
@@ -248,8 +228,8 @@ class FullBlockTest(ComparisonTestFramework):
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Reject a block with a spend from a re-org'ed out tx")
         self.move_tip(15)
-        self.next_block(17, spend=txout_b3)
-        yield self.rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
+        b17 = self.next_block(17, spend=txout_b3)
+        self.sync_blocks([b17], False, 16, b'bad-txns-inputs-missingorspent', reconnect=True)
 
         # Attempt to spend a transaction created on a different fork (on a fork this time)
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
@@ -258,11 +238,11 @@ class FullBlockTest(ComparisonTestFramework):
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Reject a block with a spend from a re-org'ed out tx (on a forked chain)")
         self.move_tip(13)
-        self.next_block(18, spend=txout_b3)
-        yield self.rejected()
+        b18 = self.next_block(18, spend=txout_b3)
+        self.sync_blocks([b18], False)
 
-        self.next_block(19, spend=out[6])
-        yield self.rejected()
+        b19 = self.next_block(19, spend=out[6])
+        self.sync_blocks([b19], False, 16, b'bad-txns-inputs-missingorspent', reconnect=True)
 
         # Attempt to spend a coinbase at depth too low
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
@@ -270,8 +250,8 @@ class FullBlockTest(ComparisonTestFramework):
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Reject a block spending an immature coinbase.")
         self.move_tip(15)
-        self.next_block(20, spend=out[7])
-        yield self.rejected(RejectResult(16, b'bad-txns-premature-spend-of-coinbase'))
+        b20 = self.next_block(20, spend=out[7])
+        self.sync_blocks([b20], False, 16, b'bad-txns-premature-spend-of-coinbase')
 
         # Attempt to spend a coinbase at depth too low (on a fork this time)
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
@@ -280,11 +260,11 @@ class FullBlockTest(ComparisonTestFramework):
         #                      \-> b3 (1) -> b4 (2)
         self.log.info("Reject a block spending an immature coinbase (on a forked chain)")
         self.move_tip(13)
-        self.next_block(21, spend=out[6])
-        yield self.rejected()
+        b21 = self.next_block(21, spend=out[6])
+        self.sync_blocks([b21], False)
 
-        self.next_block(22, spend=out[5])
-        yield self.rejected()
+        b22 = self.next_block(22, spend=out[5])
+        self.sync_blocks([b22], False, 16, b'bad-txns-premature-spend-of-coinbase')
 
         # Create a block on either side of MAX_BLOCK_BASE_SIZE and make sure its accepted/rejected
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
@@ -302,7 +282,7 @@ class FullBlockTest(ComparisonTestFramework):
         b23 = self.update_block(23, [tx])
         # Make sure the math above worked out to produce a max-sized block
         assert_equal(len(b23.serialize()), MAX_BLOCK_BASE_SIZE)
-        yield self.accepted()
+        self.sync_blocks([b23], True)
         self.save_spendable_output()
 
         self.log.info("Reject a block of size MAX_BLOCK_BASE_SIZE + 1")
@@ -313,10 +293,10 @@ class FullBlockTest(ComparisonTestFramework):
         tx.vout = [CTxOut(0, script_output)]
         b24 = self.update_block(24, [tx])
         assert_equal(len(b24.serialize()), MAX_BLOCK_BASE_SIZE + 1)
-        yield self.rejected(RejectResult(16, b'bad-blk-length'))
+        self.sync_blocks([b24], False, 16, b'bad-blk-length', reconnect=True)
 
-        self.next_block(25, spend=out[7])
-        yield self.rejected()
+        b25 = self.next_block(25, spend=out[7])
+        self.sync_blocks([b25], False)
 
         # Create blocks with a coinbase input script size out of range
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
@@ -331,11 +311,11 @@ class FullBlockTest(ComparisonTestFramework):
         # update_block causes the merkle root to get updated, even with no new
         # transactions, and updates the required state.
         b26 = self.update_block(26, [])
-        yield self.rejected(RejectResult(16, b'bad-cb-length'))
+        self.sync_blocks([b26], False, 16, b'bad-cb-length', reconnect=True)
 
         # Extend the b26 chain to make sure bitcoind isn't accepting b26
-        self.next_block(27, spend=out[7])
-        yield self.rejected(False)
+        b27 = self.next_block(27, spend=out[7])
+        self.sync_blocks([b27], False)
 
         # Now try a too-large-coinbase script
         self.move_tip(15)
@@ -343,11 +323,11 @@ class FullBlockTest(ComparisonTestFramework):
         b28.vtx[0].vin[0].scriptSig = b'\x00' * 101
         b28.vtx[0].rehash()
         b28 = self.update_block(28, [])
-        yield self.rejected(RejectResult(16, b'bad-cb-length'))
+        self.sync_blocks([b28], False, 16, b'bad-cb-length', reconnect=True)
 
         # Extend the b28 chain to make sure bitcoind isn't accepting b28
-        self.next_block(29, spend=out[7])
-        yield self.rejected(False)
+        b29 = self.next_block(29, spend=out[7])
+        self.sync_blocks([b29], False)
 
         # b30 has a max-sized coinbase scriptSig.
         self.move_tip(23)
@@ -355,7 +335,7 @@ class FullBlockTest(ComparisonTestFramework):
         b30.vtx[0].vin[0].scriptSig = b'\x00' * 100
         b30.vtx[0].rehash()
         b30 = self.update_block(30, [])
-        yield self.accepted()
+        self.sync_blocks([b30], True)
         self.save_spendable_output()
 
         # b31 - b35 - check sigops of OP_CHECKMULTISIG / OP_CHECKMULTISIGVERIFY / OP_CHECKSIGVERIFY
@@ -371,7 +351,7 @@ class FullBlockTest(ComparisonTestFramework):
         lots_of_multisigs = CScript([OP_CHECKMULTISIG] * ((MAX_BLOCK_SIGOPS - 1) // 20) + [OP_CHECKSIG] * 19)
         b31 = self.next_block(31, spend=out[8], script=lots_of_multisigs)
         assert_equal(get_legacy_sigopcount_block(b31), MAX_BLOCK_SIGOPS)
-        yield self.accepted()
+        self.sync_blocks([b31], True)
         self.save_spendable_output()
 
         # this goes over the limit because the coinbase has one sigop
@@ -379,33 +359,33 @@ class FullBlockTest(ComparisonTestFramework):
         too_many_multisigs = CScript([OP_CHECKMULTISIG] * (MAX_BLOCK_SIGOPS // 20))
         b32 = self.next_block(32, spend=out[9], script=too_many_multisigs)
         assert_equal(get_legacy_sigopcount_block(b32), MAX_BLOCK_SIGOPS + 1)
-        yield self.rejected(RejectResult(16, b'bad-blk-sigops'))
+        self.sync_blocks([b32], False, 16, b'bad-blk-sigops', reconnect=True)
 
         # CHECKMULTISIGVERIFY
         self.log.info("Accept a block with the max number of OP_CHECKMULTISIGVERIFY sigops")
         self.move_tip(31)
         lots_of_multisigs = CScript([OP_CHECKMULTISIGVERIFY] * ((MAX_BLOCK_SIGOPS - 1) // 20) + [OP_CHECKSIG] * 19)
-        self.next_block(33, spend=out[9], script=lots_of_multisigs)
-        yield self.accepted()
+        b33 = self.next_block(33, spend=out[9], script=lots_of_multisigs)
+        self.sync_blocks([b33], True)
         self.save_spendable_output()
 
         self.log.info("Reject a block with too many OP_CHECKMULTISIGVERIFY sigops")
         too_many_multisigs = CScript([OP_CHECKMULTISIGVERIFY] * (MAX_BLOCK_SIGOPS // 20))
-        self.next_block(34, spend=out[10], script=too_many_multisigs)
-        yield self.rejected(RejectResult(16, b'bad-blk-sigops'))
+        b34 = self.next_block(34, spend=out[10], script=too_many_multisigs)
+        self.sync_blocks([b34], False, 16, b'bad-blk-sigops', reconnect=True)
 
         # CHECKSIGVERIFY
         self.log.info("Accept a block with the max number of OP_CHECKSIGVERIFY sigops")
         self.move_tip(33)
         lots_of_checksigs = CScript([OP_CHECKSIGVERIFY] * (MAX_BLOCK_SIGOPS - 1))
         b35 = self.next_block(35, spend=out[10], script=lots_of_checksigs)
-        yield self.accepted()
+        self.sync_blocks([b35], True)
         self.save_spendable_output()
 
         self.log.info("Reject a block with too many OP_CHECKSIGVERIFY sigops")
         too_many_checksigs = CScript([OP_CHECKSIGVERIFY] * (MAX_BLOCK_SIGOPS))
-        self.next_block(36, spend=out[11], script=too_many_checksigs)
-        yield self.rejected(RejectResult(16, b'bad-blk-sigops'))
+        b36 = self.next_block(36, spend=out[11], script=too_many_checksigs)
+        self.sync_blocks([b36], False, 16, b'bad-blk-sigops', reconnect=True)
 
         # Check spending of a transaction in a block which failed to connect
         #
@@ -422,12 +402,12 @@ class FullBlockTest(ComparisonTestFramework):
         txout_b37 = PreviousSpendableOutput(b37.vtx[1], 0)
         tx = self.create_and_sign_transaction(out[11].tx, out[11].n, 0)
         b37 = self.update_block(37, [tx])
-        yield self.rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
+        self.sync_blocks([b37], False, 16, b'bad-txns-inputs-missingorspent', reconnect=True)
 
         # attempt to spend b37's first non-coinbase tx, at which point b37 was still considered valid
         self.move_tip(35)
-        self.next_block(38, spend=txout_b37)
-        yield self.rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
+        b38 = self.next_block(38, spend=txout_b37)
+        self.sync_blocks([b38], False, 16, b'bad-txns-inputs-missingorspent', reconnect=True)
 
         # Check P2SH SigOp counting
         #
@@ -477,7 +457,7 @@ class FullBlockTest(ComparisonTestFramework):
             b39_outputs += 1
 
         b39 = self.update_block(39, [])
-        yield self.accepted()
+        self.sync_blocks([b39], True)
         self.save_spendable_output()
 
         # Test sigops in P2SH redeem scripts
@@ -519,12 +499,12 @@ class FullBlockTest(ComparisonTestFramework):
         tx.rehash()
         new_txs.append(tx)
         self.update_block(40, new_txs)
-        yield self.rejected(RejectResult(16, b'bad-blk-sigops'))
+        self.sync_blocks([b40], False, 16, b'bad-blk-sigops', reconnect=True)
 
         # same as b40, but one less sigop
         self.log.info("Accept a block with the max number of P2SH sigops")
         self.move_tip(39)
-        self.next_block(41, spend=None)
+        b41 = self.next_block(41, spend=None)
         self.update_block(41, b40.vtx[1:-1])
         b41_sigops_to_fill = b40_sigops_to_fill - 1
         tx = CTransaction()
@@ -532,7 +512,7 @@ class FullBlockTest(ComparisonTestFramework):
         tx.vout.append(CTxOut(1, CScript([OP_CHECKSIG] * b41_sigops_to_fill)))
         tx.rehash()
         self.update_block(41, [tx])
-        yield self.accepted()
+        self.sync_blocks([b41], True)
 
         # Fork off of b39 to create a constant base again
         #
@@ -540,13 +520,12 @@ class FullBlockTest(ComparisonTestFramework):
         #                                                                  \-> b41 (12)
         #
         self.move_tip(39)
-        self.next_block(42, spend=out[12])
-        yield self.rejected()
+        b42 = self.next_block(42, spend=out[12])
         self.save_spendable_output()
 
-        self.next_block(43, spend=out[13])
-        yield self.accepted()
+        b43 = self.next_block(43, spend=out[13])
         self.save_spendable_output()
+        self.sync_blocks([b42, b43], True)
 
         # Test a number of really invalid scenarios
         #
@@ -568,7 +547,7 @@ class FullBlockTest(ComparisonTestFramework):
         self.tip = b44
         self.block_heights[b44.sha256] = height
         self.blocks[44] = b44
-        yield self.accepted()
+        self.sync_blocks([b44], True)
 
         self.log.info("Reject a block with a non-coinbase as the first tx")
         non_coinbase = self.create_tx(out[15].tx, out[15].n, 1)
@@ -583,7 +562,7 @@ class FullBlockTest(ComparisonTestFramework):
         self.block_heights[b45.sha256] = self.block_heights[self.tip.sha256] + 1
         self.tip = b45
         self.blocks[45] = b45
-        yield self.rejected(RejectResult(16, b'bad-cb-missing'))
+        self.sync_blocks([b45], False, 16, b'bad-cb-missing', reconnect=True)
 
         self.log.info("Reject a block with no transactions")
         self.move_tip(44)
@@ -598,44 +577,44 @@ class FullBlockTest(ComparisonTestFramework):
         self.tip = b46
         assert 46 not in self.blocks
         self.blocks[46] = b46
-        yield self.rejected(RejectResult(16, b'bad-blk-length'))
+        self.sync_blocks([b46], False, 16, b'bad-blk-length', reconnect=True)
 
         self.log.info("Reject a block with invalid work")
         self.move_tip(44)
         b47 = self.next_block(47, solve=False)
         target = uint256_from_compact(b47.nBits)
-        while b47.sha256 < target:  # changed > to <
+        while b47.sha256 < target:
             b47.nNonce += 1
             b47.rehash()
-        yield self.rejected(RejectResult(16, b'high-hash'))
+        self.sync_blocks([b47], False, request_block=False)
 
         self.log.info("Reject a block with a timestamp >2 hours in the future")
         self.move_tip(44)
         b48 = self.next_block(48, solve=False)
         b48.nTime = int(time.time()) + 60 * 60 * 3
         b48.solve()
-        yield self.rejected(RejectResult(16, b'time-too-new'))
+        self.sync_blocks([b48], False, request_block=False)
 
         self.log.info("Reject a block with invalid merkle hash")
         self.move_tip(44)
         b49 = self.next_block(49)
         b49.hashMerkleRoot += 1
         b49.solve()
-        yield self.rejected(RejectResult(16, b'bad-txnmrklroot'))
+        self.sync_blocks([b49], False, 16, b'bad-txnmrklroot', reconnect=True)
 
         self.log.info("Reject a block with incorrect POW limit")
         self.move_tip(44)
         b50 = self.next_block(50)
         b50.nBits = b50.nBits - 1
         b50.solve()
-        yield self.rejected(RejectResult(16, b'bad-diffbits'))
+        self.sync_blocks([b50], False, request_block=False, reconnect=True)
 
         self.log.info("Reject a block with two coinbase transactions")
         self.move_tip(44)
-        self.next_block(51)
+        b51 = self.next_block(51)
         cb2 = create_coinbase(51, self.coinbase_pubkey)
-        self.update_block(51, [cb2])
-        yield self.rejected(RejectResult(16, b'bad-cb-multiple'))
+        b51 = self.update_block(51, [cb2])
+        self.sync_blocks([b51], False, 16, b'bad-cb-multiple', reconnect=True)
 
         self.log.info("Reject a block with duplicate transactions")
         # Note: txns have to be in the right position in the merkle tree to trigger this error
@@ -643,32 +622,32 @@ class FullBlockTest(ComparisonTestFramework):
         b52 = self.next_block(52, spend=out[15])
         tx = self.create_tx(b52.vtx[1], 0, 1)
         b52 = self.update_block(52, [tx, tx])
-        yield self.rejected(RejectResult(16, b'bad-txns-duplicate'))
+        self.sync_blocks([b52], False, 16, b'bad-txns-duplicate', reconnect=True)
 
         # Test block timestamps
         #  -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15)
         #                                                                                   \-> b54 (15)
         #
         self.move_tip(43)
-        self.next_block(53, spend=out[14])
-        yield self.rejected()  # rejected since b44 is at same height
+        b53 = self.next_block(53, spend=out[14])
+        self.sync_blocks([b53], False)
         self.save_spendable_output()
 
         self.log.info("Reject a block with timestamp before MedianTimePast")
         b54 = self.next_block(54, spend=out[15])
         b54.nTime = b35.nTime - 1
         b54.solve()
-        yield self.rejected(RejectResult(16, b'time-too-old'))
+        self.sync_blocks([b54], False, request_block=False)
 
         # valid timestamp
         self.move_tip(53)
         b55 = self.next_block(55, spend=out[15])
         b55.nTime = b35.nTime
         self.update_block(55, [])
-        yield self.accepted()
+        self.sync_blocks([b55], True)
         self.save_spendable_output()
 
-        # Test CVE-2012-2459
+        # Test Merkle tree malleability
         #
         # -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57p2 (16)
         #                                                \-> b57   (16)
@@ -710,7 +689,7 @@ class FullBlockTest(ComparisonTestFramework):
         assert_equal(len(b56.vtx), 3)
         b56 = self.update_block(56, [tx1])
         assert_equal(b56.hash, b57.hash)
-        yield self.rejected(RejectResult(16, b'bad-txns-duplicate'))
+        self.sync_blocks([b56], False, 16, b'bad-txns-duplicate', reconnect=True)
 
         # b57p2 - a good block with 6 tx'es, don't submit until end
         self.move_tip(55)
@@ -730,13 +709,13 @@ class FullBlockTest(ComparisonTestFramework):
         assert_equal(b56p2.hash, b57p2.hash)
         assert_equal(len(b56p2.vtx), 6)
         b56p2 = self.update_block("b56p2", [tx3, tx4])
-        yield self.rejected(RejectResult(16, b'bad-txns-duplicate'))
+        self.sync_blocks([b56p2], False, 16, b'bad-txns-duplicate', reconnect=True)
 
         self.move_tip("57p2")
-        yield self.accepted()
+        self.sync_blocks([b57p2], True)
 
         self.move_tip(57)
-        yield self.rejected()  # rejected because 57p2 seen first
+        self.sync_blocks([b57], False)  # The tip is not updated because 57p2 seen first
         self.save_spendable_output()
 
         # Test a few invalid tx types
@@ -748,27 +727,27 @@ class FullBlockTest(ComparisonTestFramework):
         # tx with prevout.n out of range
         self.log.info("Reject a block with a transaction with prevout.n out of range")
         self.move_tip(57)
-        self.next_block(58, spend=out[17])
+        b58 = self.next_block(58, spend=out[17])
         tx = CTransaction()
         assert(len(out[17].tx.vout) < 42)
         tx.vin.append(CTxIn(COutPoint(out[17].tx.sha256, 42), CScript([OP_TRUE]), 0xffffffff))
         tx.vout.append(CTxOut(0, b""))
         tx.calc_sha256()
-        self.update_block(58, [tx])
-        yield self.rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
+        b58 = self.update_block(58, [tx])
+        self.sync_blocks([b58], False, 16, b'bad-txns-inputs-missingorspent', reconnect=True)
 
-        # tx with output value > input value out of range
+        # tx with output value > input value
         self.log.info("Reject a block with a transaction with outputs > inputs")
         self.move_tip(57)
-        self.next_block(59)
+        b59 = self.next_block(59)
         tx = self.create_and_sign_transaction(out[17].tx, out[17].n, 51 * COIN)
-        self.update_block(59, [tx])
-        yield self.rejected(RejectResult(16, b'bad-txns-in-belowout'))
+        b59 = self.update_block(59, [tx])
+        self.sync_blocks([b59], False, 16, b'bad-txns-in-belowout', reconnect=True)
 
         # reset to good chain
         self.move_tip(57)
         b60 = self.next_block(60, spend=out[17])
-        yield self.accepted()
+        self.sync_blocks([b60], True)
         self.save_spendable_output()
 
         # Test BIP30
@@ -783,11 +762,11 @@ class FullBlockTest(ComparisonTestFramework):
         self.log.info("Reject a block with a transaction with a duplicate hash of a previous transaction (BIP30)")
         self.move_tip(60)
         b61 = self.next_block(61, spend=out[18])
-        b61.vtx[0].vin[0].scriptSig = b60.vtx[0].vin[0].scriptSig  # equalize the coinbases
+        b61.vtx[0].vin[0].scriptSig = b60.vtx[0].vin[0].scriptSig  # Equalize the coinbases
         b61.vtx[0].rehash()
         b61 = self.update_block(61, [])
         assert_equal(b60.vtx[0].serialize(), b61.vtx[0].serialize())
-        yield self.rejected(RejectResult(16, b'bad-txns-BIP30'))
+        self.sync_blocks([b61], False, 16, b'bad-txns-BIP30', reconnect=True)
 
         # Test tx.isFinal is properly rejected (not an exhaustive tx.isFinal test, that should be in data-driven transaction tests)
         #
@@ -796,7 +775,7 @@ class FullBlockTest(ComparisonTestFramework):
         #
         self.log.info("Reject a block with a transaction with a nonfinal locktime")
         self.move_tip(60)
-        self.next_block(62)
+        b62 = self.next_block(62)
         tx = CTransaction()
         tx.nLockTime = 0xffffffff  # this locktime is non-final
         assert(out[18].n < len(out[18].tx.vout))
@@ -804,8 +783,8 @@ class FullBlockTest(ComparisonTestFramework):
         tx.vout.append(CTxOut(0, CScript([OP_TRUE])))
         assert(tx.vin[0].nSequence < 0xffffffff)
         tx.calc_sha256()
-        self.update_block(62, [tx])
-        yield self.rejected(RejectResult(16, b'bad-txns-nonfinal'))
+        b62 = self.update_block(62, [tx])
+        self.sync_blocks([b62], False, 16, b'bad-txns-nonfinal')
 
         # Test a non-final coinbase is also rejected
         #
@@ -819,7 +798,7 @@ class FullBlockTest(ComparisonTestFramework):
         b63.vtx[0].vin[0].nSequence = 0xDEADBEEF
         b63.vtx[0].rehash()
         b63 = self.update_block(63, [])
-        yield self.rejected(RejectResult(16, b'bad-txns-nonfinal'))
+        self.sync_blocks([b63], False, 16, b'bad-txns-nonfinal')
 
         #  This checks that a block with a bloated VARINT between the block_header and the array of tx such that
         #  the block is > MAX_BLOCK_BASE_SIZE with the bloated varint, but <= MAX_BLOCK_BASE_SIZE without the bloated varint,
@@ -853,10 +832,14 @@ class FullBlockTest(ComparisonTestFramework):
         tx.vin.append(CTxIn(COutPoint(b64a.vtx[1].sha256, 0)))
         b64a = self.update_block("64a", [tx])
         assert_equal(len(b64a.serialize()), MAX_BLOCK_BASE_SIZE + 8)
-        yield TestInstance([[self.tip, None]])
+        self.sync_blocks([b64a], False, 1, b'error parsing message')
 
-        # comptool workaround: to make sure b64 is delivered, manually erase b64a from blockstore
-        self.test.block_store.erase(b64a.sha256)
+        # bitcoind doesn't disconnect us for sending a bloated block, but if we subsequently
+        # resend the header message, it won't send us the getdata message again. Just
+        # disconnect and reconnect and then call sync_blocks.
+        # TODO: improve this test to be less dependent on P2P DOS behaviour.
+        node.disconnect_p2ps()
+        self.reconnect_p2p()
 
         self.move_tip(60)
         b64 = CBlock(b64a)
@@ -864,8 +847,8 @@ class FullBlockTest(ComparisonTestFramework):
         assert_equal(b64.hash, b64a.hash)
         assert_equal(len(b64.serialize()), MAX_BLOCK_BASE_SIZE)
         self.blocks[64] = b64
-        self.update_block(64, [])
-        yield self.accepted()
+        b64 = self.update_block(64, [])
+        self.sync_blocks([b64], True)
         self.save_spendable_output()
 
         # Spend an output created in the block itself
@@ -874,11 +857,11 @@ class FullBlockTest(ComparisonTestFramework):
         #
         self.log.info("Accept a block with a transaction spending an output created in the same block")
         self.move_tip(64)
-        self.next_block(65)
+        b65 = self.next_block(65)
         tx1 = self.create_and_sign_transaction(out[19].tx, out[19].n, out[19].tx.vout[0].nValue)
         tx2 = self.create_and_sign_transaction(tx1, 0, 0)
-        self.update_block(65, [tx1, tx2])
-        yield self.accepted()
+        b65 = self.update_block(65, [tx1, tx2])
+        self.sync_blocks([b65], True)
         self.save_spendable_output()
 
         # Attempt to spend an output created later in the same block
@@ -887,11 +870,11 @@ class FullBlockTest(ComparisonTestFramework):
         #                                                                                    \-> b66 (20)
         self.log.info("Reject a block with a transaction spending an output created later in the same block")
         self.move_tip(65)
-        self.next_block(66)
+        b66 = self.next_block(66)
         tx1 = self.create_and_sign_transaction(out[20].tx, out[20].n, out[20].tx.vout[0].nValue)
         tx2 = self.create_and_sign_transaction(tx1, 0, 1)
-        self.update_block(66, [tx2, tx1])
-        yield self.rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
+        b66 = self.update_block(66, [tx2, tx1])
+        self.sync_blocks([b66], False, 16, b'bad-txns-inputs-missingorspent', reconnect=True)
 
         # Attempt to double-spend a transaction created in a block
         #
@@ -901,12 +884,12 @@ class FullBlockTest(ComparisonTestFramework):
         #
         self.log.info("Reject a block with a transaction double spending a transaction creted in the same block")
         self.move_tip(65)
-        self.next_block(67)
+        b67 = self.next_block(67)
         tx1 = self.create_and_sign_transaction(out[20].tx, out[20].n, out[20].tx.vout[0].nValue)
         tx2 = self.create_and_sign_transaction(tx1, 0, 1)
         tx3 = self.create_and_sign_transaction(tx1, 0, 2)
-        self.update_block(67, [tx1, tx2, tx3])
-        yield self.rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
+        b67 = self.update_block(67, [tx1, tx2, tx3])
+        self.sync_blocks([b67], False, 16, b'bad-txns-inputs-missingorspent', reconnect=True)
 
         # More tests of block subsidy
         #
@@ -922,17 +905,17 @@ class FullBlockTest(ComparisonTestFramework):
         #
         self.log.info("Reject a block trying to claim too much subsidy in the coinbase transaction")
         self.move_tip(65)
-        self.next_block(68, additional_coinbase_value=10)
+        b68 = self.next_block(68, additional_coinbase_value=10)
         tx = self.create_and_sign_transaction(out[20].tx, out[20].n, out[20].tx.vout[0].nValue - 9)
-        self.update_block(68, [tx])
-        yield self.rejected(RejectResult(16, b'bad-cb-amount'))
+        b68 = self.update_block(68, [tx])
+        self.sync_blocks([b68], False, 16, b'bad-cb-amount', reconnect=True)
 
         self.log.info("Accept a block claiming the correct subsidy in the coinbase transaction")
         self.move_tip(65)
         b69 = self.next_block(69, additional_coinbase_value=10)
         tx = self.create_and_sign_transaction(out[20].tx, out[20].n, out[20].tx.vout[0].nValue - 10)
         self.update_block(69, [tx])
-        yield self.accepted()
+        self.sync_blocks([b69], True)
         self.save_spendable_output()
 
         # Test spending the outpoint of a non-existent transaction
@@ -942,14 +925,14 @@ class FullBlockTest(ComparisonTestFramework):
         #
         self.log.info("Reject a block containing a transaction spending from a non-existent input")
         self.move_tip(69)
-        self.next_block(70, spend=out[21])
+        b70 = self.next_block(70, spend=out[21])
         bogus_tx = CTransaction()
         bogus_tx.sha256 = uint256_from_str(b"23c70ed7c0506e9178fc1a987f40a33946d4ad4c962b5ae3a52546da53af0c5c")
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(bogus_tx.sha256, 0), b"", 0xffffffff))
         tx.vout.append(CTxOut(1, b""))
-        self.update_block(70, [tx])
-        yield self.rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
+        b70 = self.update_block(70, [tx])
+        self.sync_blocks([b70], False, 16, b'bad-txns-inputs-missingorspent', reconnect=True)
 
         # Test accepting an invalid block which has the same hash as a valid one (via merkle tree tricks)
         #
@@ -957,7 +940,7 @@ class FullBlockTest(ComparisonTestFramework):
         #                                                                                      \-> b71 (21)
         #
         # b72 is a good block.
-        # b71 is a copy of 72, but re-adds one of its transactions.  However, it has the same hash as b71.
+        # b71 is a copy of 72, but re-adds one of its transactions.  However, it has the same hash as b72.
         self.log.info("Reject a block containing a duplicate transaction but with the same Merkle root (Merkle tree malleability")
         self.move_tip(69)
         b72 = self.next_block(72)
@@ -974,9 +957,10 @@ class FullBlockTest(ComparisonTestFramework):
         assert_equal(b72.sha256, b71.sha256)
 
         self.move_tip(71)
-        yield self.rejected(RejectResult(16, b'bad-txns-duplicate'))
+        self.sync_blocks([b71], False, 16, b'bad-txns-duplicate', reconnect=True)
+
         self.move_tip(72)
-        yield self.accepted()
+        self.sync_blocks([b72], True)
         self.save_spendable_output()
 
         # Test some invalid scripts and MAX_BLOCK_SIGOPS
@@ -1011,7 +995,7 @@ class FullBlockTest(ComparisonTestFramework):
         tx = self.create_and_sign_transaction(out[22].tx, 0, 1, CScript(a))
         b73 = self.update_block(73, [tx])
         assert_equal(get_legacy_sigopcount_block(b73), MAX_BLOCK_SIGOPS + 1)
-        yield self.rejected(RejectResult(16, b'bad-blk-sigops'))
+        self.sync_blocks([b73], False, 16, b'bad-blk-sigops', reconnect=True)
 
         # b74/75 - if we push an invalid script element, all prevous sigops are counted,
         #          but sigops after the element are not counted.
@@ -1025,7 +1009,7 @@ class FullBlockTest(ComparisonTestFramework):
         #       b75 succeeds because we put MAX_BLOCK_SIGOPS before the element
         self.log.info("Check sigops are counted correctly after an invalid script element")
         self.move_tip(72)
-        self.next_block(74)
+        b74 = self.next_block(74)
         size = MAX_BLOCK_SIGOPS - 1 + MAX_SCRIPT_ELEMENT_SIZE + 42  # total = 20,561
         a = bytearray([OP_CHECKSIG] * size)
         a[MAX_BLOCK_SIGOPS] = 0x4e
@@ -1034,11 +1018,11 @@ class FullBlockTest(ComparisonTestFramework):
         a[MAX_BLOCK_SIGOPS + 3] = 0xff
         a[MAX_BLOCK_SIGOPS + 4] = 0xff
         tx = self.create_and_sign_transaction(out[22].tx, 0, 1, CScript(a))
-        self.update_block(74, [tx])
-        yield self.rejected(RejectResult(16, b'bad-blk-sigops'))
+        b74 = self.update_block(74, [tx])
+        self.sync_blocks([b74], False, 16, b'bad-blk-sigops', reconnect=True)
 
         self.move_tip(72)
-        self.next_block(75)
+        b75 = self.next_block(75)
         size = MAX_BLOCK_SIGOPS - 1 + MAX_SCRIPT_ELEMENT_SIZE + 42
         a = bytearray([OP_CHECKSIG] * size)
         a[MAX_BLOCK_SIGOPS - 1] = 0x4e
@@ -1047,19 +1031,19 @@ class FullBlockTest(ComparisonTestFramework):
         a[MAX_BLOCK_SIGOPS + 2] = 0xff
         a[MAX_BLOCK_SIGOPS + 3] = 0xff
         tx = self.create_and_sign_transaction(out[22].tx, 0, 1, CScript(a))
-        self.update_block(75, [tx])
-        yield self.accepted()
+        b75 = self.update_block(75, [tx])
+        self.sync_blocks([b75], True)
         self.save_spendable_output()
 
         # Check that if we push an element filled with CHECKSIGs, they are not counted
         self.move_tip(75)
-        self.next_block(76)
+        b76 = self.next_block(76)
         size = MAX_BLOCK_SIGOPS - 1 + MAX_SCRIPT_ELEMENT_SIZE + 1 + 5
         a = bytearray([OP_CHECKSIG] * size)
         a[MAX_BLOCK_SIGOPS - 1] = 0x4e  # PUSHDATA4, but leave the following bytes as just checksigs
         tx = self.create_and_sign_transaction(out[23].tx, 0, 1, CScript(a))
-        self.update_block(76, [tx])
-        yield self.accepted()
+        b76 = self.update_block(76, [tx])
+        self.sync_blocks([b76], True)
         self.save_spendable_output()
 
         # Test transaction resurrection
@@ -1081,36 +1065,36 @@ class FullBlockTest(ComparisonTestFramework):
         #    updated.  (Perhaps to spend to a P2SH OP_TRUE script)
         self.log.info("Test transaction resurrection during a re-org")
         self.move_tip(76)
-        self.next_block(77)
+        b77 = self.next_block(77)
         tx77 = self.create_and_sign_transaction(out[24].tx, out[24].n, 10 * COIN)
-        self.update_block(77, [tx77])
-        yield self.accepted()
+        b77 = self.update_block(77, [tx77])
+        self.sync_blocks([b77], True)
         self.save_spendable_output()
 
-        self.next_block(78)
+        b78 = self.next_block(78)
         tx78 = self.create_tx(tx77, 0, 9 * COIN)
-        self.update_block(78, [tx78])
-        yield self.accepted()
+        b78 = self.update_block(78, [tx78])
+        self.sync_blocks([b78], True)
 
-        self.next_block(79)
+        b79 = self.next_block(79)
         tx79 = self.create_tx(tx78, 0, 8 * COIN)
-        self.update_block(79, [tx79])
-        yield self.accepted()
+        b79 = self.update_block(79, [tx79])
+        self.sync_blocks([b79], True)
 
         # mempool should be empty
         assert_equal(len(self.nodes[0].getrawmempool()), 0)
 
         self.move_tip(77)
-        self.next_block(80, spend=out[25])
-        yield self.rejected()
+        b80 = self.next_block(80, spend=out[25])
+        self.sync_blocks([b80], False, request_block=False)
         self.save_spendable_output()
 
-        self.next_block(81, spend=out[26])
-        yield self.rejected()  # other chain is same length
+        b81 = self.next_block(81, spend=out[26])
+        self.sync_blocks([b81], False, request_block=False)  # other chain is same length
         self.save_spendable_output()
 
-        self.next_block(82, spend=out[27])
-        yield self.accepted()  # now this chain is longer, triggers re-org
+        b82 = self.next_block(82, spend=out[27])
+        self.sync_blocks([b82], True)  # now this chain is longer, triggers re-org
         self.save_spendable_output()
 
         # now check that tx78 and tx79 have been put back into the peer's mempool
@@ -1124,7 +1108,7 @@ class FullBlockTest(ComparisonTestFramework):
         #  -> b81 (26) -> b82 (27) -> b83 (28)
         #
         self.log.info("Accept a block with invalid opcodes in dead execution paths")
-        self.next_block(83)
+        b83 = self.next_block(83)
         op_codes = [OP_IF, OP_INVALIDOPCODE, OP_ELSE, OP_TRUE, OP_ENDIF]
         script = CScript(op_codes)
         tx1 = self.create_and_sign_transaction(out[28].tx, out[28].n, out[28].tx.vout[0].nValue, script)
@@ -1133,8 +1117,8 @@ class FullBlockTest(ComparisonTestFramework):
         tx2.vin[0].scriptSig = CScript([OP_FALSE])
         tx2.rehash()
 
-        self.update_block(83, [tx1, tx2])
-        yield self.accepted()
+        b83 = self.update_block(83, [tx1, tx2])
+        self.sync_blocks([b83], True)
         self.save_spendable_output()
 
         # Reorg on/off blocks that have OP_RETURN in them (and try to spend them)
@@ -1143,7 +1127,7 @@ class FullBlockTest(ComparisonTestFramework):
         #                                    \-> b85 (29) -> b86 (30)            \-> b89a (32)
         #
         self.log.info("Test re-orging blocks with OP_RETURN in them")
-        self.next_block(84)
+        b84 = self.next_block(84)
         tx1 = self.create_tx(out[29].tx, out[29].n, 0, CScript([OP_RETURN]))
         tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
         tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
@@ -1160,37 +1144,37 @@ class FullBlockTest(ComparisonTestFramework):
         tx4.vout.append(CTxOut(0, CScript([OP_RETURN])))
         tx5 = self.create_tx(tx1, 4, 0, CScript([OP_RETURN]))
 
-        self.update_block(84, [tx1, tx2, tx3, tx4, tx5])
-        yield self.accepted()
+        b84 = self.update_block(84, [tx1, tx2, tx3, tx4, tx5])
+        self.sync_blocks([b84], True)
         self.save_spendable_output()
 
         self.move_tip(83)
-        self.next_block(85, spend=out[29])
-        yield self.rejected()
+        b85 = self.next_block(85, spend=out[29])
+        self.sync_blocks([b85], False)  # other chain is same length
 
-        self.next_block(86, spend=out[30])
-        yield self.accepted()
+        b86 = self.next_block(86, spend=out[30])
+        self.sync_blocks([b86], True)
 
         self.move_tip(84)
-        self.next_block(87, spend=out[30])
-        yield self.rejected()
+        b87 = self.next_block(87, spend=out[30])
+        self.sync_blocks([b87], False)  # other chain is same length
         self.save_spendable_output()
 
-        self.next_block(88, spend=out[31])
-        yield self.accepted()
+        b88 = self.next_block(88, spend=out[31])
+        self.sync_blocks([b88], True)
         self.save_spendable_output()
 
         # trying to spend the OP_RETURN output is rejected
-        self.next_block("89a", spend=out[32])
+        b89a = self.next_block("89a", spend=out[32])
         tx = self.create_tx(tx1, 0, 0, CScript([OP_TRUE]))
-        self.update_block("89a", [tx])
-        yield self.rejected()
+        b89a = self.update_block("89a", [tx])
+        self.sync_blocks([b89a], False, 16, b'bad-txns-inputs-missingorspent', reconnect=True)
 
         self.log.info("Test a re-org of one week's worth of blocks (1088 blocks)")
 
         self.move_tip(88)
         LARGE_REORG_SIZE = 1088
-        test1 = TestInstance(sync_every_block=False)
+        blocks = []
         spend = out[32]
         for i in range(89, LARGE_REORG_SIZE + 89):
             b = self.next_block(i, spend)
@@ -1201,33 +1185,30 @@ class FullBlockTest(ComparisonTestFramework):
             tx.vin.append(CTxIn(COutPoint(b.vtx[1].sha256, 0)))
             b = self.update_block(i, [tx])
             assert_equal(len(b.serialize()), MAX_BLOCK_BASE_SIZE)
-            test1.blocks_and_transactions.append([self.tip, True])
+            blocks.append(b)
             self.save_spendable_output()
             spend = self.get_spendable_output()
 
-        yield test1
+        self.sync_blocks(blocks, True, timeout=180)
         chain1_tip = i
 
         # now create alt chain of same length
         self.move_tip(88)
-        test2 = TestInstance(sync_every_block=False)
+        blocks2 = []
         for i in range(89, LARGE_REORG_SIZE + 89):
-            self.next_block("alt" + str(i))
-            test2.blocks_and_transactions.append([self.tip, False])
-        yield test2
+            blocks2.append(self.next_block("alt" + str(i)))
+        self.sync_blocks(blocks2, False, request_block=False)
 
         # extend alt chain to trigger re-org
-        self.next_block("alt" + str(chain1_tip + 1))
-        yield self.accepted()
+        block = self.next_block("alt" + str(chain1_tip + 1))
+        self.sync_blocks([block], True, timeout=180)
 
         # ... and re-org back to the first chain
         self.move_tip(chain1_tip)
-        self.next_block(chain1_tip + 1)
-        yield self.rejected()
-        self.next_block(chain1_tip + 2)
-        yield self.accepted()
-
-        chain1_tip += 2
+        block = self.next_block(chain1_tip + 1)
+        self.sync_blocks([block], False, request_block=False)
+        block = self.next_block(chain1_tip + 2)
+        self.sync_blocks([block], True, timeout=180)
 
     # Helper methods
     ################
@@ -1238,8 +1219,7 @@ class FullBlockTest(ComparisonTestFramework):
 
     # this is a little handier to use than the version in blocktools.py
     def create_tx(self, spend_tx, n, value, script=CScript([OP_TRUE])):
-        tx = create_transaction(spend_tx, n, b"", value, script)
-        return tx
+        return create_transaction(spend_tx, n, b"", value, script)
 
     # sign a transaction, using the key we know about
     # this signs input 0 in tx, which is assumed to be spending output n in spend_tx
@@ -1289,23 +1269,14 @@ class FullBlockTest(ComparisonTestFramework):
 
     # save the current tip so it can be spent by a later block
     def save_spendable_output(self):
+        self.log.debug("saving spendable output %s" % self.tip.vtx[0])
         self.spendable_outputs.append(self.tip)
 
     # get an output that we previously marked as spendable
     def get_spendable_output(self):
+        self.log.debug("getting spendable output %s" % self.spendable_outputs[0].vtx[0])
         return PreviousSpendableOutput(self.spendable_outputs.pop(0).vtx[0], 0)
 
-    # returns a test case that asserts that the current tip was accepted
-    def accepted(self):
-        return TestInstance([[self.tip, True]])
-
-    # returns a test case that asserts that the current tip was rejected
-    def rejected(self, reject=None):
-        if reject is None:
-            return TestInstance([[self.tip, False]])
-        else:
-            return TestInstance([[self.tip, reject]])
-
     # move the tip back to a previous block
     def move_tip(self, number):
         self.tip = self.blocks[number]
@@ -1325,6 +1296,26 @@ class FullBlockTest(ComparisonTestFramework):
         self.blocks[block_number] = block
         return block
 
+    def reconnect_p2p(self):
+        """Add a P2P connection to the node.
+
+        The node gets disconnected several times in this test. This helper
+        method reconnects the p2p and restarts the network thread."""
+
+        network_thread_join()
+        self.nodes[0].disconnect_p2ps()
+        self.nodes[0].add_p2p_connection(P2PDataStore())
+        network_thread_start()
+        self.nodes[0].p2p.wait_for_verack()
+
+    def sync_blocks(self, blocks, success=True, reject_code=None, reject_reason=None, request_block=True, reconnect=False, timeout=60):
+        """Sends blocks to test node. Syncs and verifies that tip has advanced to most recent block.
+
+        Call with success = False if the tip shouldn't advance to the most recent block."""
+        self.nodes[0].p2p.send_blocks_and_test(blocks, self.nodes[0], success=success, reject_code=reject_code, reject_reason=reject_reason, request_block=request_block, timeout=timeout)
+
+        if reconnect:
+            self.reconnect_p2p()
 
 if __name__ == '__main__':
     FullBlockTest().main()